Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
Added the UID, DTSTART, CONTACT property to iCalendarJournal-Load2.vcf
[xestiacalendar/.git] / source / tests / xestiacalendar_icaleventload.h
1 // xestiacalendar_icaleventload.h - Xestia Calendar iCalendar Event Component Unit Tests
2 //
3 // (c) 2016 Xestia Software Development.
4 //
5 // This file is part of Xestia Calendar.
6 //
7 // Xestia Address Book is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by the
9 // Free Software Foundation, version 3 of the license.
10 //
11 // Xestia Address Book is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 //
16 // You should have received a copy of the GNU General Public License along
17 // with Xestia Calendar. If not, see <http://www.gnu.org/licenses/>
19 #include "../objects/calendarevent/CalendarEvent.h"
21 TEST(iCalendarEvent, BasicTests){
23         CalendarEventObject TestEvent;
24         
25         ASSERT_EQ(CALENDAROBJECTLOAD_MISSING, TestEvent.LoadFile("iCalendarEvent-Missing.vcf"));
26         ASSERT_EQ(CALENDAROBJECTLOAD_CANNOTOPEN, TestEvent.LoadFile("iCalendarEvent-InvalidPermissions.vcf"));
27         ASSERT_EQ(CALENDAROBJECTLOAD_OK, TestEvent.LoadFile("iCalendarEvent-Load1.vcf"));
28         
29 }
31 TEST(iCalendarEvent, BaseObjectVerifyTests){
33         CalendarEventObject TestEvent;
34         TestEvent.LoadFile("iCalendarEvent-Load1.vcf");
35         ASSERT_EQ(CALENDAROBJECTVALID_OK, TestEvent.ValidBaseObject());
36         
37         // Tests for METHOD.
38         
39         ASSERT_EQ("REQUEST", TestEvent.MethodData);
40         ASSERT_EQ("EXAMPLE=DATA", TestEvent.MethodTokens);
41         
42         // Tests for CALSCALE.
43         
44         ASSERT_EQ("GREGORIAN", TestEvent.CalendarScaleData);
45         ASSERT_EQ("MORE=YES", TestEvent.CalendarScaleTokens);
46         
47 }
49 TEST(iCalendarEvent, ObjectDataTests){
50         
51         CalendarEventObject TestEvent;
52         ASSERT_EQ(CALENDAROBJECTLOAD_OK, TestEvent.LoadFile("iCalendarEvent-Load2.vcf"));
53         ASSERT_EQ(CALENDAROBJECTVALID_OK, TestEvent.ValidBaseObject());
54         
55         // Tests for DTSTAMP.
56         
57         ASSERT_EQ("20160122T124100Z", TestEvent.DateTimeStampData);
58         ASSERT_EQ("OTHER=PARAM", TestEvent.DateTimeStampTokens);
59         
60         // Tests for UID.
61         
62         ASSERT_EQ("b3a16392-ad86-4061-be53-c215af2306e0", TestEvent.UniqueID);
63         ASSERT_EQ("UNIQUEPARAM=CERTAINLY;OKAY=MAYBENOT", TestEvent.UniqueIDTokens);
64         
65         // Tests for DTSTART.
66         
67         ASSERT_EQ("20160122T183000Z", TestEvent.DateTimeStartData);
68         ASSERT_EQ("DATE-TIME", TestEvent.DateTimeStartDataValue);
69         ASSERT_EQ("Europe/Truro", TestEvent.DateTimeStartDataTimeZoneID);
70         ASSERT_EQ("PARAMONE=YES;PARAMTWO=NO", TestEvent.DateTimeStartDataTokens);
71         
72         // Tests for CLASS.
73         
74         ASSERT_EQ("PUBLIC", TestEvent.ClassData);
75         ASSERT_EQ("CHOCOLATE=BAR", TestEvent.ClassDataTokens);
77         // Tests for CREATED.
79         ASSERT_EQ("20160123T081100Z", TestEvent.DateTimeCreatedData);
80         ASSERT_EQ("CARAMEL=PLEASE", TestEvent.DateTimeCreatedTokens);
81         
82         // Tests for DESCRIPTION.
83         
84         std::string DescriptionData;
85         std::string DescriptionAltRep;
86         std::string DescriptionLanguage;
87         std::string DescriptionTokens;
88         
89         if (TestEvent.DescriptionList.begin() != TestEvent.DescriptionList.end()){
90                 DescriptionData = TestEvent.DescriptionList[0];
91         }
93         if (TestEvent.DescriptionListAltRep.begin() != TestEvent.DescriptionListAltRep.end()){
94                 DescriptionAltRep = TestEvent.DescriptionListAltRep[0];
95         }
97         if (TestEvent.DescriptionListLanguage.begin() != TestEvent.DescriptionListLanguage.end()){
98                 DescriptionLanguage = TestEvent.DescriptionListLanguage[0];
99         }
101         if (TestEvent.DescriptionListTokens.begin() != TestEvent.DescriptionListTokens.end()){
102                 DescriptionTokens = TestEvent.DescriptionListTokens[0];
103         }
104         
105         ASSERT_EQ("This is a description of the event.", DescriptionData);
106         ASSERT_EQ("null:nodata", DescriptionAltRep);
107         ASSERT_EQ("kw", DescriptionLanguage);
108         ASSERT_EQ("EXAMPLE=TOKEN;MOREDATA=YES", DescriptionTokens);
110         // Tests for GEO.
111         
112         ASSERT_EQ("5.0;5.0", TestEvent.GeographicData);
113         ASSERT_EQ("EXAMPLE=MEEP", TestEvent.GeographicTokens);
114         
115         // Tests for LAST-MODIFIED.
116         
117         ASSERT_EQ("20160124T093000Z", TestEvent.LastModifiedData);
118         ASSERT_EQ("FUTURE=ODD", TestEvent.LastModifiedTokens);
120         // Tests for LOCATION.
122         ASSERT_EQ("The Basement, Truro", TestEvent.LocationData);
123         ASSERT_EQ("null:nodata", TestEvent.LocationDataAltRep);
124         ASSERT_EQ("kw", TestEvent.LocationDataLanguage);
125         ASSERT_EQ("EXACT=NO", TestEvent.LocationDataTokens);
126         
127         // Tests for ORGANIZER.
128         
129         ASSERT_EQ("mailto:organiser@example.com", TestEvent.OrganiserData);
130         ASSERT_EQ("ExampleOrganiser", TestEvent.OrganiserDataCommonName);
131         ASSERT_EQ("null:nodata", TestEvent.OrganiserDataDirectoryEntry);
132         ASSERT_EQ("mailto:organiser.noreply@example.com", TestEvent.OrganiserDataSentByParam);
133         ASSERT_EQ("kw", TestEvent.OrganiserDataLanguage);
134         ASSERT_EQ("HAPPY=DAYS", TestEvent.OrganiserDataTokens);
135         
136         // Tests for PRIORITY.
137         
138         ASSERT_EQ(5, TestEvent.PriorityData);
139         ASSERT_EQ("STATUS=DEFAULT", TestEvent.PriorityTokens);
141         // Tests for SEQUENCE.
142         
143         ASSERT_EQ(3, TestEvent.SequenceData);
144         ASSERT_EQ("TEST=YAY", TestEvent.SequenceTokens);
146         // Tests for STATUS.
147         
148         ASSERT_EQ("2.0;Success", TestEvent.StatusData);
149         ASSERT_EQ("kw", TestEvent.StatusLanguage);
150         ASSERT_EQ("FAVOURITE=RICHTEA;NOTLIKE=UNKNOWN", TestEvent.StatusTokens);
152         // Tests for SUMMARY.
153         
154         ASSERT_EQ("A summary of the event.", TestEvent.SummaryData);
155         ASSERT_EQ("null:nodata", TestEvent.SummaryDataAltRep);
156         ASSERT_EQ("kw", TestEvent.SummaryDataLanguage);
157         ASSERT_EQ("FAVOURITE=TOFU;NOTLIKE=NONE", TestEvent.SummaryDataTokens);
159         // Tests for TRANSP.
160         
161         ASSERT_EQ("TRANSPARENT", TestEvent.TimeTransparencyData);
162         ASSERT_EQ("OPAQUE=NOTYET", TestEvent.TimeTransparencyDataTokens);
164         // Tests for URL.
166         ASSERT_EQ("http://www.example.com/", TestEvent.URLData);
167         ASSERT_EQ("EXTERNAL=YES", TestEvent.URLDataTokens);
168         
169         // Tests for RECURRENCE-ID.
170         
171         ASSERT_EQ("20160124", TestEvent.RecurranceIDData);
172         ASSERT_EQ("Europe/Truro", TestEvent.RecurranceIDDataTimeZoneParam);
173         ASSERT_EQ("THISANDFUTURE", TestEvent.RecurranceIDDataRangeParam);
174         ASSERT_EQ("DATE", TestEvent.RecurranceIDDataValue);
175         ASSERT_EQ("EXAMPLE=DATA", TestEvent.RecurranceIDDataTokens);
177         // Tests for RRULE.
178         
179         ASSERT_EQ("FREQ=DAILY;COUNT=10", TestEvent.RecurranceRuleData);
180         ASSERT_EQ("TEST=DATA", TestEvent.RecurranceRuleDataTokens);
182         // Tests for DTEND.
183         
184         ASSERT_EQ("20160124T183000Z", TestEvent.DateTimeEndData);
185         ASSERT_EQ("DATE-TIME", TestEvent.DateTimeEndDataValue);
186         ASSERT_EQ("Europe/Truro", TestEvent.DateTimeEndDataTimeZoneID);
187         ASSERT_EQ("PARAMFOUR=YES;PARAMTHREE=NO", TestEvent.DateTimeEndDataTokens);
188         
189         // Tests for DURATION. (Done in another file called 
190         // iCalendarEvent-Load3.vcf).
192         CalendarEventObject TestEvent2;
193         ASSERT_EQ(CALENDAROBJECTLOAD_OK, TestEvent2.LoadFile("iCalendarEvent-Load3.vcf"));
194         ASSERT_EQ(CALENDAROBJECTVALID_OK, TestEvent2.ValidBaseObject());
196         ASSERT_EQ("PT1H", TestEvent2.DurationData);
197         ASSERT_EQ("TEST=EXAMPLE", TestEvent2.DurationDataTokens);
198         
199         // Tests for ATTACH. First ATTACH property.
201         std::string AttachData;
202         std::string AttachDataFormatType;
203         std::string AttachDataValue;
204         std::string AttachDataEncoding;
205         std::string AttachDataTokens;
207         if (TestEvent.AttachList.begin() != TestEvent.AttachList.end()){
208                 
209                 AttachData = TestEvent.AttachList[0];
210                 
211         }
212         
213         if (TestEvent.AttachListFormatType.begin() != TestEvent.AttachListFormatType.end()){
214                 
215                 AttachDataFormatType = TestEvent.AttachListFormatType[0];
216                 
217         }
219         ASSERT_EQ("http://www.example.com/", AttachData);
220         ASSERT_EQ("application/internet-shortcut", AttachDataFormatType);
221         
222         // Second ATTACH property.
223         
224         AttachData.clear();
225         AttachDataFormatType.clear();
226         AttachDataValue.clear();
227         AttachDataEncoding.clear();
228         
229         if (TestEvent.AttachList.size() > 1){
230                 
231                 AttachData = TestEvent.AttachList[1];
232                 
233         }
234         
235         if (TestEvent.AttachListFormatType.size() > 1){
236                 
237                 AttachDataFormatType = TestEvent.AttachListFormatType[1];
238                 
239         }
241         ASSERT_EQ("http://www.example.com/page2.html", AttachData);
242         ASSERT_EQ("application/internet-shortcut", AttachDataFormatType);
243         
244         // Third ATTACH property.
246         AttachData.clear();
247         AttachDataFormatType.clear();
248         AttachDataValue.clear();
249         AttachDataEncoding.clear();
250         AttachDataTokens.clear();
251         
252         if (TestEvent.AttachList.size() > 2){
253                 
254                 AttachData = TestEvent.AttachList[2];
255                 
256         }
257         
258         if (TestEvent.AttachListFormatType.size() > 2){
259                 
260                 AttachDataFormatType = TestEvent.AttachListFormatType[2];
261                 
262         }
263         
264         if (TestEvent.AttachListValue.size() > 2){
265                 
266                 AttachDataValue = TestEvent.AttachListValue[2];
267                 
268         }
269         
270         if (TestEvent.AttachListFormatType.size() > 2){
271                 
272                 AttachDataEncoding = TestEvent.AttachListEncoding[2];
273                 
274         }
276         if (TestEvent.AttachListTokens.size() > 2){
277                 
278                 AttachDataTokens = TestEvent.AttachListTokens[2];
279                 
280         }
281         
282         ASSERT_EQ("VGhpcyBpcyBhbiBleGFtcGxlIGZpbGU=", AttachData);
283         ASSERT_EQ("text/plain", AttachDataFormatType);
284         ASSERT_EQ("BASE64", AttachDataEncoding);
285         ASSERT_EQ("BINARY", AttachDataValue);
286         ASSERT_EQ("STUPID=EXAMPLE", AttachDataTokens);
288         // Tests for ATTENDEE. First ATTENDEE property.
290         std::string AttendeeDataMember;
291         std::string AttendeeDataDelegatedFrom;
292         std::string AttendeeDataDelegatedTo;
293         std::string AttendeeDataRole;
294         std::string AttendeeDataRSVP;
295         std::string AttendeeDataDirectoryEntry;
296         std::string AttendeeDataSentBy;
297         std::string AttendeeDataCommonName;
298         std::string AttendeeDataCalendarUserType;
299         std::string AttendeeDataParticipationStatus;
300         std::string AttendeeDataLanguage;
301         std::string AttendeeDataTokens;
302         std::string AttendeeData;
304         if (TestEvent.AttendeeList.begin() != TestEvent.AttendeeList.end()){
305                 
306                 AttendeeData = TestEvent.AttendeeList[0];
307                 
308         }
309         
310         ASSERT_EQ("Attendee One", AttendeeData);
311         
312         // Second ATTENDEE property.
313         
314         AttendeeData.clear();
315         
316         if (TestEvent.AttendeeList.size() > 1){
317                 
318                 AttendeeData = TestEvent.AttendeeList[1];
319                 
320         }
322         if (TestEvent.AttendeeList.size() > 1){
323                 
324                 AttendeeDataDelegatedFrom = TestEvent.AttendeeListDelegatedFrom[1];
325                 
326         }
327         
328         if (TestEvent.AttendeeList.size() > 1){
329                 
330                 AttendeeDataDelegatedTo = TestEvent.AttendeeListDelegatedTo[1];
331                 
332         }
334         if (TestEvent.AttendeeList.size() > 1){
335                 
336                 AttendeeDataRole = TestEvent.AttendeeListRole[1];
337                 
338         }
339         
340         if (TestEvent.AttendeeList.size() > 1){
341                 
342                 AttendeeDataRSVP = TestEvent.AttendeeListRSVP[1];
343                 
344         }
345         
346         ASSERT_EQ("Attendee Two", AttendeeData);
347         ASSERT_EQ("mailto:delegated.from@example.com", AttendeeDataDelegatedFrom);
348         ASSERT_EQ("mailto:delegated.to@example.com", AttendeeDataDelegatedTo);
349         ASSERT_EQ("CHAIR", AttendeeDataRole);
350         ASSERT_EQ("TRUE", AttendeeDataRSVP);
352         // Third ATTENDEE property.
353         
354         AttendeeData.clear();
355         
356         if (TestEvent.AttendeeList.size() > 2){
357                 
358                 AttendeeData = TestEvent.AttendeeList[2];
359                 
360         }
362         if (TestEvent.AttendeeList.size() > 2){
363                 
364                 AttendeeDataDirectoryEntry = TestEvent.AttendeeListDirectoryEntry[2];
365                 
366         }
367         
368         if (TestEvent.AttendeeList.size() > 2){
369                 
370                 AttendeeDataSentBy = TestEvent.AttendeeListSentBy[2];
371                 
372         }
374         if (TestEvent.AttendeeList.size() > 2){
375                 
376                 AttendeeDataCommonName = TestEvent.AttendeeListCommonName[2];
377                 
378         }
379         
380         if (TestEvent.AttendeeList.size() > 2){
381                 
382                 AttendeeDataCalendarUserType = TestEvent.AttendeeListCalendarUserType[2];
383                 
384         }
386         if (TestEvent.AttendeeList.size() > 2){
387                 
388                 AttendeeDataParticipationStatus = TestEvent.AttendeeListParticipationStatus[2];
389                 
390         }
392         if (TestEvent.AttendeeList.size() > 2){
393                 
394                 AttendeeDataLanguage = TestEvent.AttendeeListLanguage[2];
395                 
396         }
397         
398         if (TestEvent.AttendeeList.size() > 2){
399                 
400                 AttendeeDataTokens = TestEvent.AttendeeListTokens[2];
401                 
402         }
403         
404         ASSERT_EQ("Attendee Three", AttendeeData);
405         ASSERT_EQ("null:nodata", AttendeeDataDirectoryEntry);
406         ASSERT_EQ("mailto:sent.by@example.com", AttendeeDataSentBy);
407         ASSERT_EQ("Attendee The Third", AttendeeDataCommonName);
408         ASSERT_EQ("INDIVIDUAL", AttendeeDataCalendarUserType);
409         ASSERT_EQ("ACCEPTED", AttendeeDataParticipationStatus);
410         ASSERT_EQ("kw", AttendeeDataLanguage);
411         ASSERT_EQ("EXAMPLE=DATA", AttendeeDataTokens);
412         
413         // Get the first CATEGORIES.
414         
415         std::string CategoryData;
416         
417         if (TestEvent.CategoriesList.begin() != TestEvent.CategoriesList.end()){
418                 
419                 CategoryData = TestEvent.CategoriesList[0];
420                 
421         }
422         
423         ASSERT_EQ("CATEGORY ONE, CATEGORY TWO", CategoryData);
424         
425         CategoryData.clear();
427         std::string CategoryLanguage;
428         
429         // Get the second CATEGORIES.
430         
431         if (TestEvent.CategoriesList.size() > 1){
432                 
433                 CategoryData = TestEvent.CategoriesList[1];
434                 
435         }
436         
437         if (TestEvent.CategoriesList.size() > 1){
438                 
439                 CategoryLanguage = TestEvent.CategoriesListLanguage[1];
440                 
441         }
442                 
443         ASSERT_EQ("CATEGORY THREE, CATEGORY FOUR", CategoryData);
444         ASSERT_EQ("en", CategoryLanguage);
445         
446         CategoryData.clear();
447         CategoryLanguage.clear();
448         
449         // Get the third CATEGORIES.
450         
451         std::string CategoryTokens;
452         
453         if (TestEvent.CategoriesList.size() > 2){
454                 
455                 CategoryData = TestEvent.CategoriesList[2];
456                 
457         }
458         
459         if (TestEvent.CategoriesList.size() > 2){
460                 
461                 CategoryLanguage = TestEvent.CategoriesListLanguage[2];
462                 
463         }
464         
465         if (TestEvent.CategoriesList.size() > 2){
466                 
467                 CategoryTokens = TestEvent.CategoriesListTokens[2];
468                 
469         }
470                 
471         ASSERT_EQ("CATEGORY FIVE, CATEGORY SIX, CATEGORY SEVEN", CategoryData);
472         ASSERT_EQ("en-GB", CategoryLanguage);
473         ASSERT_EQ("SAMPLE=TOKEN", CategoryTokens);
474         
475         // Get the first COMMENT.
476         
477         std::string CommentData;
478         
479         if (TestEvent.CommentList.begin() != TestEvent.CommentList.end()){
480                 
481                 CommentData = TestEvent.CommentList[0];
482                 
483         }
484         
485         ASSERT_EQ("This is the first comment.", CommentData);
486         
487         // Get the second COMMENT.
488         
489         CommentData.clear();
490         
491         std::string CommentDataAltRep;
492         std::string CommentDataLanguage;
493         
494         if (TestEvent.CommentList.size() > 1){
495                 
496                 CommentData = TestEvent.CommentList[1];
497                 
498         }
499         
500         if (TestEvent.CommentList.size() > 1){
501                 
502                 CommentDataAltRep = TestEvent.CommentListAltRep[1];
503                 
504         }
505         
506         if (TestEvent.CommentList.size() > 1){
507                 
508                 CommentDataLanguage = TestEvent.CommentListLanguage[1];
509                 
510         }
511         
512         ASSERT_EQ("This is the second comment.", CommentData);
513         ASSERT_EQ("null:nodata", CommentDataAltRep);
514         ASSERT_EQ("en", CommentDataLanguage);
515         
516         // Get the third COMMENT.
517         
518         CommentData.clear();
519         
520         std::string CommentDataTokens;
521         
522         if (TestEvent.CommentList.size() > 2){
523                 
524                 CommentData = TestEvent.CommentList[2];
525                 
526         }
527         
528         if (TestEvent.CommentList.size() > 2){
529                 
530                 CommentDataTokens = TestEvent.CommentListTokens[2];
531                 
532         }
533         
534         ASSERT_EQ("This is the third comment.", CommentData);
535         ASSERT_EQ("ZEBRAS=YES", CommentDataTokens);
536         
537         // Get the first CONTACT.
538         
539         std::string ContactData;
540         
541         if (TestEvent.ContactList.begin() != TestEvent.ContactList.end()){
542                 
543                 ContactData = TestEvent.ContactList[0];
544                 
545         }
546         
547         ASSERT_EQ("First Contact", ContactData);
548         
549         // Get the second CONTACT.
550         
551         ContactData.clear();
552         
553         std::string ContactDataAltRep;
554         std::string ContactDataLanguage;
555         
556         if (TestEvent.ContactList.size() > 1){
557                 
558                 ContactData = TestEvent.ContactList[1];
559                 
560         }
561         
562         if (TestEvent.ContactList.size() > 1){
563                 
564                 ContactDataAltRep = TestEvent.ContactListAltRep[1];
565                 
566         }
567         
568         if (TestEvent.ContactList.size() > 1){
569                 
570                 ContactDataLanguage = TestEvent.ContactListLanguage[1];
571                 
572         }
573         
574         ASSERT_EQ("Second Contact", ContactData);
575         ASSERT_EQ("null:nodata", ContactDataAltRep);
576         ASSERT_EQ("en-GB", ContactDataLanguage);
577         
578         // Get the third CONTACT.
579         
580         ContactData.clear();
581         
582         std::string ContactDataTokens;
583         
584         if (TestEvent.ContactList.size() > 2){
585                 
586                 ContactData = TestEvent.ContactList[2];
587                 
588         }
589         
590         if (TestEvent.ContactList.size() > 2){
591                 
592                 ContactDataTokens = TestEvent.ContactListTokens[2];
593                 
594         }
595         
596         ASSERT_EQ("Third Contact", ContactData);
597         ASSERT_EQ("ZEBRAS=NO", ContactDataTokens);
598         
599         // Get the first EXDATE.
600         
601         std::string ExcludeDate;
602         
603         if (TestEvent.ExcludeDateData.begin() != TestEvent.ExcludeDateData.end()){
604                 
605                 ExcludeDate = TestEvent.ExcludeDateData[0];
606                 
607         }
608         
609         ASSERT_EQ("20160125T120000Z", ExcludeDate);
610         
611         // Get the second EXDATE.
613         ExcludeDate.clear();
614         
615         std::string ExcludeDataTimeZoneParam;
616         std::string ExcludeDataValue;
617         
618         if (TestEvent.ContactList.size() > 1){
619                 
620                 ExcludeDate = TestEvent.ExcludeDateData[1];
621                 
622         }
623         
624         if (TestEvent.ContactList.size() > 1){
625                 
626                 ExcludeDataTimeZoneParam = TestEvent.ExcludeDateDataTimeZoneParam[1];
627                 
628         }
629         
630         if (TestEvent.ContactList.size() > 1){
631                 
632                 ExcludeDataValue = TestEvent.ExcludeDateDataValue[1];
633                 
634         }
635         
636         ASSERT_EQ("20160125T130000Z", ExcludeDate);
637         ASSERT_EQ("DATE-TIME", ExcludeDataValue);
638         ASSERT_EQ("Europe/Truro", ExcludeDataTimeZoneParam);
639         
640         // Get the third EXDATE.
641         
642         ExcludeDate.clear();
643         
644         std::string ExcludeDataTokens;
645         
646         if (TestEvent.ContactList.size() > 2){
647                 
648                 ExcludeDate = TestEvent.ExcludeDateData[2];
649                 
650         }
651         
652         if (TestEvent.ContactList.size() > 2){
653                 
654                 ExcludeDataTokens = TestEvent.ExcludeDateDataTokens[2];
655                 
656         }
657         
658         ASSERT_EQ("20160125T133000Z", ExcludeDate);
659         ASSERT_EQ("ZOOP=ZIPPO", ExcludeDataTokens);
660         
661         // Get the first REQUEST-STATUS.
663         std::string RequestStatus;
664         
665         if (TestEvent.RequestStatusData.begin() != TestEvent.RequestStatusData.end()){
666                 
667                 RequestStatus = TestEvent.RequestStatusData[0];
668                 
669         }
670         
671         ASSERT_EQ("2.0;Success", RequestStatus);
672         
673         // Get the second REQUEST-STATUS.
674         
675         RequestStatus.clear();
676         
677         std::string RequestLanguage;
678         
679         if (TestEvent.ContactList.size() > 1){
680                 
681                 RequestStatus = TestEvent.RequestStatusData[1];
682                 
683         }
684         
685         if (TestEvent.ContactList.size() > 1){
686                 
687                 RequestLanguage = TestEvent.RequestStatusLanguage[1];
688                 
689         }
690         
691         ASSERT_EQ("3.42;Really big irrecoverable error caused by the user", RequestStatus);
692         ASSERT_EQ("en", RequestLanguage);
693         
694         // Get the third REQUEST-STATUS.
695         
696         RequestStatus.clear();
697         
698         std::string RequestTokens;
699         
700         if (TestEvent.ContactList.size() > 2){
701                 
702                 RequestStatus = TestEvent.RequestStatusData[2];
703                 
704         }
705         
706         if (TestEvent.ContactList.size() > 2){
707                 
708                 RequestTokens = TestEvent.RequestStatusTokens[2];
709                 
710         }
711         
712         ASSERT_EQ("3.7;Invalid calendar user", RequestStatus);
713         ASSERT_EQ("USER=MISSING", RequestTokens);
714         
715         // Get the first RELATED-TO.
716         
717         std::string RelatedTo;
718         
719         if (TestEvent.RelatedToData.begin() != TestEvent.RelatedToData.end()){
720                 
721                 RelatedTo = TestEvent.RelatedToData[0];
722                 
723         }
724         
725         ASSERT_EQ("person.1@example.com", RelatedTo);
726         
727         // Get the second RELATED-TO.
728         
729         RelatedTo.clear();
730         
731         std::string RelatedToType;
732         
733         if (TestEvent.RelatedToData.size() > 1){
734                 
735                 RelatedTo = TestEvent.RelatedToData[1];
736                 
737         }
738         
739         if (TestEvent.RelatedToData.size() > 1){
740                 
741                 RelatedToType = TestEvent.RelatedToDataRelationType[1];
742                 
743         }
744         
745         ASSERT_EQ("person.2@example.com", RelatedTo);
746         ASSERT_EQ("PARENT", RelatedToType);
747         
748         // Get the third RELATED-TO.
749         
750         RelatedTo.clear();
751         
752         std::string RelatedToTokens;
753         
754         if (TestEvent.RelatedToData.size() > 2){
755                 
756                 RelatedTo = TestEvent.RelatedToData[2];
757                 
758         }
759         
760         if (TestEvent.RelatedToData.size() > 2){
761                 
762                 RelatedToTokens = TestEvent.RelatedToDataTokens[2];
763                 
764         }
765         
766         ASSERT_EQ("person.3@example.com", RelatedTo);
767         ASSERT_EQ("SCHOOL=MEETING", RelatedToTokens);
768         
769         // Get the first RESOURCES.
771         std::string Resources;
772         
773         if (TestEvent.ResourcesData.begin() != TestEvent.ResourcesData.end()){
774                 
775                 Resources = TestEvent.ResourcesData[0];
776                 
777         }
778         
779         ASSERT_EQ("DMAC RECEIVER", Resources);
780         
781         // Get the second RESOURCES.
782         
783         Resources.clear();
784         
785         std::string ResourcesLanguage;
786         
787         if (TestEvent.ResourcesData.size() > 1){
788                 
789                 Resources = TestEvent.ResourcesData[1];
790                 
791         }
792         
793         if (TestEvent.ResourcesData.size() > 1){
794                 
795                 ResourcesLanguage = TestEvent.ResourcesDataLanguage[1];
796                 
797         }
798         
799         ASSERT_EQ("PAL-I TELEVISION SET", Resources);
800         ASSERT_EQ("en", ResourcesLanguage);
801         
802         // Get the third RESOURCES.
803         
804         Resources.clear();
805         
806         std::string ResourcesAltRep;
807         std::string ResourcesTokens;
808         
809         if (TestEvent.ResourcesData.size() > 2){
810                 
811                 Resources = TestEvent.ResourcesData[2];
812                 
813         }
814                 
815         if (TestEvent.ResourcesData.size() > 2){
816                 
817                 ResourcesAltRep = TestEvent.ResourcesDataAltRep[2];
818                 
819         }
820         
821         if (TestEvent.ResourcesData.size() > 2){
822                 
823                 ResourcesTokens = TestEvent.ResourcesDataTokens[2];
824                 
825         }
826         
827         ASSERT_EQ("PAL/SECAM VCR", Resources);
828         ASSERT_EQ("null:nodata", ResourcesAltRep);
829         ASSERT_EQ("STATUS=BROKEN", ResourcesTokens);
830         
831         // Get the first RDATE.
833         std::string RecurrenceDate;
834         
835         if (TestEvent.RecurranceDateData.begin() != TestEvent.RecurranceDateData.end()){
836                 
837                 RecurrenceDate = TestEvent.RecurranceDateData[0];
838                 
839         }
840         
841         ASSERT_EQ("20160120", RecurrenceDate);
842         
843         // Get the second RDATE.
844         
845         RecurrenceDate.clear();
846         
847         std::string RecurrenceDateTimeZoneParam;
848         std::string RecurrenceDateValue;
849         
850         if (TestEvent.RecurranceDateData.size() > 1){
851                 
852                 RecurrenceDate = TestEvent.RecurranceDateData[1];
853                 
854         }
855         
856         if (TestEvent.RecurranceDateData.size() > 1){
857                 
858                 RecurrenceDateTimeZoneParam = TestEvent.RecurranceDateDataTimeZoneParam[1];
859                 
860         }
861         
862         if (TestEvent.RecurranceDateData.size() > 1){
863                 
864                 RecurrenceDateValue = TestEvent.RecurranceDateDataValue[1];
865                 
866         }
867         
868         ASSERT_EQ("20160121", RecurrenceDate);
869         ASSERT_EQ("DATE", RecurrenceDateValue);
870         ASSERT_EQ("Europe/Truro", RecurrenceDateTimeZoneParam);
871         
872         // Get the third RDATE.
873         
874         RecurrenceDate.clear();
875         
876         std::string RecurrenceTokens;
877         
878         if (TestEvent.RecurranceDateData.size() > 2){
879                 
880                 RecurrenceDate = TestEvent.RecurranceDateData[2];
881                 
882         }
883         
884         if (TestEvent.RecurranceDateData.size() > 2){
885                 
886                 RecurrenceTokens = TestEvent.RecurranceDateDataTokens[2];
887                 
888         }
889         
890         ASSERT_EQ("20160520", RecurrenceDate);
891         ASSERT_EQ("ZILCH=DATA", RecurrenceTokens);
892         
893         // Get the first X-EXAMPLE1 token.
894         
895         std::string XTokenName;
896         std::string XTokenData;
897         
898         if (TestEvent.XTokensData.size() != 0 ){
899         
900                 XTokenData = TestEvent.XTokensData[0];
901                 
902         }
904         if (TestEvent.XTokensData.size() != 0){
905         
906                 XTokenName = TestEvent.XTokensDataTokens[0];
907                 
908         }
909         
910         ASSERT_EQ("Moo", XTokenData);
911         ASSERT_EQ("X-EXAMPLE1", XTokenName);
912         
913         // Get the second X-EXAMPLE1 token.
915         XTokenName.clear();
916         XTokenData.clear();
917         
918         if (TestEvent.XTokensData.size() > 1){
919         
920                 XTokenData = TestEvent.XTokensData[1];
921                 
922         }
924         if (TestEvent.XTokensData.size() > 1){
925         
926                 XTokenName = TestEvent.XTokensDataTokens[1];
927                 
928         }
929         
930         ASSERT_EQ("Meep", XTokenData);
931         ASSERT_EQ("X-EXAMPLE1;ANIMAL=NOPE", XTokenName);
932         
933         // Get the third X-EXAMPLE1 token.
935         XTokenName.clear();
936         XTokenData.clear();
937         
938         if (TestEvent.XTokensData.size() > 2){
939         
940                 XTokenData = TestEvent.XTokensData[2];
941                 
942         }
944         if (TestEvent.XTokensData.size() > 2){
945         
946                 XTokenName = TestEvent.XTokensDataTokens[2];
947                 
948         }
949         
950         ASSERT_EQ("Meow", XTokenData);
951         ASSERT_EQ("X-EXAMPLE1;ANIMAL=CAT", XTokenName);
952         
953         // Get the first X-EXAMPLE2 token.
954         
955         XTokenName.clear();
956         XTokenData.clear();
957         
958         if (TestEvent.XTokensData.size() > 3){
959         
960                 XTokenData = TestEvent.XTokensData[3];
961                 
962         }
964         if (TestEvent.XTokensData.size() > 3){
965         
966                 XTokenName = TestEvent.XTokensDataTokens[3];
967                 
968         }
969         
970         ASSERT_EQ("Dish", XTokenData);
971         ASSERT_EQ("X-EXAMPLE2", XTokenName);
972         
973         // Get the second X-EXAMPLE2 token.
974         
975         XTokenName.clear();
976         XTokenData.clear();
977         
978         if (TestEvent.XTokensData.size() > 4){
979         
980                 XTokenData = TestEvent.XTokensData[4];
981                 
982         }
984         if (TestEvent.XTokensData.size() > 4){
985         
986                 XTokenName = TestEvent.XTokensDataTokens[4];
987                 
988         }
989         
990         ASSERT_EQ("Fork", XTokenData);
991         ASSERT_EQ("X-EXAMPLE2;OBJECT=KITCHEN", XTokenName);
992         
993         // Get the third X-EXAMPLE2 token.
994         
995         XTokenName.clear();
996         XTokenData.clear();
997         
998         if (TestEvent.XTokensData.size() > 5){
999         
1000                 XTokenData = TestEvent.XTokensData[5];
1001                 
1002         }
1004         if (TestEvent.XTokensData.size() > 5){
1005         
1006                 XTokenName = TestEvent.XTokensDataTokens[5];
1007                 
1008         }
1009         
1010         ASSERT_EQ("Table", XTokenData);
1011         ASSERT_EQ("X-EXAMPLE2;OBJECT=LIVINGROOM", XTokenName);
1012         
1013         // Get the X-STATUS token.
1014         
1015         XTokenName.clear();
1016         XTokenData.clear();
1017         
1018         if (TestEvent.XTokensData.size() > 6){
1019         
1020                 XTokenData = TestEvent.XTokensData[6];
1021                 
1022         }
1024         if (TestEvent.XTokensData.size() > 6){
1025         
1026                 XTokenName = TestEvent.XTokensDataTokens[6];
1027                 
1028         }
1029         
1030         ASSERT_EQ("Idle", XTokenData);
1031         ASSERT_EQ("X-STATUS;HOLIDAY=YES", XTokenName);
1032         
1033         // Get the X-TRANSPORT token.
1034         
1035         XTokenName.clear();
1036         XTokenData.clear();
1037         
1038         if (TestEvent.XTokensData.size() > 7){
1039         
1040                 XTokenData = TestEvent.XTokensData[7];
1041                 
1042         }
1044         if (TestEvent.XTokensData.size() > 7){
1045         
1046                 XTokenName = TestEvent.XTokensDataTokens[7];
1047                 
1048         }
1049         
1050         ASSERT_EQ("Private Hire", XTokenData);
1051         ASSERT_EQ("X-TRANSPORT;PUBLIC=NO", XTokenName);
1052         
1053         // Get the X-PHANTOM-STATUS token.
1054         
1055         XTokenName.clear();
1056         XTokenData.clear();
1057         
1058         if (TestEvent.XTokensData.size() > 8){
1059         
1060                 XTokenData = TestEvent.XTokensData[8];
1061                 
1062         }
1064         if (TestEvent.XTokensData.size() > 8){
1065         
1066                 XTokenName = TestEvent.XTokensDataTokens[8];
1067                 
1068         }
1069         
1070         ASSERT_EQ("None", XTokenData);
1071         ASSERT_EQ("X-PHANTOM-STATUS;HELP=NONE", XTokenName);
1072         
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy