Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
9b3c9a347ae15723a0982e6062e65da798141095
[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.RequestStatusData.size() > 1){
680                 
681                 RequestStatus = TestEvent.RequestStatusData[1];
682                 
683         }
684         
685         if (TestEvent.RequestStatusData.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.RequestStatusData.size() > 2){
701                 
702                 RequestStatus = TestEvent.RequestStatusData[2];
703                 
704         }
705         
706         if (TestEvent.RequestStatusData.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         
1075 TEST(iCalendarEvent, AlarmTests){
1077         CalendarEventObject TestEvent;
1078         ASSERT_EQ(CALENDAROBJECTLOAD_OK, TestEvent.LoadFile("iCalendarEvent-Load2.vcf"));
1079         ASSERT_EQ(CALENDAROBJECTVALID_OK, TestEvent.ValidBaseObject());
1080         
1081         // Tests for the first VALARM property.
1082         
1083         std::string ActionData;
1084         std::string ActionDataTokens;
1085         
1086         std::string TriggerData;
1087         std::string TriggerRelated;
1088         std::string TriggerValue;
1089         std::string TriggerTokens;
1090         
1091         std::string DurationData;
1092         std::string DurationTokens;
1093         
1094         std::string RepeatData;
1095         std::string RepeatTokens;
1096         
1097         std::string XTokenData;
1098         std::string XTokenName;
1099         
1100         if (TestEvent.CalendarAlarmData.size() > 0){
1101         
1102                 ActionData = TestEvent.CalendarAlarmData[0].AlarmAction;
1103                 ActionDataTokens = TestEvent.CalendarAlarmData[0].AlarmActionTokens;
1104                 
1105                 TriggerData = TestEvent.CalendarAlarmData[0].TriggerData;
1106                 TriggerRelated = TestEvent.CalendarAlarmData[0].TriggerRelated;
1107                 TriggerValue = TestEvent.CalendarAlarmData[0].TriggerValue;
1108                 TriggerTokens = TestEvent.CalendarAlarmData[0].TriggerTokens;
1109                 
1110                 DurationData = TestEvent.CalendarAlarmData[0].DurationData;
1111                 DurationTokens = TestEvent.CalendarAlarmData[0].DurationTokens;
1112                 
1113                 RepeatData = TestEvent.CalendarAlarmData[0].RepeatData;
1114                 RepeatTokens = TestEvent.CalendarAlarmData[0].RepeatTokens;
1115                 
1116         }
1117         
1118         ASSERT_EQ("AUDIO", ActionData);
1119         ASSERT_EQ("FUNKY=SOUNDS", ActionDataTokens);
1120         
1121         ASSERT_EQ("20160220T160000Z", TriggerData);
1122         ASSERT_EQ("END", TriggerRelated);
1123         ASSERT_EQ("DATE-TIME", TriggerValue);
1124         ASSERT_EQ("PUSH=BUTTON", TriggerTokens);
1126         ASSERT_EQ("PT5H", DurationData);
1127         ASSERT_EQ("FLYING=NO", DurationTokens);
1129         ASSERT_EQ("PT5M", RepeatData);
1130         ASSERT_EQ("NEVER=SLEEP", RepeatTokens);
1131         
1132         // Tests for ATTACH. First ATTACH property.
1134         std::string AttachData;
1135         std::string AttachDataFormatType;
1136         std::string AttachDataValue;
1137         std::string AttachDataEncoding;
1138         std::string AttachDataTokens;
1140         if (TestEvent.CalendarAlarmData[0].AttachList.begin() != TestEvent.CalendarAlarmData[0].AttachList.end()){
1141                 
1142                 AttachData = TestEvent.AttachList[0];
1143                 
1144         }
1145         
1146         if (TestEvent.CalendarAlarmData[0].AttachListFormatType.begin() != TestEvent.CalendarAlarmData[0].AttachListFormatType.end()){
1147                 
1148                 AttachDataFormatType = TestEvent.AttachListFormatType[0];
1149                 
1150         }
1152         ASSERT_EQ("http://www.example.com/", AttachData);
1153         ASSERT_EQ("application/internet-shortcut", AttachDataFormatType);
1154         
1155         // Second ATTACH property.
1156         
1157         AttachData.clear();
1158         AttachDataFormatType.clear();
1159         AttachDataValue.clear();
1160         AttachDataEncoding.clear();
1161         
1162         if (TestEvent.CalendarAlarmData[0].AttachList.size() > 1){
1163                 
1164                 AttachData = TestEvent.CalendarAlarmData[0].AttachList[1];
1165                 
1166         }
1167         
1168         if (TestEvent.CalendarAlarmData[0].AttachListFormatType.size() > 1){
1169                 
1170                 AttachDataFormatType = TestEvent.CalendarAlarmData[0].AttachListFormatType[1];
1171                 
1172         }
1174         ASSERT_EQ("http://www.example.com/page2.html", AttachData);
1175         ASSERT_EQ("application/internet-shortcut", AttachDataFormatType);
1176         
1177         // Third ATTACH property.
1179         AttachData.clear();
1180         AttachDataFormatType.clear();
1181         AttachDataValue.clear();
1182         AttachDataEncoding.clear();
1183         AttachDataTokens.clear();
1184         
1185         if (TestEvent.CalendarAlarmData[0].AttachList.size() > 2){
1186                 
1187                 AttachData = TestEvent.CalendarAlarmData[0].AttachList[2];
1188                 
1189         }
1190         
1191         if (TestEvent.CalendarAlarmData[0].AttachListFormatType.size() > 2){
1192                 
1193                 AttachDataFormatType = TestEvent.CalendarAlarmData[0].AttachListFormatType[2];
1194                 
1195         }
1196         
1197         if (TestEvent.CalendarAlarmData[0].AttachListValue.size() > 2){
1198                 
1199                 AttachDataValue = TestEvent.CalendarAlarmData[0].AttachListValue[2];
1200                 
1201         }
1202         
1203         if (TestEvent.CalendarAlarmData[0].AttachListFormatType.size() > 2){
1204                 
1205                 AttachDataEncoding = TestEvent.CalendarAlarmData[0].AttachListEncoding[2];
1206                 
1207         }
1209         if (TestEvent.CalendarAlarmData[0].AttachListTokens.size() > 2){
1210                 
1211                 AttachDataTokens = TestEvent.CalendarAlarmData[0].AttachListTokens[2];
1212                 
1213         }
1214         
1215         ASSERT_EQ("VGhpcyBpcyBhbiBleGFtcGxlIGZpbGU=", AttachData);
1216         ASSERT_EQ("text/plain", AttachDataFormatType);
1217         ASSERT_EQ("BASE64", AttachDataEncoding);
1218         ASSERT_EQ("BINARY", AttachDataValue);
1219         ASSERT_EQ("STUPID=EXAMPLE", AttachDataTokens);
1220         
1221         // Test the first X-Token.
1222         
1223         if (TestEvent.CalendarAlarmData[0].XTokensData.size() > 0){
1224                 
1225                 XTokenData = TestEvent.CalendarAlarmData[0].XTokensData[0];
1226                 XTokenName = TestEvent.CalendarAlarmData[0].XTokensDataTokens[0];
1227                 
1228         }
1229         
1230         ASSERT_EQ("Example Data 1", XTokenData);
1231         ASSERT_EQ("X-EXAMPLE1;YAY=YES", XTokenName);
1232         
1233         // Test the second X-Token.
1234         
1235         XTokenData.clear();
1236         XTokenName.clear();
1237         
1238         if (TestEvent.CalendarAlarmData[0].XTokensData.size() > 1){
1239                 
1240                 XTokenData = TestEvent.CalendarAlarmData[0].XTokensData[1];
1241                 XTokenName = TestEvent.CalendarAlarmData[0].XTokensDataTokens[1];
1242                 
1243         }
1244         
1245         ASSERT_EQ("Example Data 2", XTokenData);
1246         ASSERT_EQ("X-EXAMPLE2;NOPE=YEP", XTokenName);
1247         
1248         // Test the third X-Token.
1250         XTokenData.clear();
1251         XTokenName.clear();
1252         
1253         if (TestEvent.CalendarAlarmData[0].XTokensData.size() > 2){
1254                 
1255                 XTokenData = TestEvent.CalendarAlarmData[0].XTokensData[2];
1256                 XTokenName = TestEvent.CalendarAlarmData[0].XTokensDataTokens[2];
1257                 
1258         }
1259         
1260         ASSERT_EQ("Example Data 3", XTokenData);
1261         ASSERT_EQ("X-EXAMPLE3;WORLD=NO", XTokenName);
1262         
1263         // Tests for the second VALARM property.
1264         
1265         ActionData.clear();
1266         ActionDataTokens.clear();
1267         
1268         TriggerData.clear();
1269         TriggerRelated.clear();
1270         TriggerValue.clear();
1271         TriggerTokens.clear();
1272         
1273         DurationData.clear();
1274         DurationTokens.clear();
1275         
1276         RepeatData.clear();
1277         RepeatTokens.clear();
1278         
1279         XTokenData.clear();
1280         XTokenName.clear();
1281         
1282         string DescriptionData;
1283         string DescriptionAltRep;
1284         string DescriptionLanguage;
1285         string DescriptionTokens;
1286         
1287         if (TestEvent.CalendarAlarmData.size() > 1){
1288                 
1289                 ActionData = TestEvent.CalendarAlarmData[1].AlarmAction;
1290                 ActionDataTokens = TestEvent.CalendarAlarmData[1].AlarmActionTokens;
1291                 
1292                 TriggerData = TestEvent.CalendarAlarmData[1].TriggerData;
1293                 TriggerRelated = TestEvent.CalendarAlarmData[1].TriggerRelated;
1294                 TriggerValue = TestEvent.CalendarAlarmData[1].TriggerValue;
1295                 TriggerTokens = TestEvent.CalendarAlarmData[1].TriggerTokens;
1296                 
1297                 DurationData = TestEvent.CalendarAlarmData[1].DurationData;
1298                 DurationTokens = TestEvent.CalendarAlarmData[1].DurationTokens;
1299                 
1300                 RepeatData = TestEvent.CalendarAlarmData[1].RepeatData;
1301                 RepeatTokens = TestEvent.CalendarAlarmData[1].RepeatTokens;
1302                 
1303                 DescriptionData = TestEvent.CalendarAlarmData[1].DescriptionData;
1304                 DescriptionAltRep = TestEvent.CalendarAlarmData[1].DescriptionAltRep;
1305                 DescriptionLanguage = TestEvent.CalendarAlarmData[1].DescriptionLanguage;
1306                 DescriptionTokens = TestEvent.CalendarAlarmData[1].DescriptionTokens;
1307                 
1308         }
1309         
1310         ASSERT_EQ("DISPLAY", ActionData);
1311         ASSERT_EQ("FLASHING=LIGHTS", ActionDataTokens);
1312         
1313         ASSERT_EQ("20160230T110000Z", TriggerData);
1314         ASSERT_EQ("END", TriggerRelated);
1315         ASSERT_EQ("DATE-TIME", TriggerValue);
1316         ASSERT_EQ("PUSH=BUTTON", TriggerTokens);
1318         ASSERT_EQ("PT7H", DurationData);
1319         ASSERT_EQ("FLYING=YES", DurationTokens);
1321         ASSERT_EQ("PT3M", RepeatData);
1322         ASSERT_EQ("SLEEP=ALWAYS", RepeatTokens);
1323         
1324         ASSERT_EQ("This is the second alarm.", DescriptionData);
1325         ASSERT_EQ("null:nodata", DescriptionAltRep);
1326         ASSERT_EQ("kw", DescriptionLanguage);
1327         ASSERT_EQ("TERRIBLE=TOKEN", DescriptionTokens);
1328         
1329         // Test the first X-Token.
1330         
1331         if (TestEvent.CalendarAlarmData[1].XTokensData.size() > 0){
1332                 
1333                 XTokenData = TestEvent.CalendarAlarmData[1].XTokensData[0];
1334                 XTokenName = TestEvent.CalendarAlarmData[1].XTokensDataTokens[0];
1335                 
1336         }
1337         
1338         ASSERT_EQ("Example Data 1", XTokenData);
1339         ASSERT_EQ("X-EXAMPLE1;YAY=YES", XTokenName);
1340         
1341         // Test the second X-Token.
1342         
1343         XTokenData.clear();
1344         XTokenName.clear();
1345         
1346         if (TestEvent.CalendarAlarmData[1].XTokensData.size() > 1){
1347                 
1348                 XTokenData = TestEvent.CalendarAlarmData[1].XTokensData[1];
1349                 XTokenName = TestEvent.CalendarAlarmData[1].XTokensDataTokens[1];
1350                 
1351         }
1352         
1353         ASSERT_EQ("Example Data 2", XTokenData);
1354         ASSERT_EQ("X-EXAMPLE2;NOPE=YEP", XTokenName);
1355         
1356         // Test the third X-Token.
1358         XTokenData.clear();
1359         XTokenName.clear();
1360         
1361         if (TestEvent.CalendarAlarmData[1].XTokensData.size() > 2){
1362                 
1363                 XTokenData = TestEvent.CalendarAlarmData[1].XTokensData[2];
1364                 XTokenName = TestEvent.CalendarAlarmData[1].XTokensDataTokens[2];
1365                 
1366         }
1367         
1368         ASSERT_EQ("Example Data 3", XTokenData);
1369         ASSERT_EQ("X-EXAMPLE3;WORLD=NO", XTokenName);
1370         
1371         // Tests for the third VALARM property.
1372         
1373         ActionData.clear();
1374         ActionDataTokens.clear();
1375         
1376         TriggerData.clear();
1377         TriggerRelated.clear();
1378         TriggerValue.clear();
1379         TriggerTokens.clear();
1380         
1381         DurationData.clear();
1382         DurationTokens.clear();
1383         
1384         RepeatData.clear();
1385         RepeatTokens.clear();
1386         
1387         XTokenData.clear();
1388         XTokenName.clear();
1389         
1390         DescriptionData.clear();
1391         DescriptionAltRep.clear();
1392         DescriptionLanguage.clear();
1393         DescriptionTokens.clear();
1395         string SummaryData;
1396         string SummaryAltRep;
1397         string SummaryLanguage;
1398         string SummaryTokens;
1399         
1400         string AttendeeDataMember;
1401         string AttendeeDataDelegatedFrom;
1402         string AttendeeDataDelegatedTo;
1403         string AttendeeDataRole;
1404         string AttendeeDataRSVP;
1405         string AttendeeDataDirectoryEntry;
1406         string AttendeeDataSentBy;
1407         string AttendeeDataCommonName;
1408         string AttendeeDataCalendarUserType;
1409         string AttendeeDataParticipationStatus;
1410         string AttendeeDataLanguage;
1411         string AttendeeDataTokens;
1412         string AttendeeData;
1413         
1414         AttachData.clear();
1415         AttachDataFormatType.clear();
1416         AttachDataValue.clear();
1417         AttachDataEncoding.clear();
1418         AttachDataTokens.clear();
1419         
1420         if (TestEvent.CalendarAlarmData.size() > 2){
1421                 
1422                 ActionData = TestEvent.CalendarAlarmData[2].AlarmAction;
1423                 ActionDataTokens = TestEvent.CalendarAlarmData[2].AlarmActionTokens;
1424                 
1425                 TriggerData = TestEvent.CalendarAlarmData[2].TriggerData;
1426                 TriggerRelated = TestEvent.CalendarAlarmData[2].TriggerRelated;
1427                 TriggerValue = TestEvent.CalendarAlarmData[2].TriggerValue;
1428                 TriggerTokens = TestEvent.CalendarAlarmData[2].TriggerTokens;
1429                 
1430                 DurationData = TestEvent.CalendarAlarmData[2].DurationData;
1431                 DurationTokens = TestEvent.CalendarAlarmData[2].DurationTokens;
1432                 
1433                 RepeatData = TestEvent.CalendarAlarmData[2].RepeatData;
1434                 RepeatTokens = TestEvent.CalendarAlarmData[2].RepeatTokens;
1435                 
1436                 DescriptionData = TestEvent.CalendarAlarmData[2].DescriptionData;
1437                 DescriptionAltRep = TestEvent.CalendarAlarmData[2].DescriptionAltRep;
1438                 DescriptionLanguage = TestEvent.CalendarAlarmData[2].DescriptionLanguage;
1439                 DescriptionTokens = TestEvent.CalendarAlarmData[2].DescriptionTokens;
1440                 
1441                 SummaryData = TestEvent.CalendarAlarmData[2].SummaryData;
1442                 SummaryAltRep = TestEvent.CalendarAlarmData[2].SummaryAltRep;
1443                 SummaryLanguage = TestEvent.CalendarAlarmData[2].SummaryLanguage;
1444                 SummaryTokens = TestEvent.CalendarAlarmData[2].SummaryTokens;
1445                 
1446         }
1447         
1448         ASSERT_EQ("EMAIL", ActionData);
1449         ASSERT_EQ("FLASHING=LIGHTS", ActionDataTokens);
1450         
1451         ASSERT_EQ("20160230T120000Z", TriggerData);
1452         ASSERT_EQ("END", TriggerRelated);
1453         ASSERT_EQ("DATE-TIME", TriggerValue);
1454         ASSERT_EQ("PUSH=BUTTON", TriggerTokens);
1456         ASSERT_EQ("PT7H", DurationData);
1457         ASSERT_EQ("FLYING=YES", DurationTokens);
1459         ASSERT_EQ("PT3M", RepeatData);
1460         ASSERT_EQ("SLEEP=ALWAYS", RepeatTokens);
1461         
1462         ASSERT_EQ("This is the third alarm.", DescriptionData);
1463         ASSERT_EQ("null:nodata", DescriptionAltRep);
1464         ASSERT_EQ("kw", DescriptionLanguage);
1465         ASSERT_EQ("TERRIBLE=TOKEN", DescriptionTokens);
1467         ASSERT_EQ("This is the summary of the third alarm.", SummaryData);
1468         ASSERT_EQ("null:nodata", SummaryAltRep);
1469         ASSERT_EQ("en", SummaryLanguage);
1470         ASSERT_EQ("MEEP=MOOP", SummaryTokens);
1472         // Tests for ATTENDEE. First ATTENDEE property.
1474         if (TestEvent.CalendarAlarmData[2].AttendeeList.begin() != TestEvent.CalendarAlarmData[2].AttendeeList.end()){
1475                 
1476                 AttendeeData = TestEvent.CalendarAlarmData[2].AttendeeList[0];
1477                 
1478         }
1479         
1480         ASSERT_EQ("Attendee One", AttendeeData);
1481         
1482         // Second ATTENDEE property.
1483         
1484         AttendeeData.clear();
1485         
1486         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 1){
1487                 
1488                 AttendeeData = TestEvent.CalendarAlarmData[2].AttendeeList[1];
1489                 
1490         }
1492         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 1){
1493                 
1494                 AttendeeDataDelegatedFrom = TestEvent.CalendarAlarmData[2].AttendeeListDelegatedFrom[1];
1495                 
1496         }
1497         
1498         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 1){
1499                 
1500                 AttendeeDataDelegatedTo = TestEvent.CalendarAlarmData[2].AttendeeListDelegatedTo[1];
1501                 
1502         }
1504         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 1){
1505                 
1506                 AttendeeDataRole = TestEvent.CalendarAlarmData[2].AttendeeListRole[1];
1507                 
1508         }
1509         
1510         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 1){
1511                 
1512                 AttendeeDataRSVP = TestEvent.CalendarAlarmData[2].AttendeeListRSVP[1];
1513                 
1514         }
1515         
1516         ASSERT_EQ("Attendee Two", AttendeeData);
1517         ASSERT_EQ("mailto:delegated.from@example.com", AttendeeDataDelegatedFrom);
1518         ASSERT_EQ("mailto:delegated.to@example.com", AttendeeDataDelegatedTo);
1519         ASSERT_EQ("CHAIR", AttendeeDataRole);
1520         ASSERT_EQ("TRUE", AttendeeDataRSVP);
1522         // Third ATTENDEE property.
1523         
1524         AttendeeData.clear();
1525         
1526         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 2){
1527                 
1528                 AttendeeData = TestEvent.CalendarAlarmData[2].AttendeeList[2];
1529                 
1530         }
1532         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 2){
1533                 
1534                 AttendeeDataDirectoryEntry = TestEvent.CalendarAlarmData[2].AttendeeListDirectoryEntry[2];
1535                 
1536         }
1537         
1538         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 2){
1539                 
1540                 AttendeeDataSentBy = TestEvent.CalendarAlarmData[2].AttendeeListSentBy[2];
1541                 
1542         }
1544         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 2){
1545                 
1546                 AttendeeDataCommonName = TestEvent.CalendarAlarmData[2].AttendeeListCommonName[2];
1547                 
1548         }
1549         
1550         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 2){
1551                 
1552                 AttendeeDataCalendarUserType = TestEvent.CalendarAlarmData[2].AttendeeListCalendarUserType[2];
1553                 
1554         }
1556         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 2){
1557                 
1558                 AttendeeDataParticipationStatus = TestEvent.CalendarAlarmData[2].AttendeeListParticipationStatus[2];
1559                 
1560         }
1562         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 2){
1563                 
1564                 AttendeeDataLanguage = TestEvent.CalendarAlarmData[2].AttendeeListLanguage[2];
1565                 
1566         }
1567         
1568         if (TestEvent.CalendarAlarmData[2].AttendeeList.size() > 2){
1569                 
1570                 AttendeeDataTokens = TestEvent.CalendarAlarmData[2].AttendeeListTokens[2];
1571                 
1572         }
1573         
1574         ASSERT_EQ("Attendee Three", AttendeeData);
1575         ASSERT_EQ("null:nodata", AttendeeDataDirectoryEntry);
1576         ASSERT_EQ("mailto:sent.by@example.com", AttendeeDataSentBy);
1577         ASSERT_EQ("Attendee The Third", AttendeeDataCommonName);
1578         ASSERT_EQ("INDIVIDUAL", AttendeeDataCalendarUserType);
1579         ASSERT_EQ("ACCEPTED", AttendeeDataParticipationStatus);
1580         ASSERT_EQ("kw", AttendeeDataLanguage);
1581         ASSERT_EQ("EXAMPLE=DATA", AttendeeDataTokens);
1583         // Tests for ATTACH. First ATTACH property.
1585         if (TestEvent.CalendarAlarmData[2].AttachList.begin() != TestEvent.CalendarAlarmData[2].AttachList.end()){
1586                 
1587                 AttachData = TestEvent.CalendarAlarmData[2].AttachList[0];
1588                 
1589         }
1590         
1591         if (TestEvent.CalendarAlarmData[2].AttachListFormatType.begin() != TestEvent.CalendarAlarmData[2].AttachListFormatType.end()){
1592                 
1593                 AttachDataFormatType = TestEvent.CalendarAlarmData[2].AttachListFormatType[0];
1594                 
1595         }
1597         ASSERT_EQ("http://www.example.com/", AttachData);
1598         ASSERT_EQ("application/internet-shortcut", AttachDataFormatType);
1599         
1600         // Second ATTACH property.
1601         
1602         AttachData.clear();
1603         AttachDataFormatType.clear();
1604         AttachDataValue.clear();
1605         AttachDataEncoding.clear();
1606         
1607         if (TestEvent.CalendarAlarmData[2].AttachList.size() > 1){
1608                 
1609                 AttachData = TestEvent.CalendarAlarmData[2].AttachList[1];
1610                 
1611         }
1612         
1613         if (TestEvent.CalendarAlarmData[2].AttachListFormatType.size() > 1){
1614                 
1615                 AttachDataFormatType = TestEvent.CalendarAlarmData[2].AttachListFormatType[1];
1616                 
1617         }
1619         ASSERT_EQ("http://www.example.com/page2.html", AttachData);
1620         ASSERT_EQ("application/internet-shortcut", AttachDataFormatType);
1621         
1622         // Third ATTACH property.
1624         AttachData.clear();
1625         AttachDataFormatType.clear();
1626         AttachDataValue.clear();
1627         AttachDataEncoding.clear();
1628         AttachDataTokens.clear();
1629         
1630         if (TestEvent.CalendarAlarmData[2].AttachList.size() > 2){
1631                 
1632                 AttachData = TestEvent.CalendarAlarmData[2].AttachList[2];
1633                 
1634         }
1635         
1636         if (TestEvent.CalendarAlarmData[2].AttachListFormatType.size() > 2){
1637                 
1638                 AttachDataFormatType = TestEvent.CalendarAlarmData[2].AttachListFormatType[2];
1639                 
1640         }
1641         
1642         if (TestEvent.CalendarAlarmData[2].AttachListValue.size() > 2){
1643                 
1644                 AttachDataValue = TestEvent.CalendarAlarmData[2].AttachListValue[2];
1645                 
1646         }
1647         
1648         if (TestEvent.CalendarAlarmData[2].AttachListFormatType.size() > 2){
1649                 
1650                 AttachDataEncoding = TestEvent.CalendarAlarmData[2].AttachListEncoding[2];
1651                 
1652         }
1654         if (TestEvent.CalendarAlarmData[2].AttachListTokens.size() > 2){
1655                 
1656                 AttachDataTokens = TestEvent.CalendarAlarmData[2].AttachListTokens[2];
1657                 
1658         }
1659         
1660         ASSERT_EQ("VGhpcyBpcyBhbiBleGFtcGxlIGZpbGU=", AttachData);
1661         ASSERT_EQ("text/plain", AttachDataFormatType);
1662         ASSERT_EQ("BASE64", AttachDataEncoding);
1663         ASSERT_EQ("BINARY", AttachDataValue);
1664         ASSERT_EQ("STUPID=EXAMPLE", AttachDataTokens);
1665         
1666         // Test the first X-Token.
1667         
1668         if (TestEvent.CalendarAlarmData[2].XTokensData.size() > 0){
1669                 
1670                 XTokenData = TestEvent.CalendarAlarmData[2].XTokensData[0];
1671                 XTokenName = TestEvent.CalendarAlarmData[2].XTokensDataTokens[0];
1672                 
1673         }
1674         
1675         ASSERT_EQ("Example Data 1", XTokenData);
1676         ASSERT_EQ("X-EXAMPLE1;YAY=YES", XTokenName);
1677         
1678         // Test the second X-Token.
1679         
1680         XTokenData.clear();
1681         XTokenName.clear();
1682         
1683         if (TestEvent.CalendarAlarmData[2].XTokensData.size() > 1){
1684                 
1685                 XTokenData = TestEvent.CalendarAlarmData[2].XTokensData[1];
1686                 XTokenName = TestEvent.CalendarAlarmData[2].XTokensDataTokens[1];
1687                 
1688         }
1689         
1690         ASSERT_EQ("Example Data 2", XTokenData);
1691         ASSERT_EQ("X-EXAMPLE2;NOPE=YEP", XTokenName);
1692         
1693         // Test the third X-Token.
1695         XTokenData.clear();
1696         XTokenName.clear();
1697         
1698         if (TestEvent.CalendarAlarmData[2].XTokensData.size() > 2){
1699                 
1700                 XTokenData = TestEvent.CalendarAlarmData[2].XTokensData[2];
1701                 XTokenName = TestEvent.CalendarAlarmData[2].XTokensDataTokens[2];
1702                 
1703         }
1704         
1705         ASSERT_EQ("Example Data 3", XTokenData);
1706         ASSERT_EQ("X-EXAMPLE3;WORLD=NO", XTokenName);
1707         
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