/* -*- Mode: C -*- ====================================================================== FILE: regression.c CREATOR: eric 03 April 1999 DESCRIPTION: $Id: regression.c,v 1.67 2008-02-03 16:10:48 dothebart Exp $ $Locker: $ (C) COPYRIGHT 1999 Eric Busboom http://www.softwarestudio.org The contents of this file are subject to the Mozilla Public License Version 1.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. The original author is Eric Busboom The original code is regression.c ======================================================================*/ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #include "regression.h" #include #include /* for strdup */ #include /* for malloc */ #include /* for printf */ #include /* for time() */ #ifndef WIN32 #include /* for unlink, fork */ #include /* For waitpid */ #include /* for select */ #else #include /* for mkdir */ #include #endif #include /* For wait pid */ /* For GNU libc, strcmp appears to be a macro, so using strcmp in assert results in incomprehansible assertion messages. This eliminates the problem */ int regrstrcmp(const char* a, const char* b){ return strcmp(a,b); } /* This example creates and minipulates the ical object that appears * in rfc 2445, page 137 */ /* static char str[] = "BEGIN:VCALENDAR\ PRODID:\"-//RDU Software//NONSGML HandCal//EN\"\ VERSION:2.0\ BEGIN:VTIMEZONE\ TZID:America/New_York\ BEGIN:STANDARD\ DTSTART:19981025T020000\ RDATE:19981025T020000\ TZOFFSETFROM:-0400\ TZOFFSETTO:-0500\ TZNAME:EST\ END:STANDARD\ BEGIN:DAYLIGHT\ DTSTART:19990404T020000\ RDATE:19990404T020000\ TZOFFSETFROM:-0500\ TZOFFSETTO:-0400\ TZNAME:EDT\ END:DAYLIGHT\ END:VTIMEZONE\ BEGIN:VEVENT\ DTSTAMP:19980309T231000Z\ UID:guid-1.host1.com\ ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com\ ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com\ DESCRIPTION:Project XYZ Review Meeting\ CATEGORIES:MEETING\ CLASS:PUBLIC\ CREATED:19980309T130000Z\ SUMMARY:XYZ Project Review\ DTSTART;TZID=America/New_York:19980312T083000\ DTEND;TZID=America/New_York:19980312T093000\ LOCATION:1CP Conference Room 4350\ END:VEVENT\ BEGIN:BOOGA\ DTSTAMP:19980309T231000Z\ X-LIC-FOO:Booga\ DTSTOMP:19980309T231000Z\ UID:guid-1.host1.com\ END:BOOGA\ END:VCALENDAR"; */ /* Return a list of all attendees who are required. */ /* static char** get_required_attendees(icalcomponent* event) { icalproperty* p; icalparameter* parameter; char **attendees; int max = 10; int c = 0; attendees = malloc(max * (sizeof (char *))); ok("event is non null", (event != 0)); int_is("event is a VEVENT", icalcomponent_isa(event), ICAL_VEVENT_COMPONENT); for( p = icalcomponent_get_first_property(event,ICAL_ATTENDEE_PROPERTY); p != 0; p = icalcomponent_get_next_property(event,ICAL_ATTENDEE_PROPERTY) ) { parameter = icalproperty_get_first_parameter(p,ICAL_ROLE_PARAMETER); if ( icalparameter_get_role(parameter) == ICAL_ROLE_REQPARTICIPANT) { attendees[c++] = icalmemory_strdup(icalproperty_get_attendee(p)); if (c >= max) { max *= 2; attendees = realloc(attendees, max * (sizeof (char *))); } } } return attendees; } */ /* If an attendee has a PARTSTAT of NEEDSACTION or has no PARTSTAT parameter, change it to TENTATIVE. */ /* static void update_attendees(icalcomponent* event) { icalproperty* p; icalparameter* parameter; assert(event != 0); assert(icalcomponent_isa(event) == ICAL_VEVENT_COMPONENT); for( p = icalcomponent_get_first_property(event,ICAL_ATTENDEE_PROPERTY); p != 0; p = icalcomponent_get_next_property(event,ICAL_ATTENDEE_PROPERTY) ) { parameter = icalproperty_get_first_parameter(p,ICAL_PARTSTAT_PARAMETER); if (parameter == 0) { icalproperty_add_parameter( p, icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE) ); } else if (icalparameter_get_partstat(parameter) == ICAL_PARTSTAT_NEEDSACTION) { icalproperty_remove_parameter_by_ref(p,parameter); icalparameter_free(parameter); icalproperty_add_parameter( p, icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE) ); } } } */ void test_values() { icalvalue *v; icalvalue *copy; v = icalvalue_new_caladdress("cap://value/1"); is("icalvalue_new_caladdress()", icalvalue_get_caladdress(v), "cap://value/1"); icalvalue_set_caladdress(v,"cap://value/2"); is("icalvalue_set_caladdress()", icalvalue_get_caladdress(v), "cap://value/2"); is("icalvalue_as_ical_string()", icalvalue_as_ical_string(v), "cap://value/2"); copy = icalvalue_new_clone(v); is("icalvalue_new_clone()", icalvalue_as_ical_string(copy), "cap://value/2"); icalvalue_free(v); icalvalue_free(copy); v = icalvalue_new_boolean(1); int_is("icalvalue_new_boolean(1)", icalvalue_get_boolean(v), 1); icalvalue_set_boolean(v,2); ok("icalvalue_set_boolean(2)", (2 == icalvalue_get_boolean(v))); is("icalvalue_as_ical_string()", icalvalue_as_ical_string(v), "2"); copy = icalvalue_new_clone(v); is("icalvalue_new_clone()", icalvalue_as_ical_string(copy), "2"); icalvalue_free(v); icalvalue_free(copy); v = icalvalue_new_x("test"); is("icalvalue_new_x(test)", icalvalue_get_x(v), "test"); icalvalue_set_x(v, "test2"); is("icalvalue_set_x(test2)", icalvalue_get_x(v), "test2"); is("icalvalue_as_ical_string()", icalvalue_as_ical_string(v), "test2"); copy = icalvalue_new_clone(v); is("icalvalue_new_clone()", icalvalue_as_ical_string(copy), "test2"); icalvalue_free(v); icalvalue_free(copy); v = icalvalue_new_date(icaltime_from_timet( 1023404802,0)); is("icalvalue_new_date()", icalvalue_as_ical_string(v), "20020606T230642"); icalvalue_set_date(v,icaltime_from_timet( 1023404802-3600,0)); is("icalvalue_set_date()",icalvalue_as_ical_string(v), "20020606T220642"); copy = icalvalue_new_clone(v); is("icalvalue_new_clone()",icalvalue_as_ical_string(v), "20020606T220642"); icalvalue_free(v); icalvalue_free(copy); v = icalvalue_new(-1); ok("icalvalue_new(-1), Invalid type", (v == NULL)); if (v!=0) icalvalue_free(v); ok("ICAL_BOOLEAN_VALUE",(ICAL_BOOLEAN_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_BOOLEAN))); ok("ICAL_UTCOFFSET_VALUE",(ICAL_UTCOFFSET_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_UTCOFFSET))); ok("ICAL_RECUR_VALUE", (ICAL_RECUR_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_RECUR))); ok("ICAL_CALADDRESS_VALUE",(ICAL_CALADDRESS_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_CALADDRESS))); ok("ICAL_PERIOD_VALUE", (ICAL_PERIOD_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_PERIOD))); ok("ICAL_BINARY_VALUE",(ICAL_BINARY_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_BINARY))); ok("ICAL_TEXT_VALUE",(ICAL_TEXT_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_TEXT))); ok("ICAL_DURATION_VALUE",(ICAL_DURATION_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_DURATION))); ok("ICAL_INTEGER_VALUE", (ICAL_INTEGER_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_INTEGER))); ok("ICAL_URI_VALUE", (ICAL_URI_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_URI))); ok("ICAL_FLOAT_VALUE",(ICAL_FLOAT_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_FLOAT))); ok("ICAL_X_VALUE",(ICAL_X_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_X))); ok("ICAL_DATETIME_VALUE",(ICAL_DATETIME_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_DATETIME))); ok("ICAL_DATE_TIME",(ICAL_DATE_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_DATE))); /* v = icalvalue_new_caladdress(0); printf("Bad string: %p\n",v); if (v!=0) icalvalue_free(v); */ icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR, ICAL_ERROR_NONFATAL); v = icalvalue_new_from_string(ICAL_RECUR_VALUE,"D2 #0"); ok("illegal recur value", (v == 0)); v = icalvalue_new_from_string(ICAL_TRIGGER_VALUE,"Gonk"); ok("illegal trigger value", (v == 0)); v = icalvalue_new_from_string(ICAL_REQUESTSTATUS_VALUE,"Gonk"); ok("illegal requeststatus value", (v == 0)); icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR, ICAL_ERROR_DEFAULT); } void test_properties() { icalproperty *prop; icalparameter *param; icalproperty *clone; char test_cn_str[128] = ""; char *test_cn_str_good = "A Common Name 1A Common Name 2A Common Name 3A Common Name 4"; char *test_ical_str_good = "COMMENT;CN=A Common Name 1;CN=A Common Name 2;CN=A Common Name 3;CN=A \r\n Common Name 4:Another Comment\r\n"; prop = icalproperty_vanew_comment( "Another Comment", icalparameter_new_cn("A Common Name 1"), icalparameter_new_cn("A Common Name 2"), icalparameter_new_cn("A Common Name 3"), icalparameter_new_cn("A Common Name 4"), (void *)0); for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER); param != 0; param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)) { const char *str = icalparameter_get_cn(param); if (VERBOSE) printf("Prop parameter: %s\n",icalparameter_get_cn(param)); strcat(test_cn_str, str); } is("fetching parameters", test_cn_str, test_cn_str_good); if (VERBOSE) printf("Prop value: %s\n",icalproperty_get_comment(prop)); is("icalproperty_get_comment()", icalproperty_get_comment(prop), "Another Comment"); if (VERBOSE) printf("As iCAL string:\n %s\n",icalproperty_as_ical_string(prop)); is("icalproperty_as_ical_string()", icalproperty_as_ical_string(prop), test_ical_str_good); clone = icalproperty_new_clone(prop); if (VERBOSE) printf("Clone:\n %s\n",icalproperty_as_ical_string(prop)); is("icalproperty_new_clone()", icalproperty_as_ical_string(prop), test_ical_str_good); icalproperty_free(clone); icalproperty_free(prop); prop = icalproperty_new(-1); ok("test icalproperty_new() with invalid type (-1)", (prop == NULL)); if (prop!=0) icalproperty_free(prop); } void test_utf8() { icalproperty *prop; char *utf8text = "aáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaá"; char *test_ical_str_good = "DESCRIPTION:\r\n" " aáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaá\r\n" " óaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóaáóa\r\n" " áóaáóaáóaáóaáóaáóaáóaáóaáóaá\r\n"; prop = icalproperty_new_description(utf8text); is("icalproperty_as_ical_string()", icalproperty_as_ical_string(prop), test_ical_str_good); icalproperty_free(prop); } void test_parameters() { icalparameter *p; int i; int enums[] = {ICAL_CUTYPE_INDIVIDUAL,ICAL_CUTYPE_RESOURCE,ICAL_FBTYPE_BUSY,ICAL_PARTSTAT_NEEDSACTION,ICAL_ROLE_NONPARTICIPANT,ICAL_XLICCOMPARETYPE_LESSEQUAL,ICAL_XLICERRORTYPE_MIMEPARSEERROR,-1}; char* str1 = "A Common Name"; p = icalparameter_new_cn(str1); is("icalparameter_new_cn()", icalparameter_get_cn(p), str1); is("icalparameter_as_ical_string()" ,icalparameter_as_ical_string(p),"CN=A Common Name"); icalparameter_free(p); p = icalparameter_new_from_string("PARTSTAT=ACCEPTED"); ok("PARTSTAT_PARAMETER", (icalparameter_isa(p) == ICAL_PARTSTAT_PARAMETER)); ok("PARTSTAT_ACCEPTED", (icalparameter_get_partstat(p) == ICAL_PARTSTAT_ACCEPTED)); icalparameter_free(p); p = icalparameter_new_from_string("ROLE=CHAIR"); ok("ROLE_PARAMETER", (icalparameter_isa(p) == ICAL_ROLE_PARAMETER)); ok("ROLE_CHAIR", (icalparameter_get_partstat(p) == ICAL_ROLE_CHAIR)); icalparameter_free(p); p = icalparameter_new_from_string("PARTSTAT=X-FOO"); ok("PARTSTAT_PARAMETER", (icalparameter_isa(p) == ICAL_PARTSTAT_PARAMETER)); ok("PARTSTAT_X", (icalparameter_get_partstat(p) == ICAL_PARTSTAT_X)); icalparameter_free(p); p = icalparameter_new_from_string("X-PARAM=X-FOO"); ok("X_PARAMETER", (icalparameter_isa(p) == ICAL_X_PARAMETER)); icalparameter_free(p); for (i=0;enums[i] != -1; i++){ if (VERBOSE) printf("%s\n",icalparameter_enum_to_string(enums[i])); ok("test paramter enums", (icalparameter_string_to_enum(icalparameter_enum_to_string(enums[i]))==enums[i])); } } char *good_child = "BEGIN:VEVENT\r\n" "VERSION:2.0\r\n" "DESCRIPTION:This is an event\r\n" "COMMENT;CN=A Common Name 1;CN=A Common Name 2;CN=A Common Name 3;CN=A \r\n" " Common Name 4:Another Comment\r\n" "X-LIC-ERROR;X-LIC-ERRORTYPE=COMPONENT-PARSE-ERROR:This is only a test\r\n" "END:VEVENT\r\n"; void test_components() { icalcomponent* c; icalcomponent* child; c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalproperty_new_version("2.0"), icalproperty_new_prodid("-//RDU Software//NONSGML HandCal//EN"), icalproperty_vanew_comment( "A Comment", icalparameter_new_cn("A Common Name 1"), (void *)0), icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_new_version("2.0"), icalproperty_new_description("This is an event"), icalproperty_vanew_comment( "Another Comment", icalparameter_new_cn("A Common Name 1"), icalparameter_new_cn("A Common Name 2"), icalparameter_new_cn("A Common Name 3"), icalparameter_new_cn("A Common Name 4"), (void *)0), icalproperty_vanew_xlicerror( "This is only a test", icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_COMPONENTPARSEERROR), (void *)0), 0 ), 0 ); if (VERBOSE) printf("Original Component:\n%s\n\n",icalcomponent_as_ical_string(c)); child = icalcomponent_get_first_component(c,ICAL_VEVENT_COMPONENT); ok("test icalcomponent_get_first_component()", (child != NULL)); if (VERBOSE) printf("Child Component:\n%s\n\n",icalcomponent_as_ical_string(child)); is("test results of child component", icalcomponent_as_ical_string(child), good_child); icalcomponent_free(c); } void test_memory() { size_t bufsize = 256; int i; char *p; char S1[] = "1) When in the Course of human events, "; char S2[] = "2) it becomes necessary for one people to dissolve the political bands which have connected them with another, "; char S3[] = "3) and to assume among the powers of the earth, "; char S4[] = "4) the separate and equal station to which the Laws of Nature and of Nature's God entitle them, "; char S5[] = "5) a decent respect to the opinions of mankind requires that they "; char S6[] = "6) should declare the causes which impel them to the separation. "; char S7[] = "7) We hold these truths to be self-evident, "; char S8[] = "8) that all men are created equal, "; /* char S9[] = "9) that they are endowed by their Creator with certain unalienable Rights, "; char S10[] = "10) that among these are Life, Liberty, and the pursuit of Happiness. "; char S11[] = "11) That to secure these rights, Governments are instituted among Men, "; char S12[] = "12) deriving their just powers from the consent of the governed. "; */ char *f, *b1, *b2, *b3, *b4, *b5, *b6, *b7, *b8; #define BUFSIZE 1024 f = icalmemory_new_buffer(bufsize); p = f; b1 = icalmemory_tmp_buffer(BUFSIZE); strcpy(b1, S1); icalmemory_append_string(&f, &p, &bufsize, b1); b2 = icalmemory_tmp_buffer(BUFSIZE); strcpy(b2, S2); icalmemory_append_string(&f, &p, &bufsize, b2); b3 = icalmemory_tmp_buffer(BUFSIZE); strcpy(b3, S3); icalmemory_append_string(&f, &p, &bufsize, b3); b4 = icalmemory_tmp_buffer(BUFSIZE); strcpy(b4, S4); icalmemory_append_string(&f, &p, &bufsize, b4); b5 = icalmemory_tmp_buffer(BUFSIZE); strcpy(b5, S5); icalmemory_append_string(&f, &p, &bufsize, b5); b6 = icalmemory_tmp_buffer(BUFSIZE); strcpy(b6, S6); icalmemory_append_string(&f, &p, &bufsize, b6); b7 = icalmemory_tmp_buffer(BUFSIZE); strcpy(b7, S7); icalmemory_append_string(&f, &p, &bufsize, b7); b8 = icalmemory_tmp_buffer(BUFSIZE); strcpy(b8, S8); icalmemory_append_string(&f, &p, &bufsize, b8); if (VERBOSE) { printf("1: %p %s \n",b1,b1); printf("2: %p %s\n",b2,b2); printf("3: %p %s\n",b3,b3); printf("4: %p %s\n",b4,b4); printf("5: %p %s\n",b5,b5); printf("6: %p %s\n",b6,b6); printf("7: %p %s\n",b7,b7); printf("8: %p %s\n",b8,b8); printf("Final: %s\n", f); printf("Final buffer size: %zd\n",bufsize); } ok("final buffer size == 806", (bufsize == 806)); free(f); bufsize = 4; f = icalmemory_new_buffer(bufsize); memset(f,0,bufsize); p = f; icalmemory_append_char(&f, &p, &bufsize, 'a'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'b'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'c'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'd'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'e'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'f'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'g'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'h'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'i'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'j'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'a'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'b'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'c'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'd'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'e'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'f'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'g'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'h'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'i'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'j'); if (VERBOSE) printf("Char-by-Char buffer: %s\n", f); free(f); for(i=0; i<100; i++){ f = icalmemory_tmp_buffer(bufsize); assert(f!=0); memset(f,0,bufsize); sprintf(f,"%d",i); } } void test_dirset() { icalcomponent *c; icalgauge *gauge; icalerrorenum error; icalcomponent *next, *itr; icalset* cluster; icalset *s, *s2; struct icalperiodtype rtime; int i; int count = 0; #ifndef _WIN32 mkdir("store", 0755); mkdir("store-new", 0755); #else mkdir("store"); mkdir("store-new"); #endif s = icaldirset_new("store"); s2 = icaldirset_new("store-new"); ok("opening 'store' dirset", s!=NULL); ok("opening 'store-new' dirset", s2!=NULL); rtime.start = icaltime_from_timet( time(0),0); cluster = icalfileset_new("clusterin.vcd"); if (cluster == 0){ printf("Failed to create cluster: %s\n",icalerror_strerror(icalerrno)); } #define NUMCOMP 4 /* Duplicate every component in the cluster NUMCOMP times */ icalerror_clear_errno(); for (i = 1; i */ void test_recur_parameter_bug(){ static const char test_icalcomp_str[] = "BEGIN:VEVENT\r\n" "RRULE;X-EVOLUTION-ENDDATE=20030209T081500:FREQ=DAILY;COUNT=10;INTERVAL=6\r\n" "END:VEVENT\r\n"; icalcomponent *icalcomp; icalproperty *prop; struct icalrecurrencetype recur; int n_errors; char *str; icalcomp = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string()",(icalcomp!=NULL)); assert(icalcomp!=NULL); str = icalcomponent_as_ical_string(icalcomp); is("parsed matches original", str, (char*)test_icalcomp_str); if (VERBOSE) printf("%s\n\n",str); n_errors = icalcomponent_count_errors (icalcomp); int_is("no parse errors", n_errors, 0); if (n_errors) { icalproperty *p; for (p = icalcomponent_get_first_property (icalcomp, ICAL_XLICERROR_PROPERTY); p; p = icalcomponent_get_next_property (icalcomp, ICAL_XLICERROR_PROPERTY)) { const char *str; str = icalproperty_as_ical_string (p); fprintf (stderr, "error: %s\n", str); } } prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY); ok("get RRULE property", (prop!=NULL)); assert(prop!=NULL); recur = icalproperty_get_rrule (prop); if (VERBOSE) printf("%s\n",icalrecurrencetype_as_string(&recur)); icalcomponent_free(icalcomp); } void test_duration() { struct icaldurationtype d; d = icaldurationtype_from_string("PT8H30M"); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); int_is("PT8H30M", icaldurationtype_as_int(d), 30600); d = icaldurationtype_from_string("-PT8H30M"); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); int_is("-PT8H30M", icaldurationtype_as_int(d), -30600); d = icaldurationtype_from_string("PT10H10M10S"); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); int_is("PT10H10M10S", icaldurationtype_as_int(d), 36610); d = icaldurationtype_from_string("P7W"); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); int_is("P7W", icaldurationtype_as_int(d), 4233600); d = icaldurationtype_from_string("P2DT8H30M"); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); int_is("P2DT8H30M", icaldurationtype_as_int(d), 203400); d = icaldurationtype_from_string("P2W1DT5H"); if (VERBOSE) printf("%s %d\n",icaldurationtype_as_ical_string(d), icaldurationtype_as_int(d)); int_is("P2W1DT5H", icaldurationtype_as_int(d), 1314000); icalerror_errors_are_fatal = 0; /* Test conversion of bad input */ d = icaldurationtype_from_int(1314000); if (VERBOSE) printf("%s %d\n",icaldurationtype_as_ical_string(d), icaldurationtype_as_int(d)); is("1314000", icaldurationtype_as_ical_string(d), "P15DT5H"); d = icaldurationtype_from_string("P-2DT8H30M"); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); int_is("P-2DT8H30M", icaldurationtype_as_int(d), 0); d = icaldurationtype_from_string("P7W8H"); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); int_is("P7W8H", icaldurationtype_as_int(d), 0); d = icaldurationtype_from_string("T10H"); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); int_is("T10H", icaldurationtype_as_int(d), 0); icalerror_errors_are_fatal = 1; d = icaldurationtype_from_int(4233600); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); is("P7W", icaldurationtype_as_ical_string(d), "P7W"); d = icaldurationtype_from_int(4424400); if (VERBOSE) printf("%s\n",icaldurationtype_as_ical_string(d)); is("P51DT5H", icaldurationtype_as_ical_string(d), "P51DT5H"); } void test_period() { struct icalperiodtype p; icalvalue *v; char *str; str = "19971015T050000Z/PT8H30M"; p = icalperiodtype_from_string(str); is(str, icalperiodtype_as_ical_string(p),str); str = "19971015T050000Z/19971015T060000Z"; p = icalperiodtype_from_string(str); is(str, icalperiodtype_as_ical_string(p),str); str = "19970101T120000/PT3H"; v = icalvalue_new_from_string(ICAL_PERIOD_VALUE,str); is(str, icalvalue_as_ical_string(v), str); icalvalue_free(v); } void test_strings(){ icalvalue *v; v = icalvalue_new_text("foo;bar;bats"); if (VERBOSE) printf("%s\n",icalvalue_as_ical_string(v)); is("test encoding of 'foo;bar;bats'", "foo\\;bar\\;bats", icalvalue_as_ical_string(v)); icalvalue_free(v); v = icalvalue_new_text("foo\\;b\nar\\;ba\tts"); if (VERBOSE) printf("%s\n",icalvalue_as_ical_string(v)); is("test encoding of 'foo\\\\;b\\nar\\\\;ba\\tts'", "foo\\\\\\;b\\nar\\\\\\;ba\\tts", icalvalue_as_ical_string(v)); icalvalue_free(v); } #ifdef INVALID_TEST /* This test is invalid because parameters may not have control chars, such as '\n' */ void test_tzid_escape(){ icalparameter *tzid; icalproperty *prop; tzid = icalparameter_new_tzid("Timezone\nwith a newline"); prop = icalproperty_new_dtstart(icaltime_from_day_of_year(26, 2009)); icalproperty_add_parameter(prop, tzid); if (VERBOSE) printf("%s\n",icalproperty_as_ical_string(prop)); is("test encoding of 'Timezone\\nwith a newline'", icalproperty_as_ical_string(prop), "DTSTART;VALUE=DATE,TZID=Timezone\\nwith a newline:20090126"); icalproperty_free(prop); } #endif void test_requeststat() { icalcomponent *c; icalproperty *p; icalrequeststatus s; struct icalreqstattype st, st2; char temp[1024]; static const char test_icalcomp_str[] = "BEGIN:VEVENT\n" "REQUEST-STATUS:2.1;Success but fallback taken on one or more property values.;booga\n" "END:VEVENT\n"; s = icalenum_num_to_reqstat(2,1); ok("icalenum_num_to_reqstat(2,1)",(s == ICAL_2_1_FALLBACK_STATUS)); ok("icalenum_reqstat_major()",(icalenum_reqstat_major(s) == 2)); ok("icalenum_reqstat_minor()",(icalenum_reqstat_minor(s) == 1)); is ("icalenum_reqstat_desc() -> 2.1", icalenum_reqstat_desc(s), "Success but fallback taken on one or more property values."); st.code = s; st.debug = "booga"; st.desc = 0; is("icalreqstattype_as_string()", icalreqstattype_as_string(st), "2.1;Success but fallback taken on one or more property values.;booga"); st.desc = " A non-standard description"; is("icalreqstattype_as_string() w/ non standard description", icalreqstattype_as_string(st), "2.1; A non-standard description;booga"); st.desc = 0; sprintf(temp,"%s\n",icalreqstattype_as_string(st)); st2 = icalreqstattype_from_string("2.1;Success but fallback taken on one or more property values.;booga"); /* printf("%d -- %d -- %s -- %s\n",*/ ok("icalenum_reqstat_major()",(icalenum_reqstat_major(st2.code) == 2)); ok("icalenum_reqstat_minor()",(icalenum_reqstat_minor(st2.code) == 1)); is("icalenum_reqstat_desc", icalenum_reqstat_desc(st2.code), "Success but fallback taken on one or more property values."); st2 = icalreqstattype_from_string("2.1;Success but fallback taken on one or more property values.;booga"); if (VERBOSE) printf("%s\n",icalreqstattype_as_string(st2)); st2 = icalreqstattype_from_string("2.1;Success but fallback taken on one or more property values.;"); if (VERBOSE) printf("%s\n",icalreqstattype_as_string(st2)); st2 = icalreqstattype_from_string("2.1;Success but fallback taken on one or more property values."); if (VERBOSE) printf("%s\n",icalreqstattype_as_string(st2)); st2 = icalreqstattype_from_string("2.1;"); if (VERBOSE) printf("%s\n",icalreqstattype_as_string(st2)); is("st2 test again", icalreqstattype_as_string(st2), "2.1;Success but fallback taken on one or more property values."); st2 = icalreqstattype_from_string("2.1"); is("st2 test #3", icalreqstattype_as_string(st2), "2.1;Success but fallback taken on one or more property values."); c = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string()", (c != NULL)); if (!c) { exit (EXIT_FAILURE); } if (VERBOSE) printf("%s",icalcomponent_as_ical_string(c)); p = icalcomponent_get_first_property(c,ICAL_REQUESTSTATUS_PROPERTY); #if ADD_TESTS_REQUIRING_INVESTIGATION is("icalproperty_new_from_string()", icalproperty_as_ical_string(p), "REQUEST-STATUS:2.1;Success but fallback taken on one or more property \n values.;booga\n"); #endif icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL); st2 = icalreqstattype_from_string("16.4"); ok("test unknown code", (st2.code == ICAL_UNKNOWN_STATUS)); st2 = icalreqstattype_from_string("1."); ok("test malformed code", (st2.code == ICAL_UNKNOWN_STATUS)); icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_DEFAULT); icalproperty_free(p); } void test_dtstart(){ struct icaltimetype tt,tt2; icalproperty *p; tt = icaltime_from_string("19970101"); int_is("19970101 is a date", tt.is_date, 1); p = icalproperty_new_dtstart(tt); if (VERBOSE) printf("%s\n",icalvalue_kind_to_string(icalvalue_isa(icalproperty_get_value(p)))); ok("ICAL_DATE_VALUE", (icalvalue_isa(icalproperty_get_value(p))==ICAL_DATE_VALUE)); tt2 = icalproperty_get_dtstart(p); int_is("converted date is date", tt2.is_date, 1); if (VERBOSE) printf("%s\n",icalproperty_as_ical_string(p)); tt = icaltime_from_string("19970101T103000"); int_is("19970101T103000 is not a date", tt.is_date, 0); icalproperty_free(p); p = icalproperty_new_dtstart(tt); if (VERBOSE) printf("%s\n",icalvalue_kind_to_string(icalvalue_isa(icalproperty_get_value(p)))); ok("ICAL_DATETIME_VALUE", (icalvalue_isa(icalproperty_get_value(p))==ICAL_DATETIME_VALUE)); tt2 = icalproperty_get_dtstart(p); int_is("converted datetime is not date", tt2.is_date, 0); if (VERBOSE) printf("%s\n",icalproperty_as_ical_string(p)); icalproperty_free(p); } void do_test_time(char* zone) { struct icaltimetype ictt, icttutc, icttzone, icttdayl, icttla, icttny,icttphoenix, icttlocal, icttnorm; time_t tt,tt2, tt_p200; int offset_tz; icalvalue *v; short day_of_week,start_day_of_week, day_of_year; icaltimezone *azone, *utczone; char msg[256]; icalerror_errors_are_fatal = 0; azone = icaltimezone_get_builtin_timezone(zone); utczone = icaltimezone_get_utc_timezone(); /* Test new API */ if (VERBOSE) printf("\n---> From time_t \n"); tt = 1025127869; /* stick with a constant... */ if (VERBOSE) printf("Orig : %s\n",ical_timet_string(tt)); if (VERBOSE) printf("\nicaltime_from_timet(tt,0) (DEPRECATED)\n"); ictt = icaltime_from_timet(tt, 0); is("icaltime_from_timet(1025127869) as UTC", ictt_as_string(ictt), "2002-06-26 21:44:29 (floating)"); ictt = icaltime_from_timet_with_zone(tt, 0, NULL); is("Floating time from time_t", ictt_as_string(ictt), "2002-06-26 21:44:29 (floating)"); ictt = icaltime_from_timet_with_zone(tt, 0, azone); #if ADD_TESTS_REQUIRING_INVESTIGATION ok("icaltime_from_timet_with_zone(tt,0,zone) as zone", strncmp(ictt_as_string(ictt), "2002-06-26 21:44:29", 19)==0); #endif ictt = icaltime_from_timet_with_zone(tt, 0, utczone); is("icaltime_from_timet_with_zone(tt,0,utc)", ictt_as_string(ictt), "2002-06-26 21:44:29 Z UTC"); if (VERBOSE) printf("\n---> Convert from floating \n"); ictt = icaltime_from_timet_with_zone(tt, 0, NULL); icttutc = icaltime_convert_to_zone(ictt, utczone); is("Convert from floating to UTC", ictt_as_string(icttutc), "2002-06-26 21:44:29 Z UTC"); icttzone = icaltime_convert_to_zone(ictt, azone); ok("Convert from floating to zone", (strncmp(ictt_as_string(icttzone), "2002-06-26 21:44:29", 19)==0)); tt2 = icaltime_as_timet(icttzone); if (VERBOSE) printf("\n---> Convert from UTC \n"); ictt = icaltime_from_timet_with_zone(tt, 0, utczone); icttutc = icaltime_convert_to_zone(ictt, utczone); is("Convert from UTC to UTC", ictt_as_string(icttutc), "2002-06-26 21:44:29 Z UTC"); icttzone = icaltime_convert_to_zone(ictt, azone); ok("Convert from UTC to zone (test year/mon only..)", (strncmp(ictt_as_string(icttzone), "2002-06-26 21:44:29", 7)==0)); tt2 = icaltime_as_timet(icttzone); if (VERBOSE) printf("No conversion: %s\n", ical_timet_string(tt2)); ok("No conversion at all (test year/mon only)", (strncmp(ical_timet_string(tt2), "2002-06-26 21:44:29 Z",7) == 0)); tt2 = icaltime_as_timet_with_zone(icttzone, utczone); if (VERBOSE) printf("Back to UTC : %s\n", ical_timet_string(tt2)); ok("test time conversion routines",(tt==tt2)); if (VERBOSE) printf("\n---> Convert from zone \n"); ictt = icaltime_from_timet_with_zone(tt, 0, azone); icttzone = icaltime_convert_to_zone(ictt, azone); if (VERBOSE) printf("To zone : %s\n", ictt_as_string(icttzone)); icttutc = icaltime_convert_to_zone(ictt, utczone); if (VERBOSE) printf("To UTC : %s\n", ictt_as_string(icttutc)); tt2 = icaltime_as_timet(icttutc); if (VERBOSE) printf("No conversion: %s\n", ical_timet_string(tt2)); tt2 = icaltime_as_timet_with_zone(icttutc, azone); if (VERBOSE) printf("Back to zone : %s\n", ical_timet_string(tt2)); ok("test time conversion, round 2", (tt==tt2)); ictt = icaltime_from_string("20001103T183030Z"); tt = icaltime_as_timet(ictt); ok("test icaltime -> time_t for 20001103T183030Z", (tt==973276230)); /* Fri Nov 3 10:30:30 PST 2000 in PST Fri Nov 3 18:30:30 PST 2000 in UTC */ if (VERBOSE) { printf(" Normalize \n"); printf("Orig (ical) : %s\n", ictt_as_string(ictt)); } icttnorm = ictt; icttnorm.second -= 60 * 60 * 24 * 5; icttnorm = icaltime_normalize(icttnorm); if (VERBOSE) printf("-5d in sec : %s\n", ictt_as_string(icttnorm)); icttnorm.day += 60; icttnorm = icaltime_normalize(icttnorm); if (VERBOSE) printf("+60 d : %s\n", ictt_as_string(icttnorm)); /** add test case here.. **/ if (VERBOSE) printf("\n As time_t \n"); tt2 = icaltime_as_timet(ictt); if (VERBOSE) { printf("20001103T183030Z (timet): %s\n",ical_timet_string(tt2)); printf("20001103T183030Z : %s\n",ictt_as_string(ictt)); } /** this test is bogus **/ ok("test normalization", (tt2 == tt)); icttlocal = icaltime_convert_to_zone(ictt, azone); tt2 = icaltime_as_timet(icttlocal); if (VERBOSE) { printf("20001103T183030 (timet): %s\n",ical_timet_string(tt2)); printf("20001103T183030 : %s\n",ictt_as_string(icttlocal)); } offset_tz = -icaltimezone_get_utc_offset_of_utc_time(azone, &ictt, 0); /* FIXME */ if (VERBOSE) printf("offset_tz : %d\n",offset_tz); ok("test utc offset", (tt-tt2 == offset_tz)); /* FIXME with the new API, it's not very useful */ icttlocal = ictt; icaltimezone_convert_time(&icttlocal, icaltimezone_get_utc_timezone(), icaltimezone_get_builtin_timezone(zone)); if (VERBOSE) printf("As local : %s\n", ictt_as_string(icttlocal)); if (VERBOSE) printf("\n Convert to and from lib c \n"); if (VERBOSE) printf("System time is: %s\n",ical_timet_string(tt)); v = icalvalue_new_datetime(ictt); if (VERBOSE) printf("System time from libical: %s\n",icalvalue_as_ical_string(v)); icalvalue_free(v); tt2 = icaltime_as_timet(ictt); if (VERBOSE) printf("Converted back to libc: %s\n",ical_timet_string(tt2)); if (VERBOSE) printf("\n Incrementing time \n"); icttnorm = ictt; icttnorm.year++; tt2 = icaltime_as_timet(icttnorm); if (VERBOSE) printf("Add a year: %s\n",ical_timet_string(tt2)); icttnorm.month+=13; tt2 = icaltime_as_timet(icttnorm); if (VERBOSE) printf("Add 13 months: %s\n",ical_timet_string(tt2)); icttnorm.second+=90; tt2 = icaltime_as_timet(icttnorm); if (VERBOSE) printf("Add 90 seconds: %s\n",ical_timet_string(tt2)); if (VERBOSE) printf("\n Day Of week \n"); day_of_week = icaltime_day_of_week(ictt); start_day_of_week = icaltime_start_doy_of_week(ictt); day_of_year = icaltime_day_of_year(ictt); sprintf(msg, "Testing day of week %d", day_of_week); int_is(msg, day_of_week, 6); sprintf(msg, "Testing day of year %d",day_of_year); int_is(msg, day_of_year, 308); sprintf(msg, "Week started on doy of %d", start_day_of_week); int_is(msg, start_day_of_week , 303); if (VERBOSE) printf("\n TimeZone Conversions \n"); /* icttla = ictt; icaltimezone_convert_time(&icttla, icaltimezone_get_utc_timezone(), lazone); */ icttla = icaltime_convert_to_zone(ictt, icaltimezone_get_builtin_timezone("America/Los_Angeles")); #if ADD_TESTS_REQUIRING_INVESTIGATION int_is("Converted hour in America/Los_Angeles is 10", icttla.hour, 10); #endif icttutc = icaltime_convert_to_zone(icttla,icaltimezone_get_utc_timezone()); #if ADD_TESTS_REQUIRING_INVESTIGATION ok("America/Los_Angeles local time is 2000-11-03 10:30:30", (strncmp(ictt_as_string(icttla), "2000-11-03 10:30:30", 19)==0)); #endif ok("Test conversion back to UTC",(icaltime_compare(icttutc, ictt) == 0)); icttny = icaltime_convert_to_zone(ictt, icaltimezone_get_builtin_timezone("America/New_York")); icttphoenix = icaltime_convert_to_zone(ictt, icaltimezone_get_builtin_timezone("America/Phoenix")); if (VERBOSE) { printf("Orig (ctime): %s\n", ical_timet_string(tt) ); printf("Orig (ical) : %s\n", ictt_as_string(ictt)); printf("UTC : %s\n", ictt_as_string(icttutc)); printf("Los Angeles : %s\n", ictt_as_string(icttla)); printf("Phoenix : %s\n", ictt_as_string(icttphoenix)); printf("New York : %s\n", ictt_as_string(icttny)); } /** @todo Check results for Phoenix here?... **/ /* Daylight savings test for New York */ if (VERBOSE) { printf("\n Daylight Savings \n"); printf("Orig (ctime): %s\n", ical_timet_string(tt) ); printf("Orig (ical) : %s\n", ictt_as_string(ictt)); printf("NY : %s\n", ictt_as_string(icttny)); } #if ADD_TESTS_REQUIRING_INVESTIGATION ok("Converted time in zone America/New_York is 2000-11-03 13:30:30", (strncmp(ictt_as_string(icttny),"2000-11-03 13:30:30",19)==0)); #endif tt_p200 = tt + 200 * 24 * 60 * 60 ; /* Add 200 days */ icttdayl = icaltime_from_timet_with_zone(tt_p200,0, icaltimezone_get_utc_timezone()); icttny = icaltime_convert_to_zone(icttdayl, icaltimezone_get_builtin_timezone("America/New_York")); if (VERBOSE) { printf("Orig +200d : %s\n", ical_timet_string(tt_p200) ); printf("NY+200D : %s\n", ictt_as_string(icttny)); } #if ADD_TESTS_REQUIRING_INVESTIGATION ok("Converted time +200d in zone America/New_York is 2001-05-22 14:30:30", (strncmp(ictt_as_string(icttny),"2001-05-22 14:30:30",19)==0)); #endif /* Daylight savings test for Los Angeles */ icttla = icaltime_convert_to_zone(ictt, icaltimezone_get_builtin_timezone("America/Los_Angeles")); if (VERBOSE) { printf("\nOrig (ctime): %s\n", ical_timet_string(tt) ); printf("Orig (ical) : %s\n", ictt_as_string(ictt)); printf("LA : %s\n", ictt_as_string(icttla)); } #if ADD_TESTS_REQUIRING_INVESTIGATION ok("Converted time in zone America/Los_Angeles is 2000-11-03 10:30:30", (strncmp(ictt_as_string(icttla),"2000-11-03 10:30:30",19)==0)); #endif icttla = icaltime_convert_to_zone(icttdayl, icaltimezone_get_builtin_timezone("America/Los_Angeles")); if (VERBOSE) { printf("Orig +200d : %s\n", ical_timet_string(tt_p200) ); printf("LA+200D : %s\n", ictt_as_string(icttla)); } #if ADD_TESTS_REQUIRING_INVESTIGATION ok("Converted time +200d in zone America/Los_Angeles is 2001-05-22 11:30:30", (strncmp(ictt_as_string(icttla),"2001-05-22 11:30:30",19)==0)); #endif icalerror_errors_are_fatal = 1; } void test_iterators() { icalcomponent *c,*inner,*next; icalcompiter i; char vevent_list[64] = ""; char remaining_list[64] = ""; char *vevent_list_good = "12347"; char *remaining_list_good = "568910"; int nomore = 1; c= icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew(ICAL_VEVENT_COMPONENT, icalproperty_new_version("1"),(void *)0), icalcomponent_vanew(ICAL_VEVENT_COMPONENT, icalproperty_new_version("2"),(void *)0), icalcomponent_vanew(ICAL_VEVENT_COMPONENT, icalproperty_new_version("3"),(void *)0), icalcomponent_vanew(ICAL_VEVENT_COMPONENT, icalproperty_new_version("4"),(void *)0), icalcomponent_vanew(ICAL_VTODO_COMPONENT, icalproperty_new_version("5"),(void *)0), icalcomponent_vanew(ICAL_VJOURNAL_COMPONENT, icalproperty_new_version("6"),(void *)0), icalcomponent_vanew(ICAL_VEVENT_COMPONENT, icalproperty_new_version("7"),(void *)0), icalcomponent_vanew(ICAL_VJOURNAL_COMPONENT, icalproperty_new_version("8"),(void *)0), icalcomponent_vanew(ICAL_VJOURNAL_COMPONENT, icalproperty_new_version("9"),(void *)0), icalcomponent_vanew(ICAL_VJOURNAL_COMPONENT, icalproperty_new_version("10"),(void *)0), (void *)0); /* List all of the VEVENTS */ for(i = icalcomponent_begin_component(c,ICAL_VEVENT_COMPONENT); icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){ icalcomponent *this = icalcompiter_deref(&i); icalproperty *p = icalcomponent_get_first_property(this, ICAL_VERSION_PROPERTY); const char* s = icalproperty_get_version(p); strcat(vevent_list, s); } is("iterate through VEVENTS in a component", vevent_list, vevent_list_good); /* Delete all of the VEVENTS */ /* reset iterator */ icalcomponent_get_first_component(c,ICAL_VEVENT_COMPONENT); while((inner=icalcomponent_get_current_component(c)) != 0 ){ if(icalcomponent_isa(inner) == ICAL_VEVENT_COMPONENT){ icalcomponent_remove_component(c,inner); icalcomponent_free(inner); } else { icalcomponent_get_next_component(c,ICAL_VEVENT_COMPONENT); } } /* List all remaining components */ for(inner = icalcomponent_get_first_component(c,ICAL_ANY_COMPONENT); inner != 0; inner = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT)){ icalproperty *p = icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); const char* s = icalproperty_get_version(p); strcat(remaining_list, s); } is("iterate through remaining components", remaining_list, remaining_list_good); /* Remove all remaining components */ for(inner = icalcomponent_get_first_component(c,ICAL_ANY_COMPONENT); inner != 0; inner = next){ icalcomponent *this; icalproperty *p; const char* s; next = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT); p=icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); s = icalproperty_get_version(p); icalcomponent_remove_component(c,inner); this = icalcomponent_get_current_component(c); if(this != 0){ p=icalcomponent_get_first_property(this,ICAL_VERSION_PROPERTY); s = icalproperty_get_version(p); } icalcomponent_free(inner); } /* List all remaining components */ for(inner = icalcomponent_get_first_component(c,ICAL_ANY_COMPONENT); inner != 0; inner = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT)){ icalproperty *p = icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); const char* s = icalproperty_get_version(p); if (s) nomore = 0; } ok("test if any components remain after deleting the rest", nomore == 1); icalcomponent_free(c); } void test_time() { char *zones[6] = { "America/Los_Angeles","America/New_York","Europe/London","Asia/Shanghai", NULL}; int i; do_test_time(0); for(i = 0; zones[i] != NULL; i++){ if (VERBOSE) printf(" ######### Timezone: %s ############\n",zones[i]); do_test_time(zones[i]); } } void test_icalset() { icalcomponent *c; icalset* f = icalset_new_file("2446.ics"); icalset* d = icalset_new_dir("outdir"); assert(f!=0); assert(d!=0); for(c = icalset_get_first_component(f); c != 0; c = icalset_get_next_component(f)){ icalcomponent *clone; clone = icalcomponent_new_clone(c); icalset_add_component(d,clone); printf(" class %d\n",icalclassify(c,0,"user")); } icalset_free(f); icalset_free(d); } icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp); void test_overlaps() { icalcomponent *cset,*c; icalset *set; time_t tm1 = 973378800; /*Sat Nov 4 23:00:00 UTC 2000, Sat Nov 4 15:00:00 PST 2000 */ time_t tm2 = 973382400; /*Sat Nov 5 00:00:00 UTC 2000 Sat Nov 4 16:00:00 PST 2000 */ time_t hh = 1800; /* one half hour */ icalfileset_options options = {O_RDONLY, 0644, 0}; set = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/overlaps.ics", &options); c = icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_vanew_dtstart(icaltime_from_timet(tm1-hh,0),(void *)0), icalproperty_vanew_dtend(icaltime_from_timet(tm2-hh,0),(void *)0), 0 ); cset = icalclassify_find_overlaps(set,c); #if ADD_TESTS_REQUIRING_INVESTIGATION ok("TODO find overlaps 1", (cset != NULL)); #endif if (VERBOSE && cset) printf("%s\n",icalcomponent_as_ical_string(cset)); if (cset) icalcomponent_free(cset); if (c) icalcomponent_free(c); c = icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_vanew_dtstart(icaltime_from_timet(tm1-hh,0),(void *)0), icalproperty_vanew_dtend(icaltime_from_timet(tm2,0),(void *)0), 0 ); cset = icalclassify_find_overlaps(set,c); #if ADD_TESTS_REQUIRING_INVESTIGATION ok("TODO find overlaps 1", cset != NULL); #endif if (VERBOSE && cset) printf("%s\n",icalcomponent_as_ical_string(cset)); if (cset) icalcomponent_free(cset); if (c) icalcomponent_free(c); c = icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_vanew_dtstart(icaltime_from_timet(tm1+5*hh,0),(void *)0), icalproperty_vanew_dtend(icaltime_from_timet(tm2+5*hh,0),(void *)0), 0 ); cset = icalclassify_find_overlaps(set,c); #if ADD_TESTS_REQUIRING_INVESTIGATION ok("TODO find overlaps 1", cset != NULL); #endif if (VERBOSE && cset) printf("%s\n",icalcomponent_as_ical_string(cset)); if (set) icalset_free(set); if (cset) icalcomponent_free(cset); if (c) icalcomponent_free(c); } void test_fblist() { icalspanlist *sl, *new_sl; icalfileset_options options = {O_RDONLY, 0644, 0}; icalset *set = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/spanlist.ics", &options); struct icalperiodtype period; icalcomponent *comp; int * foo; int i; sl = icalspanlist_new(set, icaltime_from_string("19980101T000000Z"), icaltime_from_string("19980108T000000Z")); ok("open ../../test-data/spanlist.ics", (set!=NULL)); assert(set!=NULL); if (VERBOSE) printf("Restricted spanlist\n"); if (VERBOSE) icalspanlist_dump(sl); period= icalspanlist_next_free_time(sl, icaltime_from_string("19970801T120000")); is("Next Free time start 19970801T120000", icaltime_as_ical_string(period.start), "19970801T120000"); is("Next Free time end 19980101T000000", icaltime_as_ical_string(period.end), "19980101T000000"); period= icalspanlist_next_free_time(sl, period.end); is("Next Free time start 19980101T010000", icaltime_as_ical_string(period.start), "19980101T010000"); is("Next Free time end 19980102T010000", icaltime_as_ical_string(period.end), "19980102T010000"); if (VERBOSE) printf("%s\n", icalcomponent_as_ical_string(icalspanlist_as_vfreebusy(sl, "a@foo.com", "b@foo.com") )); foo = icalspanlist_as_freebusy_matrix(sl,3600); for (i=0; foo[i] != -1; i++); /* find number entries */ int_is("Calculating freebusy hourly matrix", i, (7*24)); if (VERBOSE) { for (i=0; foo[i] != -1; i++) { printf("%d", foo[i]); if ((i % 24) == 23) printf("\n"); } printf("\n\n"); } free(foo); foo = icalspanlist_as_freebusy_matrix(sl,3600*24); ok("Calculating daily freebusy matrix", (foo!=NULL)); { char out_str[80] = ""; char *strp = out_str; for (i=0; foo[i]!=-1; i++){ sprintf(strp, "%d", foo[i]); strp++; } is("Checking freebusy validity", out_str, "1121110"); } if (VERBOSE) { for (i=0; foo[i] != -1; i++) { printf("%d", foo[i]); if ((i % 7) == 6) printf("\n"); } printf("\n\n"); } free(foo); icalspanlist_free(sl); if (VERBOSE) printf("Unrestricted spanlist\n"); sl = icalspanlist_new(set, icaltime_from_string("19970324T120000Z"), icaltime_null_time()); ok("add 19970324T120000Z to spanlist", (sl!=NULL)); if (VERBOSE) printf("Restricted spanlist\n"); if (VERBOSE) icalspanlist_dump(sl); period= icalspanlist_next_free_time(sl, icaltime_from_string("19970801T120000Z")); is("Next Free time start 19980101T010000", icaltime_as_ical_string(period.start), "19980101T010000"); is("Next Free time end 19980102T010000", icaltime_as_ical_string(period.end), "19980102T010000"); comp = icalspanlist_as_vfreebusy(sl, "a@foo.com", "b@foo.com"); ok("Calculating VFREEBUSY component", (comp != NULL)); if (VERBOSE) printf("%s\n", icalcomponent_as_ical_string(comp)); new_sl = icalspanlist_from_vfreebusy(comp); ok("Calculating spanlist from generated VFREEBUSY component", (new_sl != NULL)); if (VERBOSE) icalspanlist_dump(new_sl); if (sl) icalspanlist_free(sl); if (new_sl) icalspanlist_free(new_sl); if (comp) icalcomponent_free(comp); icalset_free(set); } void test_convenience(){ icalcomponent *c; int duration; struct icaltimetype tt; c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart(icaltime_from_string("19970801T120000")), icalproperty_new_dtend(icaltime_from_string("19970801T130000")), (void *)0), (void *)0); if (VERBOSE) printf("\n%s\n", icalcomponent_as_ical_string(c)); duration = icaldurationtype_as_int(icalcomponent_get_duration(c))/60; is("Start is 1997-08-01 12:00:00 (floating)", ictt_as_string(icalcomponent_get_dtstart(c)), "1997-08-01 12:00:00 (floating)"); is("End is 1997-08-01 13:00:00 (floating)", ictt_as_string(icalcomponent_get_dtend(c)), "1997-08-01 13:00:00 (floating)"); ok("Duration is 60 m", (duration == 60)); icalcomponent_free(c); c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart(icaltime_from_string("19970801T120000Z")), icalproperty_new_duration(icaldurationtype_from_string("PT1H30M")), (void *)0), (void *)0); if (VERBOSE) printf("\n%s\n", icalcomponent_as_ical_string(c)); duration = icaldurationtype_as_int(icalcomponent_get_duration(c))/60; is("Start is 1997-08-01 12:00:00 Z UTC", ictt_as_string(icalcomponent_get_dtstart(c)), "1997-08-01 12:00:00 Z UTC"); is("End is 1997-08-01 13:30:00 Z UTC", ictt_as_string(icalcomponent_get_dtend(c)), "1997-08-01 13:30:00 Z UTC"); ok("Duration is 90 m", (duration == 90)); icalcomponent_free(c); icalerror_errors_are_fatal = 0; c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart(icaltime_from_string("19970801T120000")), icalproperty_new_dtend(icaltime_from_string("19970801T130000")), (void *)0), (void *)0); icalcomponent_set_duration(c,icaldurationtype_from_string("PT1H30M")); if (VERBOSE) printf("\n%s\n", icalcomponent_as_ical_string(c)); duration = icaldurationtype_as_int(icalcomponent_get_duration(c))/60; is("Start is 1997-08-01 12:00:00 (floating)", ictt_as_string(icalcomponent_get_dtstart(c)), "1997-08-01 12:00:00 (floating)"); is("End is 1997-08-01 13:00:00 (floating)", ictt_as_string(icalcomponent_get_dtend(c)), "1997-08-01 13:00:00 (floating)"); ok("Duration is 60 m", (duration == 60)); icalcomponent_free(c); c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart(icaltime_from_string("19970801T120000Z")), icalproperty_new_duration(icaldurationtype_from_string("PT1H30M")), (void *)0), (void *)0); icalcomponent_set_dtend(c,icaltime_from_string("19970801T133000Z")); if (VERBOSE) printf("\n%s\n", icalcomponent_as_ical_string(c)); duration = icaldurationtype_as_int(icalcomponent_get_duration(c))/60; ok("Start is 1997-08-01 12:00:00 Z UTC", (0 == strcmp("1997-08-01 12:00:00 Z UTC", ictt_as_string(icalcomponent_get_dtstart(c))))); ok("End is 1997-08-01 13:30:00 Z UTC", (0 == strcmp("1997-08-01 13:30:00 Z UTC", ictt_as_string(icalcomponent_get_dtend(c))))); ok("Duration is 90 m", (duration == 90)); icalerror_errors_are_fatal = 1; icalcomponent_free(c); c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew( ICAL_VEVENT_COMPONENT, (void *)0), (void *)0); icalcomponent_set_dtstart(c,icaltime_from_string("19970801T120000Z")); icalcomponent_set_dtend(c,icaltime_from_string("19970801T133000Z")); if (VERBOSE) printf("\n%s\n", icalcomponent_as_ical_string(c)); duration = icaldurationtype_as_int(icalcomponent_get_duration(c))/60; ok("Start is 1997-08-01 12:00:00 Z UTC", (0 == strcmp("1997-08-01 12:00:00 Z UTC", ictt_as_string(icalcomponent_get_dtstart(c))))); ok("End is 1997-08-01 13:30:00 Z UTC", (0 == strcmp("1997-08-01 13:30:00 Z UTC", ictt_as_string(icalcomponent_get_dtend(c))))); ok("Duration is 90 m", (duration == 90)); icalcomponent_free(c); c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew( ICAL_VEVENT_COMPONENT, (void *)0), (void *)0); icalcomponent_set_dtstart(c,icaltime_from_string("19970801T120000Z")); icalcomponent_set_duration(c,icaldurationtype_from_string("PT1H30M")); if (VERBOSE) printf("\n%s\n", icalcomponent_as_ical_string(c)); duration = icaldurationtype_as_int(icalcomponent_get_duration(c))/60; ok("Start is 1997-08-01 12:00:00 Z UTC", (0 == strcmp("1997-08-01 12:00:00 Z UTC", ictt_as_string(icalcomponent_get_dtstart(c))))); ok("End is 1997-08-01 13:30:00 Z UTC", (0 == strcmp("1997-08-01 13:30:00 Z UTC", ictt_as_string(icalcomponent_get_dtend(c))))); ok("Duration is 90 m", (duration == 90)); icalcomponent_free(c); c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew( ICAL_VEVENT_COMPONENT, (void *)0), (void *)0); tt = icaltime_from_string("19970801T120000"); icaltime_set_timezone(&tt, icaltimezone_get_builtin_timezone("Europe/Rome")); icalcomponent_set_dtstart(c,tt); if (VERBOSE) printf("\n%s\n", icalcomponent_as_ical_string(c)); icalcomponent_set_duration(c,icaldurationtype_from_string("PT1H30M")); duration = icaldurationtype_as_int(icalcomponent_get_duration(c))/60; #ifndef USE_BUILTIN_TZDATA ok("Start is 1997-08-01 12:00:00 Europe/Rome", (0 == strcmp("1997-08-01 12:00:00 /softwarestudio.org/Tzfile/Europe/Rome", ictt_as_string(icalcomponent_get_dtstart(c))))); ok("End is 1997-08-01 13:30:00 Europe/Rome", (0 == strcmp("1997-08-01 13:30:00 /softwarestudio.org/Tzfile/Europe/Rome", ictt_as_string(icalcomponent_get_dtend(c))))); #else ok("Start is 1997-08-01 12:00:00 Europe/Rome", (0 == strcmp("1997-08-01 12:00:00 /citadel.org/20070227_1/Europe/Rome", ictt_as_string(icalcomponent_get_dtstart(c))))); ok("End is 1997-08-01 13:30:00 Europe/Rome", (0 == strcmp("1997-08-01 13:30:00 /citadel.org/20070227_1/Europe/Rome", ictt_as_string(icalcomponent_get_dtend(c))))); #endif ok("Duration is 90 m", (duration == 90)); icalcomponent_free(c); } void test_time_parser() { struct icaltimetype tt; icalerror_errors_are_fatal = 0; tt = icaltime_from_string("19970101T1000"); ok("19970101T1000 is null time", icaltime_is_null_time(tt)); tt = icaltime_from_string("19970101X100000"); ok("19970101X100000 is null time", icaltime_is_null_time(tt)); tt = icaltime_from_string("19970101T100000"); ok("19970101T100000 is valid", !icaltime_is_null_time(tt)); if (VERBOSE) printf("%s\n",icaltime_as_ctime(tt)); tt = icaltime_from_string("19970101T100000Z"); ok("19970101T100000Z is valid" , !icaltime_is_null_time(tt)); if (VERBOSE) printf("%s\n",icaltime_as_ctime(tt)); tt = icaltime_from_string("19970101"); ok("19970101 is valid", (!icaltime_is_null_time(tt))); if (VERBOSE) printf("%s\n",icaltime_as_ctime(tt)); icalerror_errors_are_fatal = 1; } void test_recur_parser() { struct icalrecurrencetype rt; char *str; str = "FREQ=YEARLY;UNTIL=20000131T090000Z;INTERVAL=1;BYDAY=-1TU,3WE,-4FR,SA,SU;BYYEARDAY=34,65,76,78;BYMONTH=1,2,3,4,8"; rt = icalrecurrencetype_from_string(str); #if ADD_TESTS_REQUIRING_INVESTIGATION is(str, icalrecurrencetype_as_string(&rt), str); #endif str = "FREQ=DAILY;COUNT=3;INTERVAL=1;BYDAY=-1TU,3WE,-4FR,SA,SU;BYYEARDAY=34,65,76,78;BYMONTH=1,2,3,4,8"; rt = icalrecurrencetype_from_string(str); #if ADD_TESTS_REQUIRING_INVESTIGATION is(str, icalrecurrencetype_as_string(&rt), str); #endif } char* ical_strstr(const char *haystack, const char *needle){ return strstr(haystack,needle); } void test_start_of_week() { struct icaltimetype tt2; struct icaltimetype tt1 = icaltime_from_string("19900110"); int dow, doy,start_dow; do{ tt1 = icaltime_normalize(tt1); doy = icaltime_start_doy_of_week(tt1); dow = icaltime_day_of_week(tt1); tt2 = icaltime_from_day_of_year(doy,tt1.year); start_dow = icaltime_day_of_week(tt2); if(doy == 1){ char msg[128]; sprintf(msg, "%s", ictt_as_string(tt1)); int_is(msg, start_dow, 1); } if(start_dow != 1){ /* Sunday is 1 */ printf("failed: Start of week (%s) is not a Sunday \n for %s (doy=%d,dow=%d)\n",ictt_as_string(tt2), ictt_as_string(tt1),dow,start_dow); } assert(start_dow == 1); tt1.day+=1; } while(tt1.year < 2010); } void test_doy() { struct icaltimetype tt1, tt2; short doy,doy2; char msg[128]; doy = -1; tt1 = icaltime_from_string("19900101"); if (VERBOSE) printf("Test icaltime_day_of_year() agreement with mktime\n"); do{ struct tm stm; tt1 = icaltime_normalize(tt1); stm.tm_sec = tt1.second; stm.tm_min = tt1.minute; stm.tm_hour = tt1.hour; stm.tm_mday = tt1.day; stm.tm_mon = tt1.month-1; stm.tm_year = tt1.year-1900; stm.tm_isdst = -1; mktime(&stm); doy = icaltime_day_of_year(tt1); doy2 = stm.tm_yday+1; if (doy == 1) { /** show some test cases **/ sprintf(msg, "Year %d - mktime() compare", tt1.year); int_is(msg, doy,doy2); } if (doy != doy2){ printf("Failed for %s (%d,%d)\n",ictt_as_string(tt1),doy,doy2); } assert(doy == doy2); tt1.day+=1; } while(tt1.year < 2010); if (VERBOSE) printf("\nTest icaltime_day_of_year() agreement with icaltime_from_day_of_year()\n"); tt1 = icaltime_from_string("19900101"); do{ if(doy == 1){ /** show some test cases **/ sprintf(msg, "Year %d - icaltime_day_of_year() compare", tt1.year); int_is(msg, doy,doy2); } doy = icaltime_day_of_year(tt1); tt2 = icaltime_from_day_of_year(doy,tt1.year); doy2 = icaltime_day_of_year(tt2); assert(doy2 == doy); assert(icaltime_compare(tt1,tt2) == 0); tt1.day+=1; tt1 = icaltime_normalize(tt1); } while(tt1.year < 2010); tt1 = icaltime_from_string("19950301"); doy = icaltime_day_of_year(tt1); tt2 = icaltime_from_day_of_year(doy,1995); if(VERBOSE) printf("%d %s %s\n",doy, icaltime_as_ctime(tt1),icaltime_as_ctime(tt2)); ok("test 19950301", (tt2.day == 1 && tt2.month == 3)); ok("day of year == 60", (doy == 60)); tt1 = icaltime_from_string("19960301"); doy = icaltime_day_of_year(tt1); tt2 = icaltime_from_day_of_year(doy,1996); if (VERBOSE) printf("%d %s %s\n",doy, icaltime_as_ctime(tt1),icaltime_as_ctime(tt2)); ok("test 19960301", (tt2.day == 1 && tt2.month == 3)); ok("day of year == 61", (doy == 61)); tt1 = icaltime_from_string("19970301"); doy = icaltime_day_of_year(tt1); tt2 = icaltime_from_day_of_year(doy,1997); if (VERBOSE) printf("%d %s %s\n",doy, icaltime_as_ctime(tt1),icaltime_as_ctime(tt2)); ok("test 19970301", (tt2.day == 1 && tt2.month == 3)); ok("day of year == 60", (doy == 60)); } void test_x(){ static const char test_icalcomp_str[] = "BEGIN:VEVENT\r\n" "RRULE\r\n" " ;X-EVOLUTION-ENDDATE=20030209T081500\r\n" " :FREQ=DAILY;COUNT=10;INTERVAL=6\r\n" "X-COMMENT;X-FOO=BAR: Booga\r\n" "END:VEVENT\r\n"; icalcomponent *icalcomp; icalproperty *prop; struct icalrecurrencetype recur; int n_errors; icalcomp = icalparser_parse_string ((char *) test_icalcomp_str); assert(icalcomp!=NULL); if (VERBOSE) printf("%s\n\n",icalcomponent_as_ical_string(icalcomp)); n_errors = icalcomponent_count_errors (icalcomp); int_is("icalparser_parse_string()", n_errors,0); if (n_errors) { /** NOT USED **/ icalproperty *p; for (p = icalcomponent_get_first_property (icalcomp, ICAL_XLICERROR_PROPERTY); p; p = icalcomponent_get_next_property (icalcomp, ICAL_XLICERROR_PROPERTY)) { const char *str; str = icalproperty_as_ical_string (p); fprintf (stderr, "error: %s\n", str); } } prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY); ok("get RRULE property", (prop != NULL)); assert(prop!=NULL); recur = icalproperty_get_rrule (prop); if (VERBOSE) printf("%s\n",icalrecurrencetype_as_string(&recur)); icalcomponent_free(icalcomp); } void test_gauge_sql() { icalgauge *g; char* str; str= "SELECT DTSTART,DTEND,COMMENT FROM VEVENT,VTODO WHERE VEVENT.SUMMARY = 'Bongoa' AND SEQUENCE < 5"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=NULL)); if (VERBOSE) icalgauge_dump(g); icalgauge_free(g); str="SELECT * FROM VEVENT,VTODO WHERE VEVENT.SUMMARY = 'Bongoa' AND SEQUENCE < 5 OR METHOD != 'CREATE'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=NULL)); if (VERBOSE) icalgauge_dump(g); icalgauge_free(g); str="SELECT * FROM VEVENT WHERE SUMMARY == 'BA301'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=NULL)); if (VERBOSE) icalgauge_dump(g); icalgauge_free(g); str="SELECT * FROM VEVENT WHERE SUMMARY == 'BA301'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=NULL)); if (VERBOSE) icalgauge_dump(g); icalgauge_free(g); str="SELECT * FROM VEVENT WHERE LOCATION == '104 Forum'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=NULL)); if (VERBOSE) icalgauge_dump(g); icalgauge_free(g); } void test_gauge_compare() { icalgauge *g; icalcomponent *c; char* str; /* Equality */ c = icalcomponent_vanew(ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew(ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart( icaltime_from_string("20000101T000002")),0),(void *)0); g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART = '20000101T000002'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART = '20000101T000002'", (c!=0 && g!=0)); assert(c!=0); assert(g!=0); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART = '20000101T000001'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART = '20000101T000001'\n", (g!=0)); assert(g!=0); int_is("compare",icalgauge_compare(g,c), 0); icalgauge_free(g); g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART != '20000101T000003'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART != '20000101T000003'\n", (c!=0 && g!=0)); assert(g!=0); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); /* Less than */ g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART < '20000101T000003'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART < '20000101T000003'", (c!=0 && g!=0)); int_is("compare",icalgauge_compare(g,c), 1); assert(g!=0); icalgauge_free(g); g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART < '20000101T000002'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART < '20000101T000002'\n", (g!=0)); assert(g!=0); int_is("compare",icalgauge_compare(g,c), 0); icalgauge_free(g); /* Greater than */ g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART > '20000101T000001'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART > '20000101T000001'\n", (g!=0)); assert(g!=0); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART > '20000101T000002'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART > '20000101T000002'\n", (g!=0)); assert(g!=0); int_is("compare",icalgauge_compare(g,c), 0); icalgauge_free(g); /* Greater than or Equal to */ g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART >= '20000101T000002'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART >= '20000101T000002'\n", (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART >= '20000101T000003'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART >= '20000101T000003'\n", (g!=0)); int_is("compare",icalgauge_compare(g,c), 0); icalgauge_free(g); /* Less than or Equal to */ g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART <= '20000101T000002'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART <= '20000101T000002'\n", (g!=0)); assert(g!=0); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART <= '20000101T000001'", 0); ok("SELECT * FROM VEVENT WHERE DTSTART <= '20000101T000001'\n", (g!=0)); int_is("compare",icalgauge_compare(g,c), 0); icalgauge_free(g); icalcomponent_free(c); /* Combinations */ c = icalcomponent_vanew(ICAL_VCALENDAR_COMPONENT, icalcomponent_vanew(ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart( icaltime_from_string("20000102T000000")),0),(void *)0); str = "SELECT * FROM VEVENT WHERE DTSTART > '20000101T000000' and DTSTART < '20000103T000000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); str = "SELECT * FROM VEVENT WHERE DTSTART > '20000101T000000' and DTSTART < '20000102T000000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 0); icalgauge_free(g); str = "SELECT * FROM VEVENT WHERE DTSTART > '20000101T000000' or DTSTART < '20000102T000000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); icalcomponent_free(c); /* Combinations, non-cannonical component */ c = icalcomponent_vanew(ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart( icaltime_from_string("20000102T000000")),(void *)0); str = "SELECT * FROM VEVENT WHERE DTSTART > '20000101T000000' and DTSTART < '20000103T000000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); str = "SELECT * FROM VEVENT WHERE DTSTART > '20000101T000000' and DTSTART < '20000102T000000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 0); icalgauge_free(g); str = "SELECT * FROM VEVENT WHERE DTSTART > '20000101T000000' or DTSTART < '20000102T000000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); icalcomponent_free(c); /* Complex comparisions */ c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalproperty_new_method(ICAL_METHOD_REQUEST), icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart( icaltime_from_string("20000101T000002")), icalproperty_new_comment("foo"), icalcomponent_vanew( ICAL_VALARM_COMPONENT, icalproperty_new_dtstart( icaltime_from_string("20000101T120000")), (void *)0), (void *)0), (void *)0); str = "SELECT * FROM VEVENT WHERE VALARM.DTSTART = '20000101T120000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); str = "SELECT * FROM VEVENT WHERE COMMENT = 'foo'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); str = "SELECT * FROM VEVENT WHERE COMMENT = 'foo' AND VALARM.DTSTART = '20000101T120000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); str = "SELECT * FROM VEVENT WHERE COMMENT = 'bar' AND VALARM.DTSTART = '20000101T120000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 0); icalgauge_free(g); str = "SELECT * FROM VEVENT WHERE COMMENT = 'bar' or VALARM.DTSTART = '20000101T120000'"; g = icalgauge_new_from_sql(str, 0); ok(str, (g!=0)); int_is("compare",icalgauge_compare(g,c), 1); icalgauge_free(g); icalcomponent_free(c); } icalcomponent* make_component(int i){ icalcomponent *c; struct icaltimetype t = icaltime_from_string("20000101T120000Z"); t.day += i; icaltime_normalize(t); c = icalcomponent_vanew( ICAL_VCALENDAR_COMPONENT, icalproperty_new_method(ICAL_METHOD_REQUEST), icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_new_dtstart(t), (void *)0), (void *)0); assert(c != 0); return c; } void test_fileset() { icalset *fs; icalcomponent *c; int i; int comp_count = 0; char *path = "test_fileset.ics"; icalgauge *g = icalgauge_new_from_sql( "SELECT * FROM VEVENT WHERE DTSTART > '20000103T120000Z' AND DTSTART <= '20000106T120000Z'", 0); ok("icalgauge_new_from_sql()", (g!=NULL)); unlink(path); fs = icalfileset_new(path); ok("icalfileset_new()", (fs!=NULL)); assert(fs != 0); for (i = 0; i!= 10; i++){ c = make_component(i); icalfileset_add_component(fs,c); } icalfileset_commit(fs); icalset_free(fs); /** reopen fileset.ics **/ fs = icalfileset_new(path); if (VERBOSE) printf("== No Selections \n"); comp_count = 0; for (c = icalfileset_get_first_component(fs); c != 0; c = icalfileset_get_next_component(fs)){ struct icaltimetype t = icalcomponent_get_dtstart(c); comp_count++; if (VERBOSE) printf("%s\n",icaltime_as_ctime(t)); } int_is("icalfileset get components",comp_count, 10); icalfileset_select(fs,g); if (VERBOSE) printf("\n== DTSTART > '20000103T120000Z' AND DTSTART <= '20000106T120000Z' \n"); comp_count = 0; for (c = icalfileset_get_first_component(fs); c != 0; c = icalfileset_get_next_component(fs)){ struct icaltimetype t = icalcomponent_get_dtstart(c); comp_count++; if (VERBOSE) printf("%s\n",icaltime_as_ctime(t)); } int_is("icalfileset get components with gauge",comp_count, 3); icalset_free(fs); /*icalgauge_free(g);*/ } void microsleep(int us) { #ifndef WIN32 struct timeval tv; tv.tv_sec = 0; tv.tv_usec = us; select(0,0,0,0,&tv); #else Sleep(us); #endif } void test_file_locks() { #ifndef WIN32 pid_t pid; char *path = "test_fileset_locktest.ics"; icalset *fs; icalcomponent *c, *c2; struct icaldurationtype d; int i; int final,sec = 0; icalerror_clear_errno(); unlink(path); fs = icalfileset_new(path); if(icalfileset_get_first_component(fs)==0){ c = make_component(0); d = icaldurationtype_from_int(1); icalcomponent_set_duration(c,d); icalfileset_add_component(fs,c); c2 = icalcomponent_new_clone(c); icalfileset_add_component(fs,c2); icalfileset_commit(fs); } icalset_free(fs); assert(icalerrno == ICAL_NO_ERROR); pid = fork(); assert(pid >= 0); if(pid == 0){ /*child*/ int i; microsleep(rand()/(RAND_MAX/100)); for(i = 0; i< 50; i++){ fs = icalfileset_new(path); assert(fs != 0); c = icalfileset_get_first_component(fs); assert(c!=0); d = icalcomponent_get_duration(c); d = icaldurationtype_from_int(icaldurationtype_as_int(d)+1); icalcomponent_set_duration(c,d); icalcomponent_set_summary(c,"Child"); c2 = icalcomponent_new_clone(c); icalcomponent_set_summary(c2,"Child"); icalfileset_add_component(fs,c2); icalfileset_mark(fs); icalfileset_commit(fs); icalset_free(fs); microsleep(rand()/(RAND_MAX/20)); } exit(0); } else { /* parent */ int i; for(i = 0; i< 50; i++){ fs = icalfileset_new(path); assert(fs != 0); c = icalfileset_get_first_component(fs); assert(c!=0); d = icalcomponent_get_duration(c); d = icaldurationtype_from_int(icaldurationtype_as_int(d)+1); icalcomponent_set_duration(c,d); icalcomponent_set_summary(c,"Parent"); c2 = icalcomponent_new_clone(c); icalcomponent_set_summary(c2,"Parent"); icalfileset_add_component(fs,c2); icalfileset_mark(fs); icalfileset_commit(fs); icalset_free(fs); putc('.',stdout); fflush(stdout); } } assert(waitpid(pid,0,0)==pid); fs = icalfileset_new(path); i=1; c = icalfileset_get_first_component(fs); final = icaldurationtype_as_int(icalcomponent_get_duration(c)); for (c = icalfileset_get_next_component(fs); c != 0; c = icalfileset_get_next_component(fs)){ struct icaldurationtype d = icalcomponent_get_duration(c); sec = icaldurationtype_as_int(d); /*printf("%d,%d ",i,sec);*/ assert(i == sec); i++; } printf("\nFinal: %d\n",final); assert(sec == final); #endif } void test_action() { icalcomponent *c; icalproperty *p; char *str; static const char test_icalcomp_str[] = "BEGIN:VEVENT\r\n" "ACTION:EMAIL\r\n" "ACTION:PROCEDURE\r\n" "ACTION:AUDIO\r\n" "ACTION:FUBAR\r\n" "END:VEVENT\r\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string(), ACTIONS", (c!=NULL)); assert(c!=0); str = icalcomponent_as_ical_string(c); is("icalcomponent_as_ical_string()", str, ((char*) test_icalcomp_str)); if (VERBOSE) printf("%s\n\n",str); p = icalcomponent_get_first_property(c,ICAL_ACTION_PROPERTY); ok("ICAL_ACTION_EMAIL", (icalproperty_get_action(p) == ICAL_ACTION_EMAIL)); p = icalcomponent_get_next_property(c,ICAL_ACTION_PROPERTY); ok("ICAL_ACTION_PROCEDURE", (icalproperty_get_action(p) == ICAL_ACTION_PROCEDURE)); p = icalcomponent_get_next_property(c,ICAL_ACTION_PROPERTY); ok("ICAL_ACTION_AUDIO", (icalproperty_get_action(p) == ICAL_ACTION_AUDIO)); p = icalcomponent_get_next_property(c,ICAL_ACTION_PROPERTY); ok("ICAL_ACTION_X", (icalproperty_get_action(p) == ICAL_ACTION_X)); is("ICAL_ACTION -> FUBAR", icalvalue_get_x(icalproperty_get_value(p)), "FUBAR"); icalcomponent_free(c); } void test_trigger() { struct icaltriggertype tr; icalcomponent *c; icalproperty *p; const char* str; static const char test_icalcomp_str[] = "BEGIN:VEVENT\r\n" "TRIGGER;VALUE=DATE-TIME:19980403T120000\r\n" "TRIGGER;VALUE=DURATION:-PT15M\r\n" "TRIGGER;VALUE=DATE-TIME:19980403T120000\r\n" "TRIGGER;VALUE=DURATION:-PT15M\r\n" "END:VEVENT\r\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string()", (c!= NULL)); assert(c!=NULL); is("parsed triggers", icalcomponent_as_ical_string(c), (char*)test_icalcomp_str); for(p = icalcomponent_get_first_property(c,ICAL_TRIGGER_PROPERTY); p != 0; p = icalcomponent_get_next_property(c,ICAL_TRIGGER_PROPERTY)){ tr = icalproperty_get_trigger(p); if(!icaltime_is_null_time(tr.time)){ if (VERBOSE) printf("value=DATE-TIME:%s\n", icaltime_as_ical_string(tr.time)); } else { if (VERBOSE) printf("value=DURATION:%s\n", icaldurationtype_as_ical_string(tr.duration)); } } icalcomponent_free(c); /* Trigger, as a DATETIME */ tr.duration = icaldurationtype_null_duration(); tr.time = icaltime_from_string("19970101T120000"); p = icalproperty_new_trigger(tr); str = icalproperty_as_ical_string(p); is("TRIGGER;VALUE=DATE-TIME:19970101T120000", str, "TRIGGER;VALUE=DATE-TIME:19970101T120000\r\n"); icalproperty_free(p); /* TRIGGER, as a DURATION */ tr.time = icaltime_null_time(); tr.duration = icaldurationtype_from_string("P3DT3H50M45S"); p = icalproperty_new_trigger(tr); str = icalproperty_as_ical_string(p); is("TRIGGER;VALUE=DURATION:P3DT3H50M45S", str, "TRIGGER;VALUE=DURATION:P3DT3H50M45S\r\n"); icalproperty_free(p); /* TRIGGER, as a DATETIME, VALUE=DATETIME*/ tr.duration = icaldurationtype_null_duration(); tr.time = icaltime_from_string("19970101T120000"); p = icalproperty_new_trigger(tr); icalproperty_add_parameter(p,icalparameter_new_value( ICAL_VALUE_DATETIME)); str = icalproperty_as_ical_string(p); is("TRIGGER;VALUE=DATE-TIME:19970101T120000", str, "TRIGGER;VALUE=DATE-TIME:19970101T120000\r\n"); icalproperty_free(p); /*TRIGGER, as a DURATION, VALUE=DATETIME */ tr.time = icaltime_null_time(); tr.duration = icaldurationtype_from_string("P3DT3H50M45S"); p = icalproperty_new_trigger(tr); icalproperty_add_parameter(p,icalparameter_new_value( ICAL_VALUE_DATETIME )); str = icalproperty_as_ical_string(p); #if ADD_TESTS_REQUIRING_INVESTIGATION is("TRIGGER;VALUE=DURATION:P3DT3H50M45S", str, "TRIGGER;VALUE=DURATION:P3DT3H50M45S\r\n"); #endif icalproperty_free(p); /* TRIGGER, as a DATETIME, VALUE=DURATION*/ tr.duration = icaldurationtype_null_duration(); tr.time = icaltime_from_string("19970101T120000"); p = icalproperty_new_trigger(tr); icalproperty_add_parameter(p,icalparameter_new_value( ICAL_VALUE_DURATION)); str = icalproperty_as_ical_string(p); #if ADD_TESTS_REQUIRING_INVESTIGATION is("TRIGGER;VALUE=DATE-TIME:19970101T120000", str, "TRIGGER;VALUE=DATE-TIME:19970101T120000\r\n"); #endif icalproperty_free(p); /*TRIGGER, as a DURATION, VALUE=DURATION */ tr.time = icaltime_null_time(); tr.duration = icaldurationtype_from_string("P3DT3H50M45S"); p = icalproperty_new_trigger(tr); icalproperty_add_parameter(p,icalparameter_new_value( ICAL_VALUE_DURATION)); str = icalproperty_as_ical_string(p); is("TRIGGER;VALUE=DURATION:P3DT3H50M45S", str, "TRIGGER;VALUE=DURATION:P3DT3H50M45S\r\n"); icalproperty_free(p); /* TRIGGER, as a DATETIME, VALUE=BINARY */ tr.duration = icaldurationtype_null_duration(); tr.time = icaltime_from_string("19970101T120000"); p = icalproperty_new_trigger(tr); icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_BINARY)); str = icalproperty_as_ical_string(p); #if ADD_TESTS_REQUIRING_INVESTIGATION is("TRIGGER;VALUE=DATE-TIME:19970101T120000", str, "TRIGGER;VALUE=DATE-TIME:19970101T120000\r\n"); #endif icalproperty_free(p); /*TRIGGER, as a DURATION, VALUE=BINARY */ tr.time = icaltime_null_time(); tr.duration = icaldurationtype_from_string("P3DT3H50M45S"); p = icalproperty_new_trigger(tr); icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_BINARY)); str = icalproperty_as_ical_string(p); #if ADD_TESTS_REQUIRING_INVESTIGATION is("TRIGGER;VALUE=DURATION:P3DT3H50M45S", str, "TRIGGER;VALUE=DURATION:P3DT3H50M45S\r\n"); #endif icalproperty_free(p); } void test_rdate() { struct icaldatetimeperiodtype dtp; icalproperty *p; const char* str; struct icalperiodtype period; period.start = icaltime_from_string("19970101T120000"); period.end = icaltime_null_time(); period.duration = icaldurationtype_from_string("PT3H10M15S"); /* RDATE, as DATE-TIME */ dtp.time = icaltime_from_string("19970101T120000"); dtp.period = icalperiodtype_null_period(); p = icalproperty_new_rdate(dtp); str = icalproperty_as_ical_string(p); is("RDATE as DATE-TIME", str, "RDATE;VALUE=DATE-TIME:19970101T120000\r\n"); icalproperty_free(p); /* RDATE, as PERIOD */ dtp.time = icaltime_null_time(); dtp.period = period; p = icalproperty_new_rdate(dtp); str = icalproperty_as_ical_string(p); is("RDATE, as PERIOD", str, "RDATE;VALUE=PERIOD:19970101T120000/PT3H10M15S\r\n"); icalproperty_free(p); /* RDATE, as DATE-TIME, VALUE=DATE-TIME */ dtp.time = icaltime_from_string("19970101T120000"); dtp.period = icalperiodtype_null_period(); p = icalproperty_new_rdate(dtp); icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_DATETIME)); str = icalproperty_as_ical_string(p); is("RDATE, as DATE-TIME, VALUE=DATE-TIME", str, "RDATE;VALUE=DATE-TIME:19970101T120000\r\n"); icalproperty_free(p); /* RDATE, as PERIOD, VALUE=DATE-TIME */ dtp.time = icaltime_null_time(); dtp.period = period; p = icalproperty_new_rdate(dtp); icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_DATETIME)); str = icalproperty_as_ical_string(p); #if ADD_TESTS_REQUIRING_INVESTIGATION is("RDATE, as PERIOD, VALUE=DATE-TIME", str, "RDATE;VALUE=PERIOD:19970101T120000/PT3H10M15S\r\n"); #endif icalproperty_free(p); /* RDATE, as DATE-TIME, VALUE=PERIOD */ dtp.time = icaltime_from_string("19970101T120000"); dtp.period = icalperiodtype_null_period(); p = icalproperty_new_rdate(dtp); icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_PERIOD)); str = icalproperty_as_ical_string(p); #if ADD_TESTS_REQUIRING_INVESTIGATION is("RDATE, as DATE-TIME, VALUE=PERIOD", str, "RDATE;VALUE=DATE-TIME:19970101T120000\r\n"); #endif icalproperty_free(p); /* RDATE, as PERIOD, VALUE=PERIOD */ dtp.time = icaltime_null_time(); dtp.period = period; p = icalproperty_new_rdate(dtp); icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_PERIOD)); str = icalproperty_as_ical_string(p); is("RDATE, as PERIOD, VALUE=PERIOD", str, "RDATE;VALUE=PERIOD:19970101T120000/PT3H10M15S\r\n"); icalproperty_free(p); /* RDATE, as DATE-TIME, VALUE=BINARY */ dtp.time = icaltime_from_string("19970101T120000"); dtp.period = icalperiodtype_null_period(); p = icalproperty_new_rdate(dtp); icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_BINARY)); str = icalproperty_as_ical_string(p); #if ADD_TESTS_REQUIRING_INVESTIGATION is("RDATE, as DATE-TIME, VALUE=BINARY", str, "RDATE;VALUE=DATE-TIME:19970101T120000\r\n"); #endif icalproperty_free(p); /* RDATE, as PERIOD, VALUE=BINARY */ dtp.time = icaltime_null_time(); dtp.period = period; p = icalproperty_new_rdate(dtp); icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_BINARY)); str = icalproperty_as_ical_string(p); #if ADD_TESTS_REQUIRING_INVESTIGATION is("RDATE, as PERIOD, VALUE=BINARY", str, "RDATE;VALUE=PERIOD:19970101T120000/PT3H10M15S\r\n"); #endif icalproperty_free(p); } void test_langbind() { icalcomponent *c, *inner; icalproperty *p; char *test_str_parsed; static const char test_str[] = "BEGIN:VEVENT\n" "ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com\n" "COMMENT: Comment that \n spans a line\n" "COMMENT: Comment with \"quotable\" \'characters\' and other \t bad magic \n things \f Yeah.\n" "DTSTART:19970101T120000\n" "DTSTART:19970101T120000Z\n" "DTSTART:19970101\n" "DURATION:P3DT4H25M\n" "FREEBUSY:19970101T120000/19970101T120000\n" "FREEBUSY:19970101T120000/P3DT4H25M\n" "END:VEVENT\n"; static const char *test_str_parsed_good = "BEGIN:VEVENT\r\n" "ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:\r\n" " employee-A@host.com\r\n" "COMMENT: Comment that spans a line\r\n" "COMMENT: Comment with \\\"quotable\\\" 'characters' and other \\t bad magic \r\n" " things \\f Yeah.\r\n" "DTSTART:19970101T120000\r\n" "DTSTART:19970101T120000Z\r\n" "DTSTART;VALUE=DATE:19970101\r\n" "DURATION:P3DT4H25M\r\n" "FREEBUSY:19970101T120000/19970101T120000\r\n" "FREEBUSY:19970101T120000/P3DT4H25M\r\n" "END:VEVENT\r\n"; if (VERBOSE) printf("%s\n",test_str); c = icalparser_parse_string(test_str); ok("icalparser_parse_string()", (c!=NULL)); assert(c != NULL); test_str_parsed = icalcomponent_as_ical_string(c); #if ADD_TESTS_REQUIRING_INVESTIGATION is("parsed version with bad chars, etc", test_str_parsed, test_str_parsed_good); #endif inner = icalcomponent_get_inner(c); for( p = icallangbind_get_first_property(inner,"ANY"); p != 0; p = icallangbind_get_next_property(inner,"ANY") ) { const char *str = icallangbind_property_eval_string(p,":"); /** TODO add tests **/ if (VERBOSE) printf("%s\n",str); } p = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY); icalproperty_set_parameter_from_string(p,"CUTYPE","INDIVIDUAL"); is ("Set attendee parameter", icalproperty_as_ical_string(p), "ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL:MAILTO:\r\n" " employee-A@host.com\r\n"); icalproperty_set_value_from_string(p,"mary@foo.org","TEXT"); is ("Set attendee parameter value", icalproperty_as_ical_string(p), "ATTENDEE;VALUE=TEXT;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL:\r\n" " mary@foo.org\r\n"); icalcomponent_free(c); } void test_property_parse() { icalcomponent *c; icalproperty *p; const char *str; static const char test_icalcomp_str[] = "BEGIN:VEVENT\n" "ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com\n" "DTSTART:19970101T120000Z\n" "END:VEVENT\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string()", (c != NULL)); if (!c) { exit (EXIT_FAILURE); } p = icalcomponent_get_first_property(c,ICAL_ATTENDEE_PROPERTY); ok("icalproperty_from_string(), ATTENDEE", (p != 0)); str = icalproperty_as_ical_string(p); if (VERBOSE) printf("%s\n",str); icalproperty_free(p); p = icalcomponent_get_first_property(c,ICAL_DTSTART_PROPERTY); ok("icalproperty_from_string(), simple DTSTART", (p != 0)); str = icalproperty_as_ical_string(p); if (VERBOSE) printf("%s\n",str); icalproperty_free(p); } void test_value_parameter() { icalcomponent *c; icalproperty *p; icalparameter *param; static const char test_icalcomp_str[] = "BEGIN:VEVENT\n" "DTSTART;VALUE=DATE-TIME:19971123T123000\n" "DTSTART;VALUE=DATE:19971123\n" "DTSTART;VALUE=FOO:19971123T123000\n" "END:VEVENT\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string()", (c != NULL)); if (!c) { exit (EXIT_FAILURE); } if (VERBOSE) printf("%s",icalcomponent_as_ical_string(c)); p = icalcomponent_get_first_property(c,ICAL_DTSTART_PROPERTY); param = icalproperty_get_first_parameter(p,ICAL_VALUE_PARAMETER); ok("icalproperty_get_value()", (icalparameter_get_value(param) == ICAL_VALUE_DATETIME)); p = icalcomponent_get_next_property(c,ICAL_DTSTART_PROPERTY); param = icalproperty_get_first_parameter(p,ICAL_VALUE_PARAMETER); ok("icalproperty_get_first_parameter()",(icalparameter_get_value(param) == ICAL_VALUE_DATE)); icalcomponent_free(c); } void test_x_parameter() { icalcomponent *c; icalproperty *p; static const char test_icalcomp_str[] = "BEGIN:VEVENT\n" "COMMENT;X-A=1;X-B=2:\\sThis is a note\n" "END:VEVENT\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string()", (c != NULL)); if (!c) { exit (EXIT_FAILURE); } if (VERBOSE) printf("%s",icalcomponent_as_ical_string(c)); p = icalcomponent_get_first_property(c,ICAL_COMMENT_PROPERTY); icalproperty_set_parameter_from_string(p,"X-LIES", "no"); icalproperty_set_parameter_from_string(p,"X-LAUGHS", "big"); icalproperty_set_parameter_from_string(p,"X-TRUTH", "yes"); icalproperty_set_parameter_from_string(p,"X-HUMOUR", "bad"); if (VERBOSE) printf("%s\n",icalproperty_as_ical_string(p)); is("COMMENT parses param", icalproperty_get_comment(p)," This is a note"); is("Check X-LIES", icalproperty_get_parameter_as_string(p, "X-LIES"), "no"); is("Check X-LAUGHS", icalproperty_get_parameter_as_string(p, "X-LAUGHS"), "big"); is("Check X-TRUTH", icalproperty_get_parameter_as_string(p, "X-TRUTH"), "yes"); is("Check X-HUMOUR", icalproperty_get_parameter_as_string(p, "X-HUMOUR"), "bad"); icalcomponent_free(c); } void test_x_property() { icalcomponent *c; icalproperty *p; static const char test_icalcomp_str[] = "BEGIN:VEVENT\n" "X-LIC-PROPERTY:\\sThis is a note\n" "END:VEVENT\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string()", (c != NULL)); if (!c) { exit (EXIT_FAILURE); } if (VERBOSE) printf("%s",icalcomponent_as_ical_string(c)); p = icalcomponent_get_first_property(c,ICAL_X_PROPERTY); ok("x-property is correct kind",(icalproperty_isa(p) == ICAL_X_PROPERTY)); is("icalproperty_get_x_name() works", icalproperty_get_x_name(p),"X-LIC-PROPERTY"); is("icalproperty_get_x() works", icalproperty_get_x(p)," This is a note"); icalcomponent_free(c); } void test_utcoffset() { icalcomponent *c; static const char test_icalcomp_str[] = "BEGIN:VTIMEZONE\n" "TZOFFSETFROM:-001608\n" "END:VTIMEZONE\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("parse TZOFFSETFROM:-001608", (c!=NULL)); if (VERBOSE && c) printf("%s",icalcomponent_as_ical_string(c)); if (c) icalcomponent_free(c); } void test_attach() { icalcomponent *c; static const char test_icalcomp_str[] = "BEGIN:VEVENT\n" "ATTACH:CID:jsmith.part3.960817T083000.xyzMain@host1.com\n" "ATTACH:FMTTYPE=application/postscript;ftp://xyzCorp.com/pub/reports/r-960812.ps\n" "END:VEVENT\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("parse simple attachment", (c != NULL)); if (VERBOSE && c) printf("%s",icalcomponent_as_ical_string(c)); if (c) icalcomponent_free(c); } void test_vcal(void) { VObject *vcal = 0; icalcomponent *comp; char* file = TEST_DATADIR "/user-cal.vcf"; vcal = Parse_MIME_FromFileName(file); ok("Parsing " TEST_DATADIR "/user-cal.vcf", (vcal != 0)); comp = icalvcal_convert(vcal); ok("Converting to ical component", (comp != 0)); if (VERBOSE && comp) printf("%s\n",icalcomponent_as_ical_string(comp)); if (comp) icalcomponent_free(comp); if (vcal) deleteVObject(vcal); } /* * Test to see if recurrences are excluded in certain situations * See r961 for more information */ void test_recurrenceexcluded(void) { char funTime[2048]; icalcomponent * calendar = NULL; icalcomponent * event = NULL; struct icaltimetype dtstart; struct icaltimetype recurtime; funTime[0] = '\0'; strcat(funTime, "BEGIN:VCALENDAR\n"); strcat(funTime, "VERSION:2.0\n"); strcat(funTime, "BEGIN:VTIMEZONE\n"); strcat(funTime, "TZID:/mozilla.org/20071231_1/Europe/London\n"); strcat(funTime, "X-LIC-LOCATION:Europe/London\n"); strcat(funTime, "BEGIN:DAYLIGHT\n"); strcat(funTime, "TZOFFSETFROM:+0000\n"); strcat(funTime, "TZOFFSETTO:+0100\n"); strcat(funTime, "TZNAME:BST\n"); strcat(funTime, "DTSTART:19700328T230000\n"); strcat(funTime, "RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=3\n"); strcat(funTime, "END:DAYLIGHT\n"); strcat(funTime, "BEGIN:STANDARD\n"); strcat(funTime, "TZOFFSETFROM:+0100\n"); strcat(funTime, "TZOFFSETTO:+0000\n"); strcat(funTime, "TZNAME:GMT\n"); strcat(funTime, "DTSTART:19701025T000000\n"); strcat(funTime, "RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=10\n"); strcat(funTime, "END:STANDARD\n"); strcat(funTime, "END:VTIMEZONE\n"); strcat(funTime, "BEGIN:VEVENT\n"); strcat(funTime, "DTSTAMP:20080805T174443Z\n"); strcat(funTime, "UID:5fb6ccb8-9646-45ab-8c95-8d15e9de1280\n"); strcat(funTime, "SUMMARY:Exclude test\n"); strcat(funTime, "EXDATE;TZID=/mozilla.org/20071231_1/Europe/London:20080818T190000\n"); strcat(funTime, "EXDATE:20080819T180000Z\n"); strcat(funTime, "RRULE:FREQ=DAILY;COUNT=12;INTERVAL=1;BYDAY=MO,TU,WE,TH,FR\n"); strcat(funTime, "DTSTART;TZID=/mozilla.org/20071231_1/Europe/London:20080811T190000\n"); strcat(funTime, "DTEND;TZID=/mozilla.org/20071231_1/Europe/London:20080811T200000\n"); strcat(funTime, "END:VEVENT\n"); strcat(funTime, "END:VCALENDAR\n"); calendar = icalparser_parse_string(funTime); dtstart = icalcomponent_get_dtstart(calendar); event = icalcomponent_get_first_component(calendar, ICAL_VEVENT_COMPONENT); recurtime = icaltime_from_string("20080818T180000Z"); ok("Recurrence is excluded as per r961", icalproperty_recurrence_is_excluded(event, &dtstart, &recurtime)); recurtime = icaltime_from_string("20080819T180000Z"); ok("Recurrence is excluded for UTC EXDATE", icalproperty_recurrence_is_excluded(event, &dtstart, &recurtime)); } void test_bad_dtstart_in_timezone(void) { icaltimezone *myTZ = NULL; icalcomponent *vtimezone = NULL; char *str = NULL; myTZ = icaltimezone_get_builtin_timezone("Europe/Zurich"); vtimezone = icaltimezone_get_component(myTZ); str = icalcomponent_as_ical_string(vtimezone); if(VERBOSE) printf("%s\n", str); #if ADD_TESTS_REQUIRING_INVESTIGATION ok("bad-dtstart-in-timezone.patch r960", (strstr(str, "DTSTART:19701025T030000") != NULL)); ok("bad-dtstart-in-timezone.patch r960", (strstr(str, "DTSTART:19700329T020000") != NULL)); #endif } void test_icalcomponent_new_from_string(void) { const char *item = "BEGIN:VCALENDAR\n" "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n" "VERSION:2.0\n" "BEGIN:VEVENT\n" "SUMMARY:phone meeting\n" "DTEND:20060406T163000Z\n" "DTSTART:20060406T160000Z\n" "UID:1234567890@dummy\n" "DTSTAMP:20110824T104144Z\n" "LAST-MODIFIED:20110824T104144Z\n" "CREATED:20060409T213201\n" "LOCATION:my office\n" "DESCRIPTION:let's talk\n" "CLASS:PUBLIC\n" "TRANSP:OPAQUE\n" "SEQUENCE:1\n" "END:VEVENT\n" "END:VCALENDAR\n"; // must succeed and not leak memory... icalcomponent *comp = icalcomponent_new_from_string(item); ok("parsed", (comp != NULL)); icalcomponent_free(comp); } void test_comma_in_quoted_value(void) { icalcomponent *c; icalproperty *p; static const char test_icalcomp_str[] = "BEGIN:VEVENT\n" "X-TEST;VALUE=URI:\"geo:10.123456,-70.123456\"\n" "END:VEVENT\n"; c = icalparser_parse_string ((char *) test_icalcomp_str); ok("icalparser_parse_string()", (c != NULL)); if (!c) { exit (EXIT_FAILURE); } if (VERBOSE) printf("%s",icalcomponent_as_ical_string(c)); p = icalcomponent_get_first_property(c,ICAL_X_PROPERTY); ok("x-property is correct kind",(icalproperty_isa(p) == ICAL_X_PROPERTY)); is("icalproperty_get_x_name() works", icalproperty_get_x_name(p),"X-TEST"); is("icalproperty_get_value_as_string() works", icalproperty_get_value_as_string(p),"\"geo:10.123456,-70.123456\""); icalcomponent_free(c); } int main(int argc, char *argv[]) { #if !defined(HAVE_UNISTD_H) extern char *optarg; extern int optopt; #endif int errflg=0; /* char* program_name = strrchr(argv[0],'/'); */ int do_test = 0; int do_header = 0; set_zone_directory("../../zoneinfo"); icaltimezone_set_tzid_prefix("/softwarestudio.org/"); putenv("TZ="); test_start(0); #ifndef WIN32 int c; while ((c = getopt(argc, argv, "lvq")) != -1) { switch (c) { case 'v': { VERBOSE = 1; break; } case 'q': { QUIET = 1; break; } case 'l': { do_header = 1;; } case '?': { errflg++; } } } if (optind < argc) { do_test = atoi(argv[argc-1]); } #else if (argc>1) do_test = atoi(argv[1]); #endif test_run("Test time parser functions", test_time_parser, do_test, do_header); test_run("Test time", test_time, do_test, do_header); test_run("Test day of Year", test_doy, do_test, do_header); test_run("Test duration", test_duration, do_test, do_header); test_run("Test period", test_period, do_test, do_header); test_run("Test DTSTART", test_dtstart, do_test, do_header); test_run("Test day of year of week start", test_start_of_week, do_test, do_header); test_run("Test recur parser", test_recur_parser, do_test, do_header); test_run("Test recur", test_recur, do_test, do_header); test_run("Test Recurring Events File", test_recur_file, do_test, do_header); test_run("Test parameter bug", test_recur_parameter_bug, do_test, do_header); test_run("Test Array Expansion", test_expand_recurrence, do_test, do_header); test_run("Test Free/Busy lists", test_fblist, do_test, do_header); test_run("Test Overlaps", test_overlaps, do_test, do_header); test_run("Test Span", test_icalcomponent_get_span, do_test, do_header); test_run("Test Gauge SQL", test_gauge_sql, do_test, do_header); test_run("Test Gauge Compare", test_gauge_compare, do_test, do_header); test_run("Test File Set", test_fileset, do_test, do_header); test_run("Test File Set (Extended)", test_fileset_extended, do_test, do_header); test_run("Test Dir Set", test_dirset, do_test, do_header); test_run("Test Dir Set (Extended)", test_dirset_extended, do_test, do_header); /* test_file_locks is slow but should work ok -- uncomment to test it */ /* test_run("Test File Locks", test_file_locks, do_test, do_header);*/ test_run("Test X Props and Params", test_x, do_test, do_header); test_run("Test Trigger", test_trigger, do_test, do_header); test_run("Test Restriction", test_restriction, do_test, do_header); test_run("Test RDATE", test_rdate, do_test, do_header); test_run("Test language binding", test_langbind, do_test, do_header); test_run("Test property parser", test_property_parse, do_test, do_header); test_run("Test Action", test_action, do_test, do_header); test_run("Test Value Parameter", test_value_parameter, do_test, do_header); test_run("Test X property", test_x_property, do_test, do_header); test_run("Test X parameter", test_x_parameter, do_test, do_header); test_run("Test request status", test_requeststat, do_test, do_header); test_run("Test UTC-OFFSET", test_utcoffset, do_test, do_header); test_run("Test Values", test_values, do_test, do_header); test_run("Test Parameters", test_parameters, do_test, do_header); test_run("Test Properties", test_properties, do_test, do_header); test_run("Test Components", test_components, do_test, do_header); test_run("Test Convenience", test_convenience, do_test, do_header); test_run("Test classify ", test_classify, do_test, do_header); test_run("Test Iterators", test_iterators, do_test, do_header); test_run("Test strings", test_strings, do_test, do_header); #ifdef INVALID_TEST test_run("Test TZID escaping", test_tzid_escape, do_test, do_header); #endif test_run("Test Compare", test_compare, do_test, do_header); test_run("Create Simple Component", create_simple_component, do_test, do_header); test_run("Create Components", create_new_component, do_test, do_header); test_run("Create Components with vaargs", create_new_component_with_va_args, do_test, do_header); test_run("Test Memory", test_memory, do_test, do_header); test_run("Test Attachment", test_attach, do_test, do_header); test_run("Test icalcalendar", test_calendar, do_test, do_header); test_run("Test Dirset", test_dirset, do_test, do_header); test_run("Test vCal to iCal conversion", test_vcal, do_test, do_header); test_run("Test UTF-8 Handling", test_utf8, do_test, do_header); test_run("Test exclusion of recurrences as per r961", test_recurrenceexcluded, do_test, do_header); test_run("Test bad dtstart in timezone as per r960", test_bad_dtstart_in_timezone, do_test, do_header); test_run("Test icalcomponent_new_from_string()", test_icalcomponent_new_from_string, do_test, do_header); test_run("Test comma in quoted value of x property", test_comma_in_quoted_value, do_test, do_header); /** OPTIONAL TESTS go here... **/ #ifdef WITH_CXX_BINDINGS test_run("Test C++ API", test_cxx, do_test, do_header); #endif #ifdef WITH_BDB test_run("Test BDB Set", test_bdbset, do_test, do_header); #endif icaltimezone_free_builtin_timezones(); icalmemory_free_ring(); free_zone_directory(); test_end(); return 0; }