Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
Version 0.06 release
[xestiacalendar/.git] / source / tests / iCalendarTaskTests / iCalendarTaskLoad.cpp
1 // xestiacalendar_icaltaskload.h - Xestia Calendar iCalendar Task Component Unit Tests
2 //
3 // (c) 2016-2017 Xestia Software Development.
4 //
5 // This file is part of Xestia Calendar.
6 //
7 // Xestia Calendar 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 Calendar 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/calendartask/CalendarTask.h"
20 #include <gtest/gtest.h>
22 class iCalendarTaskLoadTests : public ::testing::Test
23 {
24 private:
25     virtual void SetUp()
26     {
27     }
28     
29     virtual void TearDown()
30     {
31     }
32 };
34 TEST_F(iCalendarTaskLoadTests, BasicTests){
36         CalendarTaskObject testTask;
37         
38         ASSERT_EQ(CALENDAROBJECTLOAD_MISSING, testTask.LoadFile("iCalendarTask-Missing.vcf"));
39         ASSERT_EQ(CALENDAROBJECTLOAD_CANNOTOPEN, testTask.LoadFile("iCalendarTask-InvalidPermissions.vcf"));
40         ASSERT_EQ(CALENDAROBJECTLOAD_OK, testTask.LoadFile("iCalendarTask-Load1.vcf"));
41         
42 }
44 TEST_F(iCalendarTaskLoadTests, ObjectDataTests){
46         CalendarTaskObject testTask;
47         ASSERT_EQ(CALENDAROBJECTLOAD_OK, testTask.LoadFile("iCalendarTask-Load2.vcf"));
48         ASSERT_EQ(CALENDAROBJECTVALID_OK, testTask.ValidBaseObject());
49         
50         // Tests for DTSTAMP.
51         
52         ASSERT_EQ("20160131T104500Z", testTask.dateTimeStampData);
53         ASSERT_EQ("OTHER=PARAM", testTask.dateTimeStampTokens);
54         
55         // Tests for UID.
56         
57         ASSERT_EQ("b3a16392-ad86-4061-be53-c215af2306e1", testTask.uniqueID);
58         ASSERT_EQ("UNIQUEPARAM=CERTAINLY;OKAY=MAYBENOT", testTask.uniqueIDTokens);
59         
60         // Tests for CLASS.
61         
62         ASSERT_EQ("PUBLIC", testTask.classData);
63         ASSERT_EQ("CHOCOLATE=NONE", testTask.classDataTokens);
64         
65         // Tests for COMPLETED.
66         
67         ASSERT_EQ("20160131T110100Z", testTask.completedData);
68         ASSERT_EQ("LYING=NEVER", testTask.completedDataTokens);
69         
70         // Tests for CREATED.
72         ASSERT_EQ("20160131T080000Z", testTask.dateTimeCreatedData);
73         ASSERT_EQ("CARAMEL=PLEASE", testTask.dateTimeCreatedTokens);
74         
75         // Tests for DESCRIPTION.
76         
77         std::string descriptionData;
78         std::string descriptionAltRep;
79         std::string descriptionLanguage;
80         std::string descriptionTokens;
81         
82         if (testTask.descriptionList.begin() != testTask.descriptionList.end()){
83                 descriptionData = testTask.descriptionList[0];
84         }
86         if (testTask.descriptionListAltRep.begin() != testTask.descriptionListAltRep.end()){
87                 descriptionAltRep = testTask.descriptionListAltRep[0];
88         }
90         if (testTask.descriptionListLanguage.begin() != testTask.descriptionListLanguage.end()){
91                 descriptionLanguage = testTask.descriptionListLanguage[0];
92         }
94         if (testTask.descriptionListTokens.begin() != testTask.descriptionListTokens.end()){
95                 descriptionTokens = testTask.descriptionListTokens[0];
96         }
97         
98         ASSERT_EQ("This is a description of the todo.", descriptionData);
99         ASSERT_EQ("null:nodata", descriptionAltRep);
100         ASSERT_EQ("kw", descriptionLanguage);
101         ASSERT_EQ("EXAMPLE=TOKEN;MOREDATA=YES", descriptionTokens);
102         
103         // Tests for DTSTART.
104         
105         ASSERT_EQ("20160131T103000Z", testTask.dateTimeStartData);
106         ASSERT_EQ("DATE-TIME", testTask.dateTimeStartDataValue);
107         ASSERT_EQ("Europe/Truro", testTask.dateTimeStartDataTimeZoneID);
108         ASSERT_EQ("PARAMONE=YES;PARAMTWO=NO", testTask.dateTimeStartDataTokens);
109         
110         // Tests for GEO.
111         
112         ASSERT_EQ("20.0;20.0", testTask.geographicData);
113         ASSERT_EQ("EXAMPLE=MOOP", testTask.geographicTokens);
114         
115         // Tests for LAST-MODIFIED.
116         
117         ASSERT_EQ("20160131T114200Z", testTask.lastModifiedData);
118         ASSERT_EQ("FUTURE=EVEN", testTask.lastModifiedTokens);
119         
120         // Tests for LOCATION.
122         ASSERT_EQ("The Crystal Ceiling, Truro", testTask.locationData);
123         ASSERT_EQ("null:nodata", testTask.locationDataAltRep);
124         ASSERT_EQ("kw", testTask.locationDataLanguage);
125         ASSERT_EQ("EXACT=YES", testTask.locationDataTokens);
126         
127         // Tests for ORGANIZER.
128         
129         ASSERT_EQ("mailto:organiser@example.com", testTask.organiserData);
130         ASSERT_EQ("ExampleOrganiser", testTask.organiserDataCommonName);
131         ASSERT_EQ("null:nodata", testTask.organiserDataDirectoryEntry);
132         ASSERT_EQ("mailto:organiser.noreply@example.com", testTask.organiserDataSentByParam);
133         ASSERT_EQ("kw", testTask.organiserDataLanguage);
134         ASSERT_EQ("HAPPY=WEEKS", testTask.organiserDataTokens);
135         
136         // Tests for PERCENT-COMPLETE.
137         
138         ASSERT_EQ("42", testTask.percentCompleteData);
139         ASSERT_EQ("DEEP=THOUGHT", testTask.percentCompleteTokens);
140         
141         // Tests for PRIORITY.
142         
143         ASSERT_EQ(5, testTask.priorityData);
144         ASSERT_EQ("STATUS=DEFAULT", testTask.priorityTokens);
145         
146         // Tests for RECURRENCE-ID.
147         
148         ASSERT_EQ("20160131", testTask.recurranceIDData);
149         ASSERT_EQ("Europe/Truro", testTask.recurranceIDDataTimeZoneParam);
150         ASSERT_EQ("THISANDFUTURE", testTask.recurranceIDDataRangeParam);
151         ASSERT_EQ("DATE", testTask.recurranceIDDataValue);
152         ASSERT_EQ("EXAMPLE=DATA", testTask.recurranceIDDataTokens);
153         
154         // Tests for SEQUENCE.
155         
156         ASSERT_EQ(3, testTask.sequenceData);
157         ASSERT_EQ("TEST=YAY", testTask.sequenceTokens);
158         
159         // Tests for STATUS.
160         
161         ASSERT_EQ("2.0;Success", testTask.statusData);
162         ASSERT_EQ("kw", testTask.statusLanguage);
163         ASSERT_EQ("FAVOURITE=BEANS;NOTLIKE=UNKNOWN", testTask.statusTokens);
164         
165         // Tests for SUMMARY.
166         
167         ASSERT_EQ("A summary of the todo.", testTask.summaryData);
168         ASSERT_EQ("null:nodata", testTask.summaryDataAltRep);
169         ASSERT_EQ("kw", testTask.summaryDataLanguage);
170         ASSERT_EQ("FAVOURITE=TOFU;NOTLIKE=NONE", testTask.summaryDataTokens);
171         
172         // Tests for URL.
174         ASSERT_EQ("http://www.example.com/", testTask.urlData);
175         ASSERT_EQ("EXTERNAL=YES", testTask.urlDataTokens);
176         
177         // Tests for RRULE.
178         
179         ASSERT_EQ("FREQ=DAILY;COUNT=10", testTask.recurranceRuleData);
180         ASSERT_EQ("TEST=DATA", testTask.recurranceRuleDataTokens);
181         
182         // Tests for DUE.
183         
184         ASSERT_EQ("20160131T150000Z", testTask.dueData);
185         ASSERT_EQ("Europe/Truro", testTask.dueDataTimeZoneID);
186         ASSERT_EQ("DATE-TIME", testTask.dueDataValue);
187         ASSERT_EQ("TEST=YES", testTask.dueDataTokens);
188         
189         // Tests for DURATION.
190         
191         CalendarTaskObject testTask2;
192         ASSERT_EQ(CALENDAROBJECTLOAD_OK, testTask2.LoadFile("iCalendarTask-Load3.vcf"));
193         ASSERT_EQ(CALENDAROBJECTVALID_OK, testTask2.ValidBaseObject());
194         
195         ASSERT_EQ("PT15M", testTask2.durationData);
196         ASSERT_EQ("TEST=YES", testTask2.durationDataTokens);
197         
198         // Tests for ATTACH. First ATTACH property.
200         std::string attachData;
201         std::string attachDataFormatType;
202         std::string attachDataValue;
203         std::string attachDataEncoding;
204         std::string attachDataTokens;
206         if (testTask.attachList.begin() != testTask.attachList.end()){
207                 
208                 attachData = testTask.attachList[0];
209                 
210         }
211         
212         if (testTask.attachListFormatType.begin() != testTask.attachListFormatType.end()){
213                 
214                 attachDataFormatType = testTask.attachListFormatType[0];
215                 
216         }
218         ASSERT_EQ("http://www.example.com/", attachData);
219         ASSERT_EQ("application/internet-shortcut", attachDataFormatType);
220         
221         // Second ATTACH property.
222         
223         attachData.clear();
224         attachDataFormatType.clear();
225         attachDataValue.clear();
226         attachDataEncoding.clear();
227         
228         if (testTask.attachList.size() > 1){
229                 
230                 attachData = testTask.attachList[1];
231                 
232         }
233         
234         if (testTask.attachListFormatType.size() > 1){
235                 
236                 attachDataFormatType = testTask.attachListFormatType[1];
237                 
238         }
240         ASSERT_EQ("http://www.example.com/page2.html", attachData);
241         ASSERT_EQ("application/internet-shortcut", attachDataFormatType);
242         
243         // Third ATTACH property.
245         attachData.clear();
246         attachDataFormatType.clear();
247         attachDataValue.clear();
248         attachDataEncoding.clear();
249         attachDataTokens.clear();
250         
251         if (testTask.attachList.size() > 2){
252                 
253                 attachData = testTask.attachList[2];
254                 
255         }
256         
257         if (testTask.attachListFormatType.size() > 2){
258                 
259                 attachDataFormatType = testTask.attachListFormatType[2];
260                 
261         }
262         
263         if (testTask.attachListValue.size() > 2){
264                 
265                 attachDataValue = testTask.attachListValue[2];
266                 
267         }
268         
269         if (testTask.attachListFormatType.size() > 2){
270                 
271                 attachDataEncoding = testTask.attachListEncoding[2];
272                 
273         }
275         if (testTask.attachListTokens.size() > 2){
276                 
277                 attachDataTokens = testTask.attachListTokens[2];
278                 
279         }
280         
281         ASSERT_EQ("VGhpcyBpcyBhbiBleGFtcGxlIGZpbGU=", attachData);
282         ASSERT_EQ("text/plain", attachDataFormatType);
283         ASSERT_EQ("BASE64", attachDataEncoding);
284         ASSERT_EQ("BINARY", attachDataValue);
285         ASSERT_EQ("STUPID=EXAMPLE", attachDataTokens);
286         
287         // Tests for ATTENDEE. First ATTENDEE property.
289         std::string attendeeDataMember;
290         std::string attendeeDataDelegatedFrom;
291         std::string attendeeDataDelegatedTo;
292         std::string attendeeDataRole;
293         std::string attendeeDataRSVP;
294         std::string attendeeDataDirectoryEntry;
295         std::string attendeeDataSentBy;
296         std::string attendeeDataCommonName;
297         std::string attendeeDataCalendarUserType;
298         std::string attendeeDataParticipationStatus;
299         std::string attendeeDataLanguage;
300         std::string attendeeDataTokens;
301         std::string attendeeData;
303         if (testTask.attendeeList.begin() != testTask.attendeeList.end()){
304                 
305                 attendeeData = testTask.attendeeList[0];
306                 
307         }
308         
309         ASSERT_EQ("Attendee One", attendeeData);
310         
311         // Second ATTENDEE property.
312         
313         attendeeData.clear();
314         
315         if (testTask.attendeeList.size() > 1){
316                 
317                 attendeeData = testTask.attendeeList[1];
318                 
319         }
321         if (testTask.attendeeList.size() > 1){
322                 
323                 attendeeDataDelegatedFrom = testTask.attendeeListDelegatedFrom[1];
324                 
325         }
326         
327         if (testTask.attendeeList.size() > 1){
328                 
329                 attendeeDataDelegatedTo = testTask.attendeeListDelegatedTo[1];
330                 
331         }
333         if (testTask.attendeeList.size() > 1){
334                 
335                 attendeeDataRole = testTask.attendeeListRole[1];
336                 
337         }
338         
339         if (testTask.attendeeList.size() > 1){
340                 
341                 attendeeDataRSVP = testTask.attendeeListRSVP[1];
342                 
343         }
344         
345         ASSERT_EQ("Attendee Two", attendeeData);
346         ASSERT_EQ("mailto:delegated.from@example.com", attendeeDataDelegatedFrom);
347         ASSERT_EQ("mailto:delegated.to@example.com", attendeeDataDelegatedTo);
348         ASSERT_EQ("CHAIR", attendeeDataRole);
349         ASSERT_EQ("TRUE", attendeeDataRSVP);
351         // Third ATTENDEE property.
352         
353         attendeeData.clear();
354         
355         if (testTask.attendeeList.size() > 2){
356                 
357                 attendeeData = testTask.attendeeList[2];
358                 
359         }
361         if (testTask.attendeeList.size() > 2){
362                 
363                 attendeeDataDirectoryEntry = testTask.attendeeListDirectoryEntry[2];
364                 
365         }
366         
367         if (testTask.attendeeList.size() > 2){
368                 
369                 attendeeDataSentBy = testTask.attendeeListSentBy[2];
370                 
371         }
373         if (testTask.attendeeList.size() > 2){
374                 
375                 attendeeDataCommonName = testTask.attendeeListCommonName[2];
376                 
377         }
378         
379         if (testTask.attendeeList.size() > 2){
380                 
381                 attendeeDataCalendarUserType = testTask.attendeeListCalendarUserType[2];
382                 
383         }
385         if (testTask.attendeeList.size() > 2){
386                 
387                 attendeeDataParticipationStatus = testTask.attendeeListParticipationStatus[2];
388                 
389         }
391         if (testTask.attendeeList.size() > 2){
392                 
393                 attendeeDataLanguage = testTask.attendeeListLanguage[2];
394                 
395         }
396         
397         if (testTask.attendeeList.size() > 2){
398                 
399                 attendeeDataTokens = testTask.attendeeListTokens[2];
400                 
401         }
402         
403         ASSERT_EQ("Attendee Three", attendeeData);
404         ASSERT_EQ("null:nodata", attendeeDataDirectoryEntry);
405         ASSERT_EQ("mailto:sent.by@example.com", attendeeDataSentBy);
406         ASSERT_EQ("Attendee The Third", attendeeDataCommonName);
407         ASSERT_EQ("INDIVIDUAL", attendeeDataCalendarUserType);
408         ASSERT_EQ("ACCEPTED", attendeeDataParticipationStatus);
409         ASSERT_EQ("kw", attendeeDataLanguage);
410         ASSERT_EQ("EXAMPLE=DATA", attendeeDataTokens);
411         
412         // Get the first CATEGORIES.
413         
414         std::string categoryData;
415         
416         if (testTask.categoriesList.begin() != testTask.categoriesList.end()){
417                 
418                 categoryData = testTask.categoriesList[0];
419                 
420         }
421         
422         ASSERT_EQ("CATEGORY ONE, CATEGORY TWO", categoryData);
423         
424         categoryData.clear();
426         std::string categoryLanguage;
427         
428         // Get the second CATEGORIES.
429         
430         if (testTask.categoriesList.size() > 1){
431                 
432                 categoryData = testTask.categoriesList[1];
433                 
434         }
435         
436         if (testTask.categoriesList.size() > 1){
437                 
438                 categoryLanguage = testTask.categoriesListLanguage[1];
439                 
440         }
441                 
442         ASSERT_EQ("CATEGORY THREE, CATEGORY FOUR", categoryData);
443         ASSERT_EQ("en", categoryLanguage);
444         
445         categoryData.clear();
446         categoryLanguage.clear();
447         
448         // Get the third CATEGORIES.
449         
450         std::string categoryTokens;
451         
452         if (testTask.categoriesList.size() > 2){
453                 
454                 categoryData = testTask.categoriesList[2];
455                 
456         }
457         
458         if (testTask.categoriesList.size() > 2){
459                 
460                 categoryLanguage = testTask.categoriesListLanguage[2];
461                 
462         }
463         
464         if (testTask.categoriesList.size() > 2){
465                 
466                 categoryTokens = testTask.categoriesListTokens[2];
467                 
468         }
469                 
470         ASSERT_EQ("CATEGORY FIVE, CATEGORY SIX, CATEGORY SEVEN", categoryData);
471         ASSERT_EQ("en-GB", categoryLanguage);
472         ASSERT_EQ("SAMPLE=TOKEN", categoryTokens);
473         
474         // Get the first COMMENT.
475         
476         std::string commentData;
477         
478         if (testTask.commentList.begin() != testTask.commentList.end()){
479                 
480                 commentData = testTask.commentList[0];
481                 
482         }
483         
484         ASSERT_EQ("This is the first comment.", commentData);
485         
486         // Get the second COMMENT.
487         
488         commentData.clear();
489         
490         std::string commentDataAltRep;
491         std::string commentDataLanguage;
492         
493         if (testTask.commentList.size() > 1){
494                 
495                 commentData = testTask.commentList[1];
496                 
497         }
498         
499         if (testTask.commentList.size() > 1){
500                 
501                 commentDataAltRep = testTask.commentListAltRep[1];
502                 
503         }
504         
505         if (testTask.commentList.size() > 1){
506                 
507                 commentDataLanguage = testTask.commentListLanguage[1];
508                 
509         }
510         
511         ASSERT_EQ("This is the second comment.", commentData);
512         ASSERT_EQ("null:nodata", commentDataAltRep);
513         ASSERT_EQ("en", commentDataLanguage);
514         
515         // Get the third COMMENT.
516         
517         commentData.clear();
518         
519         std::string commentDataTokens;
520         
521         if (testTask.commentList.size() > 2){
522                 
523                 commentData = testTask.commentList[2];
524                 
525         }
526         
527         if (testTask.commentList.size() > 2){
528                 
529                 commentDataTokens = testTask.commentListTokens[2];
530                 
531         }
532         
533         ASSERT_EQ("This is the third comment.", commentData);
534         ASSERT_EQ("ZEBRAS=YES", commentDataTokens);
536         // Get the first CONTACT.
537         
538         std::string contactData;
539         
540         if (testTask.contactList.begin() != testTask.contactList.end()){
541                 
542                 contactData = testTask.contactList[0];
543                 
544         }
545         
546         ASSERT_EQ("First Contact", contactData);
547         
548         // Get the second CONTACT.
549         
550         contactData.clear();
551         
552         std::string contactDataAltRep;
553         std::string contactDataLanguage;
554         
555         if (testTask.contactList.size() > 1){
556                 
557                 contactData = testTask.contactList[1];
558                 
559         }
560         
561         if (testTask.contactList.size() > 1){
562                 
563                 contactDataAltRep = testTask.contactListAltRep[1];
564                 
565         }
566         
567         if (testTask.contactList.size() > 1){
568                 
569                 contactDataLanguage = testTask.contactListLanguage[1];
570                 
571         }
572         
573         ASSERT_EQ("Second Contact", contactData);
574         ASSERT_EQ("null:nodata", contactDataAltRep);
575         ASSERT_EQ("en-GB", contactDataLanguage);
576         
577         // Get the third CONTACT.
578         
579         contactData.clear();
580         
581         std::string contactDataTokens;
582         
583         if (testTask.contactList.size() > 2){
584                 
585                 contactData = testTask.contactList[2];
586                 
587         }
588         
589         if (testTask.contactList.size() > 2){
590                 
591                 contactDataTokens = testTask.contactListTokens[2];
592                 
593         }
594         
595         ASSERT_EQ("Third Contact", contactData);
596         ASSERT_EQ("ZEBRAS=NO", contactDataTokens);
598         // Get the first EXDATE.
599         
600         std::string excludeDate;
601         
602         if (testTask.excludeDateData.begin() != testTask.excludeDateData.end()){
603                 
604                 excludeDate = testTask.excludeDateData[0];
605                 
606         }
607         
608         ASSERT_EQ("20160125T120000Z", excludeDate);
609         
610         // Get the second EXDATE.
612         excludeDate.clear();
613         
614         std::string excludeDataTimeZoneParam;
615         std::string excludeDataValue;
616         
617         if (testTask.contactList.size() > 1){
618                 
619                 excludeDate = testTask.excludeDateData[1];
620                 
621         }
622         
623         if (testTask.contactList.size() > 1){
624                 
625                 excludeDataTimeZoneParam = testTask.excludeDateDataTimeZoneParam[1];
626                 
627         }
628         
629         if (testTask.contactList.size() > 1){
630                 
631                 excludeDataValue = testTask.excludeDateDataValue[1];
632                 
633         }
634         
635         ASSERT_EQ("20160125T130000Z", excludeDate);
636         ASSERT_EQ("DATE-TIME", excludeDataValue);
637         ASSERT_EQ("Europe/Truro", excludeDataTimeZoneParam);
638         
639         // Get the third EXDATE.
640         
641         excludeDate.clear();
642         
643         std::string excludeDataTokens;
644         
645         if (testTask.contactList.size() > 2){
646                 
647                 excludeDate = testTask.excludeDateData[2];
648                 
649         }
650         
651         if (testTask.contactList.size() > 2){
652                 
653                 excludeDataTokens = testTask.excludeDateDataTokens[2];
654                 
655         }
656         
657         ASSERT_EQ("20160125T133000Z", excludeDate);
658         ASSERT_EQ("ZOOP=ZIPPO", excludeDataTokens);
659         
660         // Get the first REQUEST-STATUS.
662         std::string requestStatus;
663         
664         if (testTask.requestStatusData.begin() != testTask.requestStatusData.end()){
665                 
666                 requestStatus = testTask.requestStatusData[0];
667                 
668         }
669         
670         ASSERT_EQ("2.0;Success", requestStatus);
671         
672         // Get the second REQUEST-STATUS.
673         
674         requestStatus.clear();
675         
676         std::string requestLanguage;
677         
678         if (testTask.contactList.size() > 1){
679                 
680                 requestStatus = testTask.requestStatusData[1];
681                 
682         }
683         
684         if (testTask.contactList.size() > 1){
685                 
686                 requestLanguage = testTask.requestStatusLanguage[1];
687                 
688         }
689         
690         ASSERT_EQ("3.42;Really big irrecoverable error caused by the user", requestStatus);
691         ASSERT_EQ("en", requestLanguage);
692         
693         // Get the third REQUEST-STATUS.
694         
695         requestStatus.clear();
696         
697         std::string requestTokens;
698         
699         if (testTask.contactList.size() > 2){
700                 
701                 requestStatus = testTask.requestStatusData[2];
702                 
703         }
704         
705         if (testTask.contactList.size() > 2){
706                 
707                 requestTokens = testTask.requestStatusTokens[2];
708                 
709         }
710         
711         ASSERT_EQ("3.7;Invalid calendar user", requestStatus);
712         ASSERT_EQ("USER=MISSING", requestTokens);
713         
714         // Get the first RELATED-TO.
715         
716         std::string relatedTo;
717         
718         if (testTask.relatedToData.begin() != testTask.relatedToData.end()){
719                 
720                 relatedTo = testTask.relatedToData[0];
721                 
722         }
723         
724         ASSERT_EQ("person.1@example.com", relatedTo);
725         
726         // Get the second RELATED-TO.
727         
728         relatedTo.clear();
729         
730         std::string relatedToType;
731         
732         if (testTask.relatedToData.size() > 1){
733                 
734                 relatedTo = testTask.relatedToData[1];
735                 
736         }
737         
738         if (testTask.relatedToData.size() > 1){
739                 
740                 relatedToType = testTask.relatedToDataRelationType[1];
741                 
742         }
743         
744         ASSERT_EQ("person.2@example.com", relatedTo);
745         ASSERT_EQ("PARENT", relatedToType);
746         
747         // Get the third RELATED-TO.
748         
749         relatedTo.clear();
750         
751         std::string relatedToTokens;
752         
753         if (testTask.relatedToData.size() > 2){
754                 
755                 relatedTo = testTask.relatedToData[2];
756                 
757         }
758         
759         if (testTask.relatedToData.size() > 2){
760                 
761                 relatedToTokens = testTask.relatedToDataTokens[2];
762                 
763         }
764         
765         ASSERT_EQ("person.3@example.com", relatedTo);
766         ASSERT_EQ("SCHOOL=MEETING", relatedToTokens);
767         
768         // Get the first RESOURCES.
770         std::string resources;
771         
772         if (testTask.resourcesData.begin() != testTask.resourcesData.end()){
773                 
774                 resources = testTask.resourcesData[0];
775                 
776         }
777         
778         ASSERT_EQ("DMAC RECEIVER", resources);
779         
780         // Get the second RESOURCES.
781         
782         resources.clear();
783         
784         std::string resourcesLanguage;
785         
786         if (testTask.resourcesData.size() > 1){
787                 
788                 resources = testTask.resourcesData[1];
789                 
790         }
791         
792         if (testTask.resourcesData.size() > 1){
793                 
794                 resourcesLanguage = testTask.resourcesDataLanguage[1];
795                 
796         }
797         
798         ASSERT_EQ("PAL-I TELEVISION SET", resources);
799         ASSERT_EQ("en", resourcesLanguage);
800         
801         // Get the third RESOURCES.
802         
803         resources.clear();
804         
805         std::string resourcesAltRep;
806         std::string resourcesTokens;
807         
808         if (testTask.resourcesData.size() > 2){
809                 
810                 resources = testTask.resourcesData[2];
811                 
812         }
813                 
814         if (testTask.resourcesData.size() > 2){
815                 
816                 resourcesAltRep = testTask.resourcesDataAltRep[2];
817                 
818         }
819         
820         if (testTask.resourcesData.size() > 2){
821                 
822                 resourcesTokens = testTask.resourcesDataTokens[2];
823                 
824         }
825         
826         ASSERT_EQ("PAL/SECAM VCR", resources);
827         ASSERT_EQ("null:nodata", resourcesAltRep);
828         ASSERT_EQ("STATUS=BROKEN", resourcesTokens);
829         
830         // Get the first RDATE.
832         std::string recurrenceDate;
833         
834         if (testTask.recurranceDateData.begin() != testTask.recurranceDateData.end()){
835                 
836                 recurrenceDate = testTask.recurranceDateData[0];
837                 
838         }
839         
840         ASSERT_EQ("20160120", recurrenceDate);
841         
842         // Get the second RDATE.
843         
844         recurrenceDate.clear();
845         
846         std::string recurrenceDateTimeZoneParam;
847         std::string recurrenceDateValue;
848         
849         if (testTask.recurranceDateData.size() > 1){
850                 
851                 recurrenceDate = testTask.recurranceDateData[1];
852                 
853         }
854         
855         if (testTask.recurranceDateData.size() > 1){
856                 
857                 recurrenceDateTimeZoneParam = testTask.recurranceDateDataTimeZoneParam[1];
858                 
859         }
860         
861         if (testTask.recurranceDateData.size() > 1){
862                 
863                 recurrenceDateValue = testTask.recurranceDateDataValue[1];
864                 
865         }
866         
867         ASSERT_EQ("20160121", recurrenceDate);
868         ASSERT_EQ("DATE", recurrenceDateValue);
869         ASSERT_EQ("Europe/Truro", recurrenceDateTimeZoneParam);
870         
871         // Get the third RDATE.
872         
873         recurrenceDate.clear();
874         
875         std::string recurrenceTokens;
876         
877         if (testTask.recurranceDateData.size() > 2){
878                 
879                 recurrenceDate = testTask.recurranceDateData[2];
880                 
881         }
882         
883         if (testTask.recurranceDateData.size() > 2){
884                 
885                 recurrenceTokens = testTask.recurranceDateDataTokens[2];
886                 
887         }
888         
889         ASSERT_EQ("20160520", recurrenceDate);
890         ASSERT_EQ("ZILCH=DATA", recurrenceTokens);
891         
892         // Get the first X-EXAMPLE1 token.
893         
894         std::string xTokenName;
895         std::string xTokenData;
896         
897         if (testTask.xTokensData.size() != 0 ){
898         
899                 xTokenData = testTask.xTokensData[0];
900                 
901         }
903         if (testTask.xTokensData.size() != 0){
904         
905                 xTokenName = testTask.xTokensDataTokens[0];
906                 
907         }
908         
909         ASSERT_EQ("Moo", xTokenData);
910         ASSERT_EQ("X-EXAMPLE1", xTokenName);
911         
912         // Get the second X-EXAMPLE1 token.
914         xTokenName.clear();
915         xTokenData.clear();
916         
917         if (testTask.xTokensData.size() > 1){
918         
919                 xTokenData = testTask.xTokensData[1];
920                 
921         }
923         if (testTask.xTokensData.size() > 1){
924         
925                 xTokenName = testTask.xTokensDataTokens[1];
926                 
927         }
928         
929         ASSERT_EQ("Meep", xTokenData);
930         ASSERT_EQ("X-EXAMPLE1;ANIMAL=NOPE", xTokenName);
931         
932         // Get the third X-EXAMPLE1 token.
934         xTokenName.clear();
935         xTokenData.clear();
936         
937         if (testTask.xTokensData.size() > 2){
938         
939                 xTokenData = testTask.xTokensData[2];
940                 
941         }
943         if (testTask.xTokensData.size() > 2){
944         
945                 xTokenName = testTask.xTokensDataTokens[2];
946                 
947         }
948         
949         ASSERT_EQ("Meow", xTokenData);
950         ASSERT_EQ("X-EXAMPLE1;ANIMAL=CAT", xTokenName);
951         
952         // Get the first X-EXAMPLE2 token.
953         
954         xTokenName.clear();
955         xTokenData.clear();
956         
957         if (testTask.xTokensData.size() > 3){
958         
959                 xTokenData = testTask.xTokensData[3];
960                 
961         }
963         if (testTask.xTokensData.size() > 3){
964         
965                 xTokenName = testTask.xTokensDataTokens[3];
966                 
967         }
968         
969         ASSERT_EQ("Dish", xTokenData);
970         ASSERT_EQ("X-EXAMPLE2", xTokenName);
971         
972         // Get the second X-EXAMPLE2 token.
973         
974         xTokenName.clear();
975         xTokenData.clear();
976         
977         if (testTask.xTokensData.size() > 4){
978         
979                 xTokenData = testTask.xTokensData[4];
980                 
981         }
983         if (testTask.xTokensData.size() > 4){
984         
985                 xTokenName = testTask.xTokensDataTokens[4];
986                 
987         }
988         
989         ASSERT_EQ("Fork", xTokenData);
990         ASSERT_EQ("X-EXAMPLE2;OBJECT=KITCHEN", xTokenName);
991         
992         // Get the third X-EXAMPLE2 token.
993         
994         xTokenName.clear();
995         xTokenData.clear();
996         
997         if (testTask.xTokensData.size() > 5){
998         
999                 xTokenData = testTask.xTokensData[5];
1000                 
1001         }
1003         if (testTask.xTokensData.size() > 5){
1004         
1005                 xTokenName = testTask.xTokensDataTokens[5];
1006                 
1007         }
1008         
1009         ASSERT_EQ("Table", xTokenData);
1010         ASSERT_EQ("X-EXAMPLE2;OBJECT=LIVINGROOM", xTokenName);
1011         
1012         // Get the X-STATUS token.
1013         
1014         xTokenName.clear();
1015         xTokenData.clear();
1016         
1017         if (testTask.xTokensData.size() > 6){
1018         
1019                 xTokenData = testTask.xTokensData[6];
1020                 
1021         }
1023         if (testTask.xTokensData.size() > 6){
1024         
1025                 xTokenName = testTask.xTokensDataTokens[6];
1026                 
1027         }
1028         
1029         ASSERT_EQ("Idle", xTokenData);
1030         ASSERT_EQ("X-STATUS;HOLIDAY=YES", xTokenName);
1031         
1032         // Get the X-TRANSPORT token.
1033         
1034         xTokenName.clear();
1035         xTokenData.clear();
1036         
1037         if (testTask.xTokensData.size() > 7){
1038         
1039                 xTokenData = testTask.xTokensData[7];
1040                 
1041         }
1043         if (testTask.xTokensData.size() > 7){
1044         
1045                 xTokenName = testTask.xTokensDataTokens[7];
1046                 
1047         }
1048         
1049         ASSERT_EQ("Private Hire", xTokenData);
1050         ASSERT_EQ("X-TRANSPORT;PUBLIC=NO", xTokenName);
1051         
1052         // Get the X-PHANTOM-STATUS token.
1053         
1054         xTokenName.clear();
1055         xTokenData.clear();
1056         
1057         if (testTask.xTokensData.size() > 8){
1058         
1059                 xTokenData = testTask.xTokensData[8];
1060                 
1061         }
1063         if (testTask.xTokensData.size() > 8){
1064         
1065                 xTokenName = testTask.xTokensDataTokens[8];
1066                 
1067         }
1068         
1069         ASSERT_EQ("None", xTokenData);
1070         ASSERT_EQ("X-PHANTOM-STATUS;HELP=NONE", xTokenName);
1071         
1074 TEST_F(iCalendarTaskLoadTests, AlarmTests){
1076         CalendarTaskObject testTask;
1077         ASSERT_EQ(CALENDAROBJECTLOAD_OK, testTask.LoadFile("iCalendarTask-Load2.vcf"));
1078         ASSERT_EQ(CALENDAROBJECTVALID_OK, testTask.ValidBaseObject());
1079         
1080         // Tests for the first VALARM property.
1081         
1082         std::string actionData;
1083         std::string actionDataTokens;
1084         
1085         std::string triggerData;
1086         std::string triggerRelated;
1087         std::string triggerValue;
1088         std::string triggerTokens;
1089         
1090         std::string durationData;
1091         std::string durationTokens;
1092         
1093         std::string repeatData;
1094         std::string repeatTokens;
1095         
1096         std::string xTokenData;
1097         std::string xTokenName;
1098         
1099         if (testTask.calendarAlarmData.size() > 0){
1100         
1101                 actionData = testTask.calendarAlarmData[0].alarmAction;
1102                 actionDataTokens = testTask.calendarAlarmData[0].alarmActionTokens;
1103                 
1104                 triggerData = testTask.calendarAlarmData[0].triggerData;
1105                 triggerRelated = testTask.calendarAlarmData[0].triggerRelated;
1106                 triggerValue = testTask.calendarAlarmData[0].triggerValue;
1107                 triggerTokens = testTask.calendarAlarmData[0].triggerTokens;
1108                 
1109                 durationData = testTask.calendarAlarmData[0].durationData;
1110                 durationTokens = testTask.calendarAlarmData[0].durationTokens;
1111                 
1112                 repeatData = testTask.calendarAlarmData[0].repeatData;
1113                 repeatTokens = testTask.calendarAlarmData[0].repeatTokens;
1114                 
1115         }
1116         
1117         ASSERT_EQ("AUDIO", actionData);
1118         ASSERT_EQ("FUNKY=SOUNDS", actionDataTokens);
1119         
1120         ASSERT_EQ("20160220T160000Z", triggerData);
1121         ASSERT_EQ("END", triggerRelated);
1122         ASSERT_EQ("DATE-TIME", triggerValue);
1123         ASSERT_EQ("PUSH=BUTTON", triggerTokens);
1125         ASSERT_EQ("PT5H", durationData);
1126         ASSERT_EQ("FLYING=NO", durationTokens);
1128         ASSERT_EQ("PT5M", repeatData);
1129         ASSERT_EQ("NEVER=SLEEP", repeatTokens);
1130         
1131         // Tests for ATTACH. First ATTACH property.
1133         std::string attachData;
1134         std::string attachDataFormatType;
1135         std::string attachDataValue;
1136         std::string attachDataEncoding;
1137         std::string attachDataTokens;
1139         if (testTask.calendarAlarmData[0].attachList.begin() != testTask.calendarAlarmData[0].attachList.end()){
1140                 
1141                 attachData = testTask.attachList[0];
1142                 
1143         }
1144         
1145         if (testTask.calendarAlarmData[0].attachListFormatType.begin() != testTask.calendarAlarmData[0].attachListFormatType.end()){
1146                 
1147                 attachDataFormatType = testTask.attachListFormatType[0];
1148                 
1149         }
1151         ASSERT_EQ("http://www.example.com/", attachData);
1152         ASSERT_EQ("application/internet-shortcut", attachDataFormatType);
1153         
1154         // Second ATTACH property.
1155         
1156         attachData.clear();
1157         attachDataFormatType.clear();
1158         attachDataValue.clear();
1159         attachDataEncoding.clear();
1160         
1161         if (testTask.calendarAlarmData[0].attachList.size() > 1){
1162                 
1163                 attachData = testTask.calendarAlarmData[0].attachList[1];
1164                 
1165         }
1166         
1167         if (testTask.calendarAlarmData[0].attachListFormatType.size() > 1){
1168                 
1169                 attachDataFormatType = testTask.calendarAlarmData[0].attachListFormatType[1];
1170                 
1171         }
1173         ASSERT_EQ("http://www.example.com/page2.html", attachData);
1174         ASSERT_EQ("application/internet-shortcut", attachDataFormatType);
1175         
1176         // Third ATTACH property.
1178         attachData.clear();
1179         attachDataFormatType.clear();
1180         attachDataValue.clear();
1181         attachDataEncoding.clear();
1182         attachDataTokens.clear();
1183         
1184         if (testTask.calendarAlarmData[0].attachList.size() > 2){
1185                 
1186                 attachData = testTask.calendarAlarmData[0].attachList[2];
1187                 
1188         }
1189         
1190         if (testTask.calendarAlarmData[0].attachListFormatType.size() > 2){
1191                 
1192                 attachDataFormatType = testTask.calendarAlarmData[0].attachListFormatType[2];
1193                 
1194         }
1195         
1196         if (testTask.calendarAlarmData[0].attachListValue.size() > 2){
1197                 
1198                 attachDataValue = testTask.calendarAlarmData[0].attachListValue[2];
1199                 
1200         }
1201         
1202         if (testTask.calendarAlarmData[0].attachListFormatType.size() > 2){
1203                 
1204                 attachDataEncoding = testTask.calendarAlarmData[0].attachListEncoding[2];
1205                 
1206         }
1208         if (testTask.calendarAlarmData[0].attachListTokens.size() > 2){
1209                 
1210                 attachDataTokens = testTask.calendarAlarmData[0].attachListTokens[2];
1211                 
1212         }
1213         
1214         ASSERT_EQ("VGhpcyBpcyBhbiBleGFtcGxlIGZpbGU=", attachData);
1215         ASSERT_EQ("text/plain", attachDataFormatType);
1216         ASSERT_EQ("BASE64", attachDataEncoding);
1217         ASSERT_EQ("BINARY", attachDataValue);
1218         ASSERT_EQ("STUPID=EXAMPLE", attachDataTokens);
1219         
1220         // Test the first X-Token.
1221         
1222         if (testTask.calendarAlarmData[0].xTokensData.size() > 0){
1223                 
1224                 xTokenData = testTask.calendarAlarmData[0].xTokensData[0];
1225                 xTokenName = testTask.calendarAlarmData[0].xTokensDataTokens[0];
1226                 
1227         }
1228         
1229         ASSERT_EQ("Example Data 1", xTokenData);
1230         ASSERT_EQ("X-EXAMPLE1;YAY=YES", xTokenName);
1231         
1232         // Test the second X-Token.
1233         
1234         xTokenData.clear();
1235         xTokenName.clear();
1236         
1237         if (testTask.calendarAlarmData[0].xTokensData.size() > 1){
1238                 
1239                 xTokenData = testTask.calendarAlarmData[0].xTokensData[1];
1240                 xTokenName = testTask.calendarAlarmData[0].xTokensDataTokens[1];
1241                 
1242         }
1243         
1244         ASSERT_EQ("Example Data 2", xTokenData);
1245         ASSERT_EQ("X-EXAMPLE2;NOPE=YEP", xTokenName);
1246         
1247         // Test the third X-Token.
1249         xTokenData.clear();
1250         xTokenName.clear();
1251         
1252         if (testTask.calendarAlarmData[0].xTokensData.size() > 2){
1253                 
1254                 xTokenData = testTask.calendarAlarmData[0].xTokensData[2];
1255                 xTokenName = testTask.calendarAlarmData[0].xTokensDataTokens[2];
1256                 
1257         }
1258         
1259         ASSERT_EQ("Example Data 3", xTokenData);
1260         ASSERT_EQ("X-EXAMPLE3;WORLD=NO", xTokenName);
1261         
1262         // Tests for the second VALARM property.
1263         
1264         actionData.clear();
1265         actionDataTokens.clear();
1266         
1267         triggerData.clear();
1268         triggerRelated.clear();
1269         triggerValue.clear();
1270         triggerTokens.clear();
1271         
1272         durationData.clear();
1273         durationTokens.clear();
1274         
1275         repeatData.clear();
1276         repeatTokens.clear();
1277         
1278         xTokenData.clear();
1279         xTokenName.clear();
1280         
1281         string descriptionData;
1282         string descriptionAltRep;
1283         string descriptionLanguage;
1284         string descriptionTokens;
1285         
1286         if (testTask.calendarAlarmData.size() > 1){
1287                 
1288                 actionData = testTask.calendarAlarmData[1].alarmAction;
1289                 actionDataTokens = testTask.calendarAlarmData[1].alarmActionTokens;
1290                 
1291                 triggerData = testTask.calendarAlarmData[1].triggerData;
1292                 triggerRelated = testTask.calendarAlarmData[1].triggerRelated;
1293                 triggerValue = testTask.calendarAlarmData[1].triggerValue;
1294                 triggerTokens = testTask.calendarAlarmData[1].triggerTokens;
1295                 
1296                 durationData = testTask.calendarAlarmData[1].durationData;
1297                 durationTokens = testTask.calendarAlarmData[1].durationTokens;
1298                 
1299                 repeatData = testTask.calendarAlarmData[1].repeatData;
1300                 repeatTokens = testTask.calendarAlarmData[1].repeatTokens;
1301                 
1302                 descriptionData = testTask.calendarAlarmData[1].descriptionData;
1303                 descriptionAltRep = testTask.calendarAlarmData[1].descriptionAltRep;
1304                 descriptionLanguage = testTask.calendarAlarmData[1].descriptionLanguage;
1305                 descriptionTokens = testTask.calendarAlarmData[1].descriptionTokens;
1306                 
1307         }
1308         
1309         ASSERT_EQ("DISPLAY", actionData);
1310         ASSERT_EQ("FLASHING=LIGHTS", actionDataTokens);
1311         
1312         ASSERT_EQ("20160230T110000Z", triggerData);
1313         ASSERT_EQ("END", triggerRelated);
1314         ASSERT_EQ("DATE-TIME", triggerValue);
1315         ASSERT_EQ("PUSH=BUTTON", triggerTokens);
1317         ASSERT_EQ("PT7H", durationData);
1318         ASSERT_EQ("FLYING=YES", durationTokens);
1320         ASSERT_EQ("PT3M", repeatData);
1321         ASSERT_EQ("SLEEP=ALWAYS", repeatTokens);
1322         
1323         ASSERT_EQ("This is the second alarm.", descriptionData);
1324         ASSERT_EQ("null:nodata", descriptionAltRep);
1325         ASSERT_EQ("kw", descriptionLanguage);
1326         ASSERT_EQ("TERRIBLE=TOKEN", descriptionTokens);
1327         
1328         // Test the first X-Token.
1329         
1330         if (testTask.calendarAlarmData[1].xTokensData.size() > 0){
1331                 
1332                 xTokenData = testTask.calendarAlarmData[1].xTokensData[0];
1333                 xTokenName = testTask.calendarAlarmData[1].xTokensDataTokens[0];
1334                 
1335         }
1336         
1337         ASSERT_EQ("Example Data 1", xTokenData);
1338         ASSERT_EQ("X-EXAMPLE1;YAY=YES", xTokenName);
1339         
1340         // Test the second X-Token.
1341         
1342         xTokenData.clear();
1343         xTokenName.clear();
1344         
1345         if (testTask.calendarAlarmData[1].xTokensData.size() > 1){
1346                 
1347                 xTokenData = testTask.calendarAlarmData[1].xTokensData[1];
1348                 xTokenName = testTask.calendarAlarmData[1].xTokensDataTokens[1];
1349                 
1350         }
1351         
1352         ASSERT_EQ("Example Data 2", xTokenData);
1353         ASSERT_EQ("X-EXAMPLE2;NOPE=YEP", xTokenName);
1354         
1355         // Test the third X-Token.
1357         xTokenData.clear();
1358         xTokenName.clear();
1359         
1360         if (testTask.calendarAlarmData[1].xTokensData.size() > 2){
1361                 
1362                 xTokenData = testTask.calendarAlarmData[1].xTokensData[2];
1363                 xTokenName = testTask.calendarAlarmData[1].xTokensDataTokens[2];
1364                 
1365         }
1366         
1367         ASSERT_EQ("Example Data 3", xTokenData);
1368         ASSERT_EQ("X-EXAMPLE3;WORLD=NO", xTokenName);
1369         
1370         // Tests for the third VALARM property.
1371         
1372         actionData.clear();
1373         actionDataTokens.clear();
1374         
1375         triggerData.clear();
1376         triggerRelated.clear();
1377         triggerValue.clear();
1378         triggerTokens.clear();
1379         
1380         durationData.clear();
1381         durationTokens.clear();
1382         
1383         repeatData.clear();
1384         repeatTokens.clear();
1385         
1386         xTokenData.clear();
1387         xTokenName.clear();
1388         
1389         descriptionData.clear();
1390         descriptionAltRep.clear();
1391         descriptionLanguage.clear();
1392         descriptionTokens.clear();
1394         string summaryData;
1395         string summaryAltRep;
1396         string summaryLanguage;
1397         string summaryTokens;
1398         
1399         string attendeeDataMember;
1400         string attendeeDataDelegatedFrom;
1401         string attendeeDataDelegatedTo;
1402         string attendeeDataRole;
1403         string attendeeDataRSVP;
1404         string attendeeDataDirectoryEntry;
1405         string attendeeDataSentBy;
1406         string attendeeDataCommonName;
1407         string attendeeDataCalendarUserType;
1408         string attendeeDataParticipationStatus;
1409         string attendeeDataLanguage;
1410         string attendeeDataTokens;
1411         string attendeeData;
1412         
1413         attachData.clear();
1414         attachDataFormatType.clear();
1415         attachDataValue.clear();
1416         attachDataEncoding.clear();
1417         attachDataTokens.clear();
1418         
1419         if (testTask.calendarAlarmData.size() > 2){
1420                 
1421                 actionData = testTask.calendarAlarmData[2].alarmAction;
1422                 actionDataTokens = testTask.calendarAlarmData[2].alarmActionTokens;
1423                 
1424                 triggerData = testTask.calendarAlarmData[2].triggerData;
1425                 triggerRelated = testTask.calendarAlarmData[2].triggerRelated;
1426                 triggerValue = testTask.calendarAlarmData[2].triggerValue;
1427                 triggerTokens = testTask.calendarAlarmData[2].triggerTokens;
1428                 
1429                 durationData = testTask.calendarAlarmData[2].durationData;
1430                 durationTokens = testTask.calendarAlarmData[2].durationTokens;
1431                 
1432                 repeatData = testTask.calendarAlarmData[2].repeatData;
1433                 repeatTokens = testTask.calendarAlarmData[2].repeatTokens;
1434                 
1435                 descriptionData = testTask.calendarAlarmData[2].descriptionData;
1436                 descriptionAltRep = testTask.calendarAlarmData[2].descriptionAltRep;
1437                 descriptionLanguage = testTask.calendarAlarmData[2].descriptionLanguage;
1438                 descriptionTokens = testTask.calendarAlarmData[2].descriptionTokens;
1439                 
1440                 summaryData = testTask.calendarAlarmData[2].summaryData;
1441                 summaryAltRep = testTask.calendarAlarmData[2].summaryAltRep;
1442                 summaryLanguage = testTask.calendarAlarmData[2].summaryLanguage;
1443                 summaryTokens = testTask.calendarAlarmData[2].summaryTokens;
1444                 
1445         }
1446         
1447         ASSERT_EQ("EMAIL", actionData);
1448         ASSERT_EQ("FLASHING=LIGHTS", actionDataTokens);
1449         
1450         ASSERT_EQ("20160230T120000Z", triggerData);
1451         ASSERT_EQ("END", triggerRelated);
1452         ASSERT_EQ("DATE-TIME", triggerValue);
1453         ASSERT_EQ("PUSH=BUTTON", triggerTokens);
1455         ASSERT_EQ("PT7H", durationData);
1456         ASSERT_EQ("FLYING=YES", durationTokens);
1458         ASSERT_EQ("PT3M", repeatData);
1459         ASSERT_EQ("SLEEP=ALWAYS", repeatTokens);
1460         
1461         ASSERT_EQ("This is the third alarm.", descriptionData);
1462         ASSERT_EQ("null:nodata", descriptionAltRep);
1463         ASSERT_EQ("kw", descriptionLanguage);
1464         ASSERT_EQ("TERRIBLE=TOKEN", descriptionTokens);
1466         ASSERT_EQ("This is the summary of the third alarm.", summaryData);
1467         ASSERT_EQ("null:nodata", summaryAltRep);
1468         ASSERT_EQ("en", summaryLanguage);
1469         ASSERT_EQ("MEEP=MOOP", summaryTokens);
1471         // Tests for ATTENDEE. First ATTENDEE property.
1473         if (testTask.calendarAlarmData[2].attendeeList.begin() != testTask.calendarAlarmData[2].attendeeList.end()){
1474                 
1475                 attendeeData = testTask.calendarAlarmData[2].attendeeList[0];
1476                 
1477         }
1478         
1479         ASSERT_EQ("Attendee One", attendeeData);
1480         
1481         // Second ATTENDEE property.
1482         
1483         attendeeData.clear();
1484         
1485         if (testTask.calendarAlarmData[2].attendeeList.size() > 1){
1486                 
1487                 attendeeData = testTask.calendarAlarmData[2].attendeeList[1];
1488                 
1489         }
1491         if (testTask.calendarAlarmData[2].attendeeList.size() > 1){
1492                 
1493                 attendeeDataDelegatedFrom = testTask.calendarAlarmData[2].attendeeListDelegatedFrom[1];
1494                 
1495         }
1496         
1497         if (testTask.calendarAlarmData[2].attendeeList.size() > 1){
1498                 
1499                 attendeeDataDelegatedTo = testTask.calendarAlarmData[2].attendeeListDelegatedTo[1];
1500                 
1501         }
1503         if (testTask.calendarAlarmData[2].attendeeList.size() > 1){
1504                 
1505                 attendeeDataRole = testTask.calendarAlarmData[2].attendeeListRole[1];
1506                 
1507         }
1508         
1509         if (testTask.calendarAlarmData[2].attendeeList.size() > 1){
1510                 
1511                 attendeeDataRSVP = testTask.calendarAlarmData[2].attendeeListRSVP[1];
1512                 
1513         }
1514         
1515         ASSERT_EQ("Attendee Two", attendeeData);
1516         ASSERT_EQ("mailto:delegated.from@example.com", attendeeDataDelegatedFrom);
1517         ASSERT_EQ("mailto:delegated.to@example.com", attendeeDataDelegatedTo);
1518         ASSERT_EQ("CHAIR", attendeeDataRole);
1519         ASSERT_EQ("TRUE", attendeeDataRSVP);
1521         // Third ATTENDEE property.
1522         
1523         attendeeData.clear();
1524         
1525         if (testTask.calendarAlarmData[2].attendeeList.size() > 2){
1526                 
1527                 attendeeData = testTask.calendarAlarmData[2].attendeeList[2];
1528                 
1529         }
1531         if (testTask.calendarAlarmData[2].attendeeList.size() > 2){
1532                 
1533                 attendeeDataDirectoryEntry = testTask.calendarAlarmData[2].attendeeListDirectoryEntry[2];
1534                 
1535         }
1536         
1537         if (testTask.calendarAlarmData[2].attendeeList.size() > 2){
1538                 
1539                 attendeeDataSentBy = testTask.calendarAlarmData[2].attendeeListSentBy[2];
1540                 
1541         }
1543         if (testTask.calendarAlarmData[2].attendeeList.size() > 2){
1544                 
1545                 attendeeDataCommonName = testTask.calendarAlarmData[2].attendeeListCommonName[2];
1546                 
1547         }
1548         
1549         if (testTask.calendarAlarmData[2].attendeeList.size() > 2){
1550                 
1551                 attendeeDataCalendarUserType = testTask.calendarAlarmData[2].attendeeListCalendarUserType[2];
1552                 
1553         }
1555         if (testTask.calendarAlarmData[2].attendeeList.size() > 2){
1556                 
1557                 attendeeDataParticipationStatus = testTask.calendarAlarmData[2].attendeeListParticipationStatus[2];
1558                 
1559         }
1561         if (testTask.calendarAlarmData[2].attendeeList.size() > 2){
1562                 
1563                 attendeeDataLanguage = testTask.calendarAlarmData[2].attendeeListLanguage[2];
1564                 
1565         }
1566         
1567         if (testTask.calendarAlarmData[2].attendeeList.size() > 2){
1568                 
1569                 attendeeDataTokens = testTask.calendarAlarmData[2].attendeeListTokens[2];
1570                 
1571         }
1572         
1573         ASSERT_EQ("Attendee Three", attendeeData);
1574         ASSERT_EQ("null:nodata", attendeeDataDirectoryEntry);
1575         ASSERT_EQ("mailto:sent.by@example.com", attendeeDataSentBy);
1576         ASSERT_EQ("Attendee The Third", attendeeDataCommonName);
1577         ASSERT_EQ("INDIVIDUAL", attendeeDataCalendarUserType);
1578         ASSERT_EQ("ACCEPTED", attendeeDataParticipationStatus);
1579         ASSERT_EQ("kw", attendeeDataLanguage);
1580         ASSERT_EQ("EXAMPLE=DATA", attendeeDataTokens);
1582         // Tests for ATTACH. First ATTACH property.
1584         if (testTask.calendarAlarmData[2].attachList.begin() != testTask.calendarAlarmData[2].attachList.end()){
1585                 
1586                 attachData = testTask.calendarAlarmData[2].attachList[0];
1587                 
1588         }
1589         
1590         if (testTask.calendarAlarmData[2].attachListFormatType.begin() != testTask.calendarAlarmData[2].attachListFormatType.end()){
1591                 
1592                 attachDataFormatType = testTask.calendarAlarmData[2].attachListFormatType[0];
1593                 
1594         }
1596         ASSERT_EQ("http://www.example.com/", attachData);
1597         ASSERT_EQ("application/internet-shortcut", attachDataFormatType);
1598         
1599         // Second ATTACH property.
1600         
1601         attachData.clear();
1602         attachDataFormatType.clear();
1603         attachDataValue.clear();
1604         attachDataEncoding.clear();
1605         
1606         if (testTask.calendarAlarmData[2].attachList.size() > 1){
1607                 
1608                 attachData = testTask.calendarAlarmData[2].attachList[1];
1609                 
1610         }
1611         
1612         if (testTask.calendarAlarmData[2].attachListFormatType.size() > 1){
1613                 
1614                 attachDataFormatType = testTask.calendarAlarmData[2].attachListFormatType[1];
1615                 
1616         }
1618         ASSERT_EQ("http://www.example.com/page2.html", attachData);
1619         ASSERT_EQ("application/internet-shortcut", attachDataFormatType);
1620         
1621         // Third ATTACH property.
1623         attachData.clear();
1624         attachDataFormatType.clear();
1625         attachDataValue.clear();
1626         attachDataEncoding.clear();
1627         attachDataTokens.clear();
1628         
1629         if (testTask.calendarAlarmData[2].attachList.size() > 2){
1630                 
1631                 attachData = testTask.calendarAlarmData[2].attachList[2];
1632                 
1633         }
1634         
1635         if (testTask.calendarAlarmData[2].attachListFormatType.size() > 2){
1636                 
1637                 attachDataFormatType = testTask.calendarAlarmData[2].attachListFormatType[2];
1638                 
1639         }
1640         
1641         if (testTask.calendarAlarmData[2].attachListValue.size() > 2){
1642                 
1643                 attachDataValue = testTask.calendarAlarmData[2].attachListValue[2];
1644                 
1645         }
1646         
1647         if (testTask.calendarAlarmData[2].attachListFormatType.size() > 2){
1648                 
1649                 attachDataEncoding = testTask.calendarAlarmData[2].attachListEncoding[2];
1650                 
1651         }
1653         if (testTask.calendarAlarmData[2].attachListTokens.size() > 2){
1654                 
1655                 attachDataTokens = testTask.calendarAlarmData[2].attachListTokens[2];
1656                 
1657         }
1658         
1659         ASSERT_EQ("VGhpcyBpcyBhbiBleGFtcGxlIGZpbGU=", attachData);
1660         ASSERT_EQ("text/plain", attachDataFormatType);
1661         ASSERT_EQ("BASE64", attachDataEncoding);
1662         ASSERT_EQ("BINARY", attachDataValue);
1663         ASSERT_EQ("STUPID=EXAMPLE", attachDataTokens);
1664         
1665         // Test the first X-Token.
1666         
1667         if (testTask.calendarAlarmData[2].xTokensData.size() > 0){
1668                 
1669                 xTokenData = testTask.calendarAlarmData[2].xTokensData[0];
1670                 xTokenName = testTask.calendarAlarmData[2].xTokensDataTokens[0];
1671                 
1672         }
1673         
1674         ASSERT_EQ("Example Data 1", xTokenData);
1675         ASSERT_EQ("X-EXAMPLE1;YAY=YES", xTokenName);
1676         
1677         // Test the second X-Token.
1678         
1679         xTokenData.clear();
1680         xTokenName.clear();
1681         
1682         if (testTask.calendarAlarmData[2].xTokensData.size() > 1){
1683                 
1684                 xTokenData = testTask.calendarAlarmData[2].xTokensData[1];
1685                 xTokenName = testTask.calendarAlarmData[2].xTokensDataTokens[1];
1686                 
1687         }
1688         
1689         ASSERT_EQ("Example Data 2", xTokenData);
1690         ASSERT_EQ("X-EXAMPLE2;NOPE=YEP", xTokenName);
1691         
1692         // Test the third X-Token.
1694         xTokenData.clear();
1695         xTokenName.clear();
1696         
1697         if (testTask.calendarAlarmData[2].xTokensData.size() > 2){
1698                 
1699                 xTokenData = testTask.calendarAlarmData[2].xTokensData[2];
1700                 xTokenName = testTask.calendarAlarmData[2].xTokensDataTokens[2];
1701                 
1702         }
1703         
1704         ASSERT_EQ("Example Data 3", xTokenData);
1705         ASSERT_EQ("X-EXAMPLE3;WORLD=NO", xTokenName);
1706         
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