Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
Added source code, header and unit tests to the PHOTO vCard property for ContactDataO...
[xestiaab/.git] / source / tests / xestiaab_contactload.h
1 // xestiaab_contactload.h - Xestia Address Book Contact Load Unit Tests.
2 //
3 // (c) 2012-2015 Xestia Software Development.
4 //
5 // This file is part of Xestia Address Book.
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 Address Book. If not, see <http://www.gnu.org/licenses/>
19 #include <gtest/gtest.h>
20 #include "../contacteditor/ContactDataObject.h"
22 TEST(ContactLoad, ContactLoadTests){
24         ContactDataObject TestFile;
26         // Check that the file given is not missing.
27         
28         ASSERT_EQ(CONTACTLOAD_FILEMISSING, TestFile.LoadFile("MissingFile.vcf"));
29         
30         // Check that the file given does not have an error when attempting to
31         // open it. 
32         
33         ASSERT_EQ(CONTACTLOAD_FILEERROR, TestFile.LoadFile("InvalidPermissions.vcf"));
34         
35         // Check that the file is a valid vCard 4.0 file.
36         
37         ASSERT_EQ(CONTACTLOAD_FILEINVALIDFORMAT, TestFile.LoadFile("LoadCheck-Load1-v3.vcf"));
39         // Check that the vCard 4.0 file meets the base specification.
40         
41         ASSERT_EQ(CONTACTLOAD_FILEBASESPECFAIL, TestFile.LoadFile("LoadCheck-Load3.vcf"));
43         // Check that the vCard 4.0 file loads OK.
45         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
46         
47         // Check that the kind status has been set. (KIND).
48         
49         ASSERT_NE(CONTACTKIND_NONE, TestFile.ContactKind);
50         ASSERT_EQ(CONTACTKIND_INDIVIDUAL, TestFile.ContactKind);
51         
52         // Check that the groups have been read (MEMBER).
53         
54         std::map<int,wxString>::iterator TestFileIter;
55         std::map<int,int>::iterator TestFileIntIter;
56         
57         TestFileIter = TestFile.GroupsList.find(0);
58         
59         ASSERT_NE(TestFile.GroupsList.end(), TestFileIter);
60         ASSERT_EQ("7a2af44d-6431-4797-a55f-d86d56304fda", TestFileIter->second);
62         // Check the ALTID parameter.
64         TestFileIter = TestFile.GroupsListAltID.find(0);
65         ASSERT_NE(TestFile.GroupsListAltID.end(), TestFileIter);
66         ASSERT_EQ("35", TestFileIter->second);
68         // Check the PID parameter.
69         
70         TestFileIter = TestFile.GroupsListPID.find(0);
71         ASSERT_NE(TestFile.GroupsListPID.end(), TestFileIter);
72         ASSERT_EQ("40", TestFileIter->second);
73         
74         // Check the PREF parameter.
75         
76         TestFileIntIter = TestFile.GroupsListPref.find(0);
77         ASSERT_NE(TestFile.GroupsListPref.end(), TestFileIntIter);
78         ASSERT_EQ(45, TestFileIntIter->second);
79         
80         // Check the MEDIATYPE parameter.
81         
82         TestFileIter = TestFile.GroupsListMediaType.find(0);
83         ASSERT_NE(TestFile.GroupsListMediaType.end(), TestFileIter);
84         ASSERT_EQ("text/plain", TestFileIter->second);
85         
86         // Check the extra tokens parameter.
87         
88         TestFileIter = TestFile.GroupsListTokens.find(0);
89         ASSERT_NE(TestFile.GroupsListTokens.end(), TestFileIter);
90         ASSERT_EQ("EXAMPLE=Meep", TestFileIter->second);
91         
92         // Check that the formatted name has been read (FN).
93         
94         TestFileIter = TestFile.FullNamesList.find(0);
95         ASSERT_NE(TestFile.FullNamesList.end(), TestFileIter);
96         ASSERT_EQ("Test Contact", TestFileIter->second);
97         
98         // Check the TYPE parameter.
100         TestFileIter = TestFile.FullNamesListType.find(0);
101         ASSERT_NE(TestFile.FullNamesListType.end(), TestFileIter);
102         ASSERT_EQ("work", TestFileIter->second);
103         
104         // Check the LANGUAGE parameter.
105         
106         TestFileIter = TestFile.FullNamesListLanguage.find(0);
107         ASSERT_NE(TestFile.FullNamesListLanguage.end(), TestFileIter);
108         ASSERT_EQ("kw", TestFileIter->second);
109         
110         // Check the ALTID parameter.
111         
112         TestFileIter = TestFile.FullNamesListAltID.find(0);
113         ASSERT_NE(TestFile.FullNamesListAltID.end(), TestFileIter);
114         ASSERT_EQ("500", TestFileIter->second);
116         // Check the PID parameter.
118         TestFileIter = TestFile.FullNamesListPID.find(0);
119         ASSERT_NE(TestFile.FullNamesListPID.end(), TestFileIter);
120         ASSERT_EQ("40", TestFileIter->second);
121         
122         // Check the PREF parameter.
123         
124         TestFileIntIter = TestFile.FullNamesListPref.find(0);
125         ASSERT_NE(TestFile.FullNamesListPref.end(), TestFileIntIter);
126         ASSERT_EQ(45, TestFileIntIter->second);
127         
128         // Check for the extra tokens parameter.
129         
130         TestFileIter = TestFile.FullNamesListTokens.find(0);
131         ASSERT_NE(TestFile.FullNamesListTokens.end(), TestFileIter);
132         ASSERT_EQ("EXAMPLE=Baaa", TestFileIter->second);
133         
134         // Check that the name has been read (N).
135         
136         ASSERT_EQ("Contact", TestFile.NameSurname);
137         ASSERT_EQ("Test", TestFile.NameForename);
138         ASSERT_EQ("Example", TestFile.NameOtherNames);
139         ASSERT_EQ("Robot", TestFile.NameTitle);
140         ASSERT_EQ("LOONY", TestFile.NameSuffix);
141         
142         // Check the ALTID parameter.
143         
144         ASSERT_EQ("3", TestFile.NameAltID);
145         
146         // Check the LANGUAGE parameter. 
147         
148         ASSERT_EQ("kw", TestFile.NameLanguage);
149         
150         // Check the SORT-AS parameter.
151          
152         ASSERT_EQ("Contact,Test", TestFile.NameDisplayAs);
154         // Check the extra tokens parameter.
155         
156         ASSERT_EQ("TEST=Yes", TestFile.NameTokens);
160 TEST(ContactLoad, NicknameTests){
162         ContactDataObject TestFile;
164         // Check that the vCard 4.0 file loads OK.
166         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
168         std::map<int,wxString>::iterator TestFileIter;
169         std::map<int,int>::iterator TestFileIntIter;
171         // Check that the nickname has been read (NICKNAME). General.
172         
173         TestFileIter = TestFile.GeneralNicknamesList.find(0);
174         ASSERT_NE(TestFile.GeneralNicknamesList.end(), TestFileIter);   
175         ASSERT_EQ("Tester", TestFileIter->second);
176         
177         // Check the ALTID parameter.
178         
179         TestFileIter = TestFile.GeneralNicknamesListAltID.find(0);
180         ASSERT_NE(TestFile.GeneralNicknamesListAltID.end(), TestFileIter);
181         ASSERT_EQ("35", TestFileIter->second);
182         
183         // Check the PID parameter.
184         
185         TestFileIter = TestFile.GeneralNicknamesListPID.find(0);
186         ASSERT_NE(TestFile.GeneralNicknamesListPID.end(), TestFileIter);
187         ASSERT_EQ("50", TestFileIter->second);
188         
189         // Check the PREF parameter.
191         TestFileIntIter = TestFile.GeneralNicknamesListPref.find(0);
192         ASSERT_NE(TestFile.GeneralNicknamesListPref.end(), TestFileIntIter);
193         ASSERT_EQ(40, TestFileIntIter->second);
195         // Check the LANGUAGE parameter.
197         TestFileIter = TestFile.GeneralNicknamesListLanguage.find(0);
198         ASSERT_NE(TestFile.GeneralNicknamesListLanguage.end(), TestFileIter);
199         ASSERT_EQ("kw", TestFileIter->second);
200         
201         // Check the extra tokens parameter.
202         
203         TestFileIter = TestFile.GeneralNicknamesListTokens.find(0);
204         ASSERT_NE(TestFile.GeneralNicknamesListTokens.end(), TestFileIter);
205         ASSERT_EQ("YAY=Nope;Beep=Boop", TestFileIter->second);
206         
207         // Repeat for the home type.
208         
209         TestFileIter = TestFile.HomeNicknamesList.find(1);
210         ASSERT_NE(TestFile.HomeNicknamesList.end(), TestFileIter);      
211         ASSERT_EQ("Testy", TestFileIter->second);
212         
213         // Check the ALTID parameter.
214         
215         TestFileIter = TestFile.HomeNicknamesListAltID.find(1);
216         ASSERT_NE(TestFile.HomeNicknamesListAltID.end(), TestFileIter);
217         ASSERT_EQ("17", TestFileIter->second);
218         
219         // Check the PID parameter.
220         
221         TestFileIter = TestFile.HomeNicknamesListPID.find(1);
222         ASSERT_NE(TestFile.HomeNicknamesListPID.end(), TestFileIter);
223         ASSERT_EQ("39", TestFileIter->second);
224         
225         // Check the PREF parameter.
227         TestFileIntIter = TestFile.HomeNicknamesListPref.find(1);
228         ASSERT_NE(TestFile.HomeNicknamesListPref.end(), TestFileIntIter);
229         ASSERT_EQ(78, TestFileIntIter->second);
231         // Check the LANGUAGE parameter.
233         TestFileIter = TestFile.HomeNicknamesListLanguage.find(1);
234         ASSERT_NE(TestFile.HomeNicknamesListLanguage.end(), TestFileIter);
235         ASSERT_EQ("en", TestFileIter->second);
236         
237         // Check the extra tokens parameter.
238         
239         TestFileIter = TestFile.HomeNicknamesListTokens.find(1);
240         ASSERT_NE(TestFile.HomeNicknamesListTokens.end(), TestFileIter);
241         ASSERT_EQ("YAY=Yep;Beep=Boop", TestFileIter->second);
242         
243         // Repeat for the work type.
244         
245         TestFileIter = TestFile.BusinessNicknamesList.find(2);
246         ASSERT_NE(TestFile.BusinessNicknamesList.end(), TestFileIter);  
247         ASSERT_EQ("The Testing One", TestFileIter->second);
248         
249         // Check the ALTID parameter.
250         
251         TestFileIter = TestFile.BusinessNicknamesListAltID.find(2);
252         ASSERT_NE(TestFile.BusinessNicknamesListAltID.end(), TestFileIter);
253         ASSERT_EQ("99", TestFileIter->second);
254         
255         // Check the PID parameter.
256         
257         TestFileIter = TestFile.BusinessNicknamesListPID.find(2);
258         ASSERT_NE(TestFile.BusinessNicknamesListPID.end(), TestFileIter);
259         ASSERT_EQ("10", TestFileIter->second);
260         
261         // Check the PREF parameter.
263         TestFileIntIter = TestFile.BusinessNicknamesListPref.find(2);
264         ASSERT_NE(TestFile.BusinessNicknamesListPref.end(), TestFileIntIter);
265         ASSERT_EQ(1, TestFileIntIter->second);
267         // Check the LANGUAGE parameter.
269         TestFileIter = TestFile.BusinessNicknamesListLanguage.find(2);
270         ASSERT_NE(TestFile.BusinessNicknamesListLanguage.end(), TestFileIter);
271         ASSERT_EQ("en-GB", TestFileIter->second);
272         
273         // Check the extra tokens parameter.
274         
275         TestFileIter = TestFile.BusinessNicknamesListTokens.find(2);
276         ASSERT_NE(TestFile.BusinessNicknamesListTokens.end(), TestFileIter);
277         ASSERT_EQ("YAY=Maybe;Boop=Boing", TestFileIter->second);
281 TEST(ContactLoad, GenderTests){
283         // Check that the gender has been read.
285         ContactDataObject TestFile;
287         // Check that the vCard 4.0 file loads OK.
289         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
291         std::map<int,wxString>::iterator TestFileIter;
292         std::map<int,int>::iterator TestFileIntIter;
293         
294         ASSERT_NE("", TestFile.Gender);
295         ASSERT_EQ("F", TestFile.Gender);
296         ASSERT_EQ("Example Text", TestFile.GenderDetails);
297         ASSERT_EQ("BEEP=Boop", TestFile.GenderTokens);
301 TEST(ContactLoad, BirthdayTests){
303         // Check that the birthday has been read.
305         ContactDataObject TestFile;
307         // Check that the vCard 4.0 file loads OK.
309         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
311         std::map<int,wxString>::iterator TestFileIter;
312         std::map<int,int>::iterator TestFileIntIter;
313         
314         ASSERT_NE("", TestFile.Birthday);
315         ASSERT_EQ("20040101", TestFile.Birthday);
316         
317         // Check the ALTID parameter.
318         
319         ASSERT_EQ("35", TestFile.BirthdayAltID);
320         
321         // Check the CALSCALE parameter.
322         
323         ASSERT_EQ("georgian", TestFile.BirthdayCalScale);
324         
325         // Check the extra tokens parameter.
327         ASSERT_EQ("HAPPY=Days", TestFile.BirthdayTokens);
328         
329         // Check the VALUE parameter. (Note have to use a different file
330         // due to the *1 rule in RFC6350.
331         
332         ContactDataObject TestFileValue;
333         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4-BDayValue.vcf"));
334         
335         ASSERT_EQ("Circa 2000s", TestFile.Birthday);
336         
339 TEST(ContactLoad, AnniversaryTests){
341         // Check that the anniversary has been read.
343         ContactDataObject TestFile;
345         // Check that the vCard 4.0 file loads OK.
347         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
349         std::map<int,wxString>::iterator TestFileIter;
350         std::map<int,int>::iterator TestFileIntIter;
351         
352         ASSERT_NE("", TestFile.Anniversary);
353         ASSERT_EQ("20200516", TestFile.Anniversary);
354         
355         // Check the ALTID parameter.
356         
357         ASSERT_EQ("70", TestFile.AnniversaryAltID);
358         
359         // Check the CALSCALE parameter.
360         
361         ASSERT_EQ("georgian", TestFile.AnniversaryCalScale);
362         
363         // Check the extra tokens parameter.
365         ASSERT_EQ("WONDERFUL=Day", TestFile.AnniversaryTokens);
366         
367         // Check the VALUE parameter. (Note have to use a different file
368         // due to the *1 rule in RFC6350.
369         
370         ContactDataObject TestFileValue;
371         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4-BDayValue.vcf"));
372         
373         ASSERT_EQ("Circa 2020s", TestFile.Anniversary); 
377 TEST(ContactLoad, TimeZoneTests){
379         ContactDataObject TestFile;
381         // Check that the vCard 4.0 file loads OK.
383         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
385         std::map<int,wxString>::iterator TestFileIter;
386         std::map<int,int>::iterator TestFileIntIter;
388         // Check that the timezone has been read (TZ). General.
389         
390         TestFileIter = TestFile.GeneralTZList.find(0);
391         ASSERT_NE(TestFile.GeneralTZList.end(), TestFileIter);  
392         ASSERT_EQ("Europe/Truro", TestFileIter->second);
394         // Check the ALTID parameter.
395         
396         TestFileIter = TestFile.GeneralTZListAltID.find(0);
397         ASSERT_NE(TestFile.GeneralTZListAltID.end(), TestFileIter);
398         ASSERT_EQ("35", TestFileIter->second);
399         
400         // Check the PID parameter.
401         
402         TestFileIter = TestFile.GeneralTZListPID.find(0);
403         ASSERT_NE(TestFile.GeneralTZListPID.end(), TestFileIter);
404         ASSERT_EQ("60", TestFileIter->second);
405         
406         // Check the PREF parameter.
408         TestFileIntIter = TestFile.GeneralTZListPref.find(0);
409         ASSERT_NE(TestFile.GeneralTZListPref.end(), TestFileIntIter);
410         ASSERT_EQ(20, TestFileIntIter->second);
412         // Check the LANGUAGE parameter.
414         TestFileIter = TestFile.GeneralTZListMediatype.find(0);
415         ASSERT_NE(TestFile.GeneralTZListMediatype.end(), TestFileIter);
416         ASSERT_EQ("text/plain", TestFileIter->second);
417         
418         // Check the extra tokens parameter.
419         
420         TestFileIter = TestFile.GeneralTZListTokens.find(0);
421         ASSERT_NE(TestFile.GeneralTZListTokens.end(), TestFileIter);
422         ASSERT_EQ("WHATS=This;A=Potato", TestFileIter->second);
423         
424         // Check that the timezone has been read (TZ). Home.
425         
426         TestFileIter = TestFile.HomeTZList.find(1);
427         ASSERT_NE(TestFile.HomeTZList.end(), TestFileIter);     
428         ASSERT_EQ("Europe/Penzance", TestFileIter->second);
430         // Check the ALTID parameter.
431         
432         TestFileIter = TestFile.HomeTZListAltID.find(1);
433         ASSERT_NE(TestFile.HomeTZListAltID.end(), TestFileIter);
434         ASSERT_EQ("15", TestFileIter->second);
435         
436         // Check the PID parameter.
437         
438         TestFileIter = TestFile.HomeTZListPID.find(1);
439         ASSERT_NE(TestFile.HomeTZListPID.end(), TestFileIter);
440         ASSERT_EQ("20", TestFileIter->second);
441         
442         // Check the PREF parameter.
444         TestFileIntIter = TestFile.HomeTZListPref.find(1);
445         ASSERT_NE(TestFile.HomeTZListPref.end(), TestFileIntIter);
446         ASSERT_EQ(40, TestFileIntIter->second);
448         // Check the LANGUAGE parameter.
450         TestFileIter = TestFile.HomeTZListMediatype.find(1);
451         ASSERT_NE(TestFile.HomeTZListMediatype.end(), TestFileIter);
452         ASSERT_EQ("text/plain", TestFileIter->second);
453         
454         // Check the extra tokens parameter.
455         
456         TestFileIter = TestFile.HomeTZListTokens.find(1);
457         ASSERT_NE(TestFile.HomeTZListTokens.end(), TestFileIter);
458         ASSERT_EQ("MAYBE=not", TestFileIter->second);
459         
460         // Check that the timezone has been read (TZ). Business.
461         
462         TestFileIter = TestFile.BusinessTZList.find(2);
463         ASSERT_NE(TestFile.BusinessTZList.end(), TestFileIter);
464         ASSERT_EQ("Europe/St Austell", TestFileIter->second);
466         // Check the ALTID parameter.
467         
468         TestFileIter = TestFile.BusinessTZListAltID.find(2);
469         ASSERT_NE(TestFile.BusinessTZListAltID.end(), TestFileIter);
470         ASSERT_EQ("45", TestFileIter->second);
471         
472         // Check the PID parameter.
473         
474         TestFileIter = TestFile.BusinessTZListPID.find(2);
475         ASSERT_NE(TestFile.BusinessTZListPID.end(), TestFileIter);
476         ASSERT_EQ("70", TestFileIter->second);
477         
478         // Check the PREF parameter.
480         TestFileIntIter = TestFile.BusinessTZListPref.find(2);
481         ASSERT_NE(TestFile.BusinessTZListPref.end(), TestFileIntIter);
482         ASSERT_EQ(80, TestFileIntIter->second);
484         // Check the LANGUAGE parameter.
486         TestFileIter = TestFile.BusinessTZListMediatype.find(2);
487         ASSERT_NE(TestFile.BusinessTZListMediatype.end(), TestFileIter);
488         ASSERT_EQ("text/plain", TestFileIter->second);
489         
490         // Check the extra tokens parameter.
491         
492         TestFileIter = TestFile.BusinessTZListTokens.find(2);
493         ASSERT_NE(TestFile.BusinessTZListTokens.end(), TestFileIter);
494         ASSERT_EQ("MAYBE=yes", TestFileIter->second);
495         
498 TEST(ContactLoad, AddressTests){
500         ContactDataObject TestFile;
502         // Check that the vCard 4.0 file loads OK.
504         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
506         std::map<int,wxString>::iterator TestFileIter;
507         std::map<int,int>::iterator TestFileIntIter;
509         // Start with the general address.
511         // Check the address street section.
513         TestFileIter = TestFile.GeneralAddressList.find(0);
514         ASSERT_NE(TestFile.GeneralAddressList.end(), TestFileIter);
515         ASSERT_EQ("1 Lovely Lane", TestFileIter->second);
517         // Check the address town section.
519         TestFileIter = TestFile.GeneralAddressListTown.find(0);
520         ASSERT_NE(TestFile.GeneralAddressListTown.end(), TestFileIter);
521         ASSERT_EQ("Rodney", TestFileIter->second);
522         
523         // Check the address county section.
525         TestFileIter = TestFile.GeneralAddressListCounty.find(0);
526         ASSERT_NE(TestFile.GeneralAddressListCounty.end(), TestFileIter);
527         ASSERT_EQ("Cornwall", TestFileIter->second);
529         // Check the address post code section.
531         TestFileIter = TestFile.GeneralAddressListPostCode.find(0);
532         ASSERT_NE(TestFile.GeneralAddressListPostCode.end(), TestFileIter);
533         ASSERT_EQ("PL99 1AA", TestFileIter->second);
535         // Check the address country section.
537         TestFileIter = TestFile.GeneralAddressListCountry.find(0);
538         ASSERT_NE(TestFile.GeneralAddressListCountry.end(), TestFileIter);
539         ASSERT_EQ("United Kingdom", TestFileIter->second);
540         
541         // Check the LABEL section.
543         TestFileIter = TestFile.GeneralAddressListLabel.find(0);
544         ASSERT_NE(TestFile.GeneralAddressListLabel.end(), TestFileIter);
545         ASSERT_EQ("\"1 Lovely Lane\nRodney\nCornwall\nPL99 1AA\nCornwall\nUnited Kingdom\"", TestFileIter->second);
547         // Check the LANGUAGE section.
548         
549         TestFileIter = TestFile.GeneralAddressListLang.find(0);
550         ASSERT_NE(TestFile.GeneralAddressListLang.end(), TestFileIter);
551         ASSERT_EQ("kw", TestFileIter->second);
552         
553         // Check the ALTID section.
554         
555         TestFileIter = TestFile.GeneralAddressListAltID.find(0);
556         ASSERT_NE(TestFile.GeneralAddressListAltID.end(), TestFileIter);
557         ASSERT_EQ("15", TestFileIter->second);
558         
559         // Check the PID section.
560         
561         TestFileIter = TestFile.GeneralAddressListPID.find(0);
562         ASSERT_NE(TestFile.GeneralAddressListPID.end(), TestFileIter);
563         ASSERT_EQ("81", TestFileIter->second);
564         
565         // Check the GEO section.
566         
567         TestFileIter = TestFile.GeneralAddressListGeo.find(0);
568         ASSERT_NE(TestFile.GeneralAddressListGeo.end(), TestFileIter);
569         ASSERT_EQ("\"geo:1.0, 1.0\"", TestFileIter->second);
571         // Check the TZ section.
572         
573         TestFileIter = TestFile.GeneralAddressListTimezone.find(0);
574         ASSERT_NE(TestFile.GeneralAddressListTimezone.end(), TestFileIter);
575         ASSERT_EQ("Europe/Truro", TestFileIter->second);
576         
577         // Check the MEDIATYPE section.
578         
579         TestFileIter = TestFile.GeneralAddressListMediatype.find(0);
580         ASSERT_NE(TestFile.GeneralAddressListMediatype.end(), TestFileIter);
581         ASSERT_EQ("text/plain", TestFileIter->second);
582         
583         // Check the PREF section.
584         
585         TestFileIntIter = TestFile.GeneralAddressListPref.find(0);
586         ASSERT_NE(TestFile.GeneralAddressListPref.end(), TestFileIntIter);
587         ASSERT_EQ(98, TestFileIntIter->second);
588         
589         // Check the extra tokens.
590         
591         TestFileIter = TestFile.GeneralAddressListTokens.find(0);
592         ASSERT_NE(TestFile.GeneralAddressListTokens.end(), TestFileIter);
593         ASSERT_EQ("MAKES=Moo;ANIMAL=Cow", TestFileIter->second);
594         
595         // Process the home address
596         
597         // Check the address street section.
599         TestFileIter = TestFile.HomeAddressList.find(1);
600         ASSERT_NE(TestFile.HomeAddressList.end(), TestFileIter);
601         ASSERT_EQ("3 Working Plaice", TestFileIter->second);
603         // Check the address town section.
605         TestFileIter = TestFile.HomeAddressListTown.find(1);
606         ASSERT_NE(TestFile.HomeAddressListTown.end(), TestFileIter);
607         ASSERT_EQ("Roger", TestFileIter->second);
608         
609         // Check the address county section.
611         TestFileIter = TestFile.HomeAddressListCounty.find(1);
612         ASSERT_NE(TestFile.HomeAddressListCounty.end(), TestFileIter);
613         ASSERT_EQ("Cornwall", TestFileIter->second);
615         // Check the address post code section.
617         TestFileIter = TestFile.HomeAddressListPostCode.find(1);
618         ASSERT_NE(TestFile.HomeAddressListPostCode.end(), TestFileIter);
619         ASSERT_EQ("PL75 4ZZ", TestFileIter->second);
621         // Check the address country section.
623         TestFileIter = TestFile.HomeAddressListCountry.find(1);
624         ASSERT_NE(TestFile.HomeAddressListCountry.end(), TestFileIter);
625         ASSERT_EQ("United Kingdom", TestFileIter->second);
626         
627         // Check the LABEL section.
629         TestFileIter = TestFile.HomeAddressListLabel.find(1);
630         ASSERT_NE(TestFile.HomeAddressListLabel.end(), TestFileIter);
631         ASSERT_EQ("\"3 Working Plaice\nRoger\nCornwall\nPL75 4ZZ\nCornwall\nUnited Kingdom\"", TestFileIter->second);
633         // Check the LANGUAGE section.
634         
635         TestFileIter = TestFile.HomeAddressListLang.find(1);
636         ASSERT_NE(TestFile.HomeAddressListLang.end(), TestFileIter);
637         ASSERT_EQ("en", TestFileIter->second);
638         
639         // Check the ALTID section.
640         
641         TestFileIter = TestFile.HomeAddressListAltID.find(1);
642         ASSERT_NE(TestFile.HomeAddressListAltID.end(), TestFileIter);
643         ASSERT_EQ("40", TestFileIter->second);
644         
645         // Check the PID section.
646         
647         TestFileIter = TestFile.HomeAddressListPID.find(1);
648         ASSERT_NE(TestFile.HomeAddressListPID.end(), TestFileIter);
649         ASSERT_EQ("13", TestFileIter->second);
650         
651         // Check the GEO section.
652         
653         TestFileIter = TestFile.HomeAddressListGeo.find(1);
654         ASSERT_NE(TestFile.HomeAddressListGeo.end(), TestFileIter);
655         ASSERT_EQ("\"geo:4.0, 4.0\"", TestFileIter->second);
657         // Check the TZ section.
658         
659         TestFileIter = TestFile.HomeAddressListTimezone.find(1);
660         ASSERT_NE(TestFile.HomeAddressListTimezone.end(), TestFileIter);
661         ASSERT_EQ("Europe/St Ives", TestFileIter->second);
662         
663         // Check the MEDIATYPE section.
664         
665         TestFileIter = TestFile.HomeAddressListMediatype.find(1);
666         ASSERT_NE(TestFile.HomeAddressListMediatype.end(), TestFileIter);
667         ASSERT_EQ("text/plain", TestFileIter->second);
668         
669         // Check the PREF section.
670         
671         TestFileIntIter = TestFile.HomeAddressListPref.find(1);
672         ASSERT_NE(TestFile.HomeAddressListPref.end(), TestFileIntIter);
673         ASSERT_EQ(10, TestFileIntIter->second);
674         
675         // Check the extra tokens.
676         
677         TestFileIter = TestFile.HomeAddressListTokens.find(1);
678         ASSERT_NE(TestFile.HomeAddressListTokens.end(), TestFileIter);
679         ASSERT_EQ("TOAST=Butter", TestFileIter->second);
681         // Process the business address.
682         
683         // Check the address street section.
685         TestFileIter = TestFile.BusinessAddressList.find(2);
686         ASSERT_NE(TestFile.BusinessAddressList.end(), TestFileIter);
687         ASSERT_EQ("7 Flyby Drive", TestFileIter->second);
689         // Check the address town section.
691         TestFileIter = TestFile.BusinessAddressListTown.find(2);
692         ASSERT_NE(TestFile.BusinessAddressListTown.end(), TestFileIter);
693         ASSERT_EQ("Elaine", TestFileIter->second);
695         // Check the address county section.
697         TestFileIter = TestFile.BusinessAddressListCounty.find(2);
698         ASSERT_NE(TestFile.BusinessAddressListCounty.end(), TestFileIter);
699         ASSERT_EQ("Cornwall", TestFileIter->second);
701         // Check the address post code section.
703         TestFileIter = TestFile.BusinessAddressListPostCode.find(2);
704         ASSERT_NE(TestFile.BusinessAddressListPostCode.end(), TestFileIter);
705         ASSERT_EQ("PL84 9YE", TestFileIter->second);
707         // Check the address country section.
709         TestFileIter = TestFile.BusinessAddressListCountry.find(2);
710         ASSERT_NE(TestFile.BusinessAddressListCountry.end(), TestFileIter);
711         ASSERT_EQ("United Kingdom", TestFileIter->second);
712         
713         // Check the LABEL section.
715         TestFileIter = TestFile.BusinessAddressListLabel.find(2);
716         ASSERT_NE(TestFile.BusinessAddressListLabel.end(), TestFileIter);
717         ASSERT_EQ("\"7 Flyby Drive\nElaine\nCornwall\nPL84 9YE\nCornwall\nUnited Kingdom\"", TestFileIter->second);
719         // Check the LANGUAGE section.
720         
721         TestFileIter = TestFile.BusinessAddressListLang.find(2);
722         ASSERT_NE(TestFile.BusinessAddressListLang.end(), TestFileIter);
723         ASSERT_EQ("en-GB", TestFileIter->second);
724         
725         // Check the ALTID section.
726         
727         TestFileIter = TestFile.BusinessAddressListAltID.find(2);
728         ASSERT_NE(TestFile.BusinessAddressListAltID.end(), TestFileIter);
729         ASSERT_EQ("45", TestFileIter->second);
730         
731         // Check the PID section.
732         
733         TestFileIter = TestFile.BusinessAddressListPID.find(2);
734         ASSERT_NE(TestFile.BusinessAddressListPID.end(), TestFileIter);
735         ASSERT_EQ("28", TestFileIter->second);
736         
737         // Check the GEO section.
738         
739         TestFileIter = TestFile.BusinessAddressListGeo.find(2);
740         ASSERT_NE(TestFile.BusinessAddressListGeo.end(), TestFileIter);
741         ASSERT_EQ("\"geo:7.0, 7.0\"", TestFileIter->second);
743         // Check the TZ section.
744         
745         TestFileIter = TestFile.BusinessAddressListTimezone.find(2);
746         ASSERT_NE(TestFile.BusinessAddressListTimezone.end(), TestFileIter);
747         ASSERT_EQ("Europe/Newquay", TestFileIter->second);
748         
749         // Check the MEDIATYPE section.
750         
751         TestFileIter = TestFile.BusinessAddressListMediatype.find(2);
752         ASSERT_NE(TestFile.BusinessAddressListMediatype.end(), TestFileIter);
753         ASSERT_EQ("text/plain", TestFileIter->second);
754         
755         // Check the PREF section.
756         
757         TestFileIntIter = TestFile.BusinessAddressListPref.find(2);
758         ASSERT_NE(TestFile.BusinessAddressListPref.end(), TestFileIntIter);
759         ASSERT_EQ(10, TestFileIntIter->second);
760         
761         // Check the extra tokens.
762         
763         TestFileIter = TestFile.BusinessAddressListTokens.find(2);
764         ASSERT_NE(TestFile.BusinessAddressListTokens.end(), TestFileIter);
765         ASSERT_EQ("JAM=Red", TestFileIter->second);
770 TEST(ContactLoad, EmailTests){
772         ContactDataObject TestFile;
774         // Check that the vCard 4.0 file loads OK.
776         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
778         std::map<int,wxString>::iterator TestFileIter;
779         std::map<int,int>::iterator TestFileIntIter;
780         
781         // Start with the general email.
782         
783         TestFileIter = TestFile.GeneralEmailList.find(0);
784         ASSERT_NE(TestFile.GeneralEmailList.end(), TestFileIter);
785         ASSERT_EQ("moo@example.com", TestFileIter->second);
786         
787         // Check the ALTID section.
788         
789         TestFileIter = TestFile.GeneralEmailListAltID.find(0);
790         ASSERT_NE(TestFile.GeneralEmailListAltID.end(), TestFileIter);
791         ASSERT_EQ("10", TestFileIter->second);
792         
793         // Check the PID section.
794         
795         TestFileIter = TestFile.GeneralEmailListPID.find(0);
796         ASSERT_NE(TestFile.GeneralEmailListPID.end(), TestFileIter);
797         ASSERT_EQ("20", TestFileIter->second);
798         
799         // Check the PREF section.
800         
801         TestFileIntIter = TestFile.GeneralEmailListPref.find(0);
802         ASSERT_NE(TestFile.GeneralEmailListPref.end(), TestFileIntIter);
803         ASSERT_EQ(40, TestFileIntIter->second);
804         
805         // Check the extra tokens.
806         
807         TestFileIter = TestFile.GeneralEmailListTokens.find(0);
808         ASSERT_NE(TestFile.GeneralEmailListTokens.end(), TestFileIter);
809         ASSERT_EQ("WONDERFUL=Colour", TestFileIter->second);
811         // Start with the home email.
812         
813         TestFileIter = TestFile.HomeEmailList.find(1);
814         ASSERT_NE(TestFile.HomeEmailList.end(), TestFileIter);
815         ASSERT_EQ("moo.home@example.com", TestFileIter->second);
816         
817         // Check the ALTID section.
818         
819         TestFileIter = TestFile.HomeEmailListAltID.find(1);
820         ASSERT_NE(TestFile.HomeEmailListAltID.end(), TestFileIter);
821         ASSERT_EQ("5", TestFileIter->second);
822         
823         // Check the PID section.
824         
825         TestFileIter = TestFile.HomeEmailListPID.find(1);
826         ASSERT_NE(TestFile.HomeEmailListPID.end(), TestFileIter);
827         ASSERT_EQ("10", TestFileIter->second);
828         
829         // Check the PREF section.
830         
831         TestFileIntIter = TestFile.HomeEmailListPref.find(1);
832         ASSERT_NE(TestFile.HomeEmailListPref.end(), TestFileIntIter);
833         ASSERT_EQ(20, TestFileIntIter->second);
834         
835         // Check the extra tokens.
836         
837         TestFileIter = TestFile.HomeEmailListTokens.find(1);
838         ASSERT_NE(TestFile.HomeEmailListTokens.end(), TestFileIter);
839         ASSERT_EQ("PEACE=quiet", TestFileIter->second);
841         // Start with the business email.
842         
843         TestFileIter = TestFile.BusinessEmailList.find(2);
844         ASSERT_NE(TestFile.BusinessEmailList.end(), TestFileIter);
845         ASSERT_EQ("moo.business@example.com", TestFileIter->second);
846         
847         // Check the ALTID section.
848         
849         TestFileIter = TestFile.BusinessEmailListAltID.find(2);
850         ASSERT_NE(TestFile.BusinessEmailListAltID.end(), TestFileIter);
851         ASSERT_EQ("1", TestFileIter->second);
852         
853         // Check the PID section.
854         
855         TestFileIter = TestFile.BusinessEmailListPID.find(2);
856         ASSERT_NE(TestFile.BusinessEmailListPID.end(), TestFileIter);
857         ASSERT_EQ("2", TestFileIter->second);
858         
859         // Check the PREF section.
860         
861         TestFileIntIter = TestFile.BusinessEmailListPref.find(2);
862         ASSERT_NE(TestFile.BusinessEmailListPref.end(), TestFileIntIter);
863         ASSERT_EQ(3, TestFileIntIter->second);
864         
865         // Check the extra tokens.
866         
867         TestFileIter = TestFile.BusinessEmailListTokens.find(2);
868         ASSERT_NE(TestFile.BusinessEmailListTokens.end(), TestFileIter);
869         ASSERT_EQ("BUSINESS=Money", TestFileIter->second);
873 TEST(ContactLoad, IMTests){
875         ContactDataObject TestFile;
877         // Check that the vCard 4.0 file loads OK.
879         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
881         std::map<int,wxString>::iterator TestFileIter;
882         std::map<int,int>::iterator TestFileIntIter;
883         
884         // Start with the general IM.
885         
886         TestFileIter = TestFile.GeneralIMList.find(0);
887         ASSERT_NE(TestFile.GeneralIMList.end(), TestFileIter);
888         ASSERT_EQ("moo@example.com", TestFileIter->second);
889         
890         // Check the ALTID section.
891         
892         TestFileIter = TestFile.GeneralIMListAltID.find(0);
893         ASSERT_NE(TestFile.GeneralIMListAltID.end(), TestFileIter);
894         ASSERT_EQ("10", TestFileIter->second);
895         
896         // Check the PID section.
897         
898         TestFileIter = TestFile.GeneralIMListPID.find(0);
899         ASSERT_NE(TestFile.GeneralIMListPID.end(), TestFileIter);
900         ASSERT_EQ("20", TestFileIter->second);
902         // Check the MEDIATYPE section.
903         
904         TestFileIter = TestFile.GeneralIMListMediatype.find(0);
905         ASSERT_NE(TestFile.GeneralIMListMediatype.end(), TestFileIter);
906         ASSERT_EQ("text/plain", TestFileIter->second);
907         
908         // Check the PREF section.
909         
910         TestFileIntIter = TestFile.GeneralIMListPref.find(0);
911         ASSERT_NE(TestFile.GeneralIMListPref.end(), TestFileIntIter);
912         ASSERT_EQ(40, TestFileIntIter->second);
913         
914         // Check the extra tokens.
915         
916         TestFileIter = TestFile.GeneralIMListTokens.find(0);
917         ASSERT_NE(TestFile.GeneralIMListTokens.end(), TestFileIter);
918         ASSERT_EQ("WONDERFUL=Colour", TestFileIter->second);
920         // Start with the home IM.
921         
922         TestFileIter = TestFile.HomeIMList.find(1);
923         ASSERT_NE(TestFile.HomeIMList.end(), TestFileIter);
924         ASSERT_EQ("moo.home@example.com", TestFileIter->second);
925         
926         // Check the ALTID section.
927         
928         TestFileIter = TestFile.HomeIMListAltID.find(1);
929         ASSERT_NE(TestFile.HomeIMListAltID.end(), TestFileIter);
930         ASSERT_EQ("20", TestFileIter->second);
931         
932         // Check the PID section.
933         
934         TestFileIter = TestFile.HomeIMListPID.find(1);
935         ASSERT_NE(TestFile.HomeIMListPID.end(), TestFileIter);
936         ASSERT_EQ("40", TestFileIter->second);
937         
938         // Check the MEDIATYPE section.
939         
940         TestFileIter = TestFile.HomeIMListMediatype.find(1);
941         ASSERT_NE(TestFile.HomeIMListMediatype.end(), TestFileIter);
942         ASSERT_EQ("text/reallyplain", TestFileIter->second);
943         
944         // Check the PREF section.
945         
946         TestFileIntIter = TestFile.HomeIMListPref.find(1);
947         ASSERT_NE(TestFile.HomeIMListPref.end(), TestFileIntIter);
948         ASSERT_EQ(80, TestFileIntIter->second);
949         
950         // Check the extra tokens.
951         
952         TestFileIter = TestFile.HomeIMListTokens.find(1);
953         ASSERT_NE(TestFile.HomeIMListTokens.end(), TestFileIter);
954         ASSERT_EQ("PEACE=quiet", TestFileIter->second);
956         // Start with the business IM.
957         
958         TestFileIter = TestFile.BusinessIMList.find(2);
959         ASSERT_NE(TestFile.BusinessIMList.end(), TestFileIter);
960         ASSERT_EQ("moo.business@example.com", TestFileIter->second);
961         
962         // Check the ALTID section.
963         
964         TestFileIter = TestFile.BusinessIMListAltID.find(2);
965         ASSERT_NE(TestFile.BusinessIMListAltID.end(), TestFileIter);
966         ASSERT_EQ("98", TestFileIter->second);
967         
968         // Check the PID section.
969         
970         TestFileIter = TestFile.BusinessIMListPID.find(2);
971         ASSERT_NE(TestFile.BusinessIMListPID.end(), TestFileIter);
972         ASSERT_EQ("99", TestFileIter->second);
973         
974         // Check the MEDIATYPE section.
975         
976         TestFileIter = TestFile.BusinessIMListMediatype.find(2);
977         ASSERT_NE(TestFile.BusinessIMListMediatype.end(), TestFileIter);
978         ASSERT_EQ("text/superplain", TestFileIter->second);
979         
980         // Check the PREF section.
981         
982         TestFileIntIter = TestFile.BusinessIMListPref.find(2);
983         ASSERT_NE(TestFile.BusinessIMListPref.end(), TestFileIntIter);
984         ASSERT_EQ(50, TestFileIntIter->second);
985         
986         // Check the extra tokens.
987         
988         TestFileIter = TestFile.BusinessIMListTokens.find(2);
989         ASSERT_NE(TestFile.BusinessIMListTokens.end(), TestFileIter);
990         ASSERT_EQ("BUSINESS=Money", TestFileIter->second);
994 TEST(ContactLoad, TelephoneTests){
996         ContactDataObject TestFile;
998         // Check that the vCard 4.0 file loads OK.
1000         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1002         std::map<int,wxString>::iterator TestFileIter;
1003         std::map<int,int>::iterator TestFileIntIter;
1004         
1005         // Start with the general Telephone.
1006         
1007         TestFileIter = TestFile.GeneralTelephoneList.find(0);
1008         ASSERT_NE(TestFile.GeneralTelephoneList.end(), TestFileIter);
1009         ASSERT_EQ("tel:00000000", TestFileIter->second);
1010         
1011         // Check the type section.
1012         
1013         TestFileIter = TestFile.GeneralTelephoneListTypeInfo.find(0);
1014         ASSERT_NE(TestFile.GeneralTelephoneListTypeInfo.end(), TestFileIter);
1015         ASSERT_EQ("fax,mobile", TestFileIter->second);  
1016         
1017         // Check the ALTID section.
1018         
1019         TestFileIter = TestFile.GeneralTelephoneListAltID.find(0);
1020         ASSERT_NE(TestFile.GeneralTelephoneListAltID.end(), TestFileIter);
1021         ASSERT_EQ("10", TestFileIter->second);
1022         
1023         // Check the PID section.
1024         
1025         TestFileIter = TestFile.GeneralTelephoneListPID.find(0);
1026         ASSERT_NE(TestFile.GeneralTelephoneListPID.end(), TestFileIter);
1027         ASSERT_EQ("20", TestFileIter->second);
1028         
1029         // Check the PREF section.
1030         
1031         TestFileIntIter = TestFile.GeneralTelephoneListPref.find(0);
1032         ASSERT_NE(TestFile.GeneralTelephoneListPref.end(), TestFileIntIter);
1033         ASSERT_EQ(40, TestFileIntIter->second);
1034         
1035         // Check the extra tokens.
1036         
1037         TestFileIter = TestFile.GeneralTelephoneListTokens.find(0);
1038         ASSERT_NE(TestFile.GeneralTelephoneListTokens.end(), TestFileIter);
1039         ASSERT_EQ("WONDERFUL=Colour", TestFileIter->second);
1040         
1041         // Start with the home Telephone.
1042         
1043         TestFileIter = TestFile.HomeTelephoneList.find(1);
1044         ASSERT_NE(TestFile.HomeTelephoneList.end(), TestFileIter);
1045         ASSERT_EQ("tel:00001111", TestFileIter->second);
1046         
1047         // Check the type section.
1048         
1049         TestFileIter = TestFile.HomeTelephoneListTypeInfo.find(1);
1050         ASSERT_NE(TestFile.HomeTelephoneListTypeInfo.end(), TestFileIter);
1051         ASSERT_EQ("fax", TestFileIter->second); 
1052         
1053         // Check the ALTID section.
1054         
1055         TestFileIter = TestFile.HomeTelephoneListAltID.find(1);
1056         ASSERT_NE(TestFile.HomeTelephoneListAltID.end(), TestFileIter);
1057         ASSERT_EQ("10", TestFileIter->second);
1058         
1059         // Check the PID section.
1060         
1061         TestFileIter = TestFile.HomeTelephoneListPID.find(1);
1062         ASSERT_NE(TestFile.HomeTelephoneListPID.end(), TestFileIter);
1063         ASSERT_EQ("20", TestFileIter->second);
1064         
1065         // Check the PREF section.
1066         
1067         TestFileIntIter = TestFile.HomeTelephoneListPref.find(1);
1068         ASSERT_NE(TestFile.HomeTelephoneListPref.end(), TestFileIntIter);
1069         ASSERT_EQ(40, TestFileIntIter->second);
1070         
1071         // Check the extra tokens.
1072         
1073         TestFileIter = TestFile.HomeTelephoneListTokens.find(1);
1074         ASSERT_NE(TestFile.HomeTelephoneListTokens.end(), TestFileIter);
1075         ASSERT_EQ("BUSINESS=Money", TestFileIter->second);
1077         // Start with the business Telephone.
1078         
1079         TestFileIter = TestFile.BusinessTelephoneList.find(2);
1080         ASSERT_NE(TestFile.BusinessTelephoneList.end(), TestFileIter);
1081         ASSERT_EQ("tel:22221111", TestFileIter->second);
1082         
1083         // Check the type section.
1084         
1085         TestFileIter = TestFile.BusinessTelephoneListTypeInfo.find(2);
1086         ASSERT_NE(TestFile.BusinessTelephoneListTypeInfo.end(), TestFileIter);
1087         ASSERT_EQ("voice", TestFileIter->second);       
1088         
1089         // Check the ALTID section.
1090         
1091         TestFileIter = TestFile.BusinessTelephoneListAltID.find(2);
1092         ASSERT_NE(TestFile.BusinessTelephoneListAltID.end(), TestFileIter);
1093         ASSERT_EQ("25", TestFileIter->second);
1094         
1095         // Check the PID section.
1096         
1097         TestFileIter = TestFile.BusinessTelephoneListPID.find(2);
1098         ASSERT_NE(TestFile.BusinessTelephoneListPID.end(), TestFileIter);
1099         ASSERT_EQ("50", TestFileIter->second);
1100         
1101         // Check the PREF section.
1102         
1103         TestFileIntIter = TestFile.BusinessTelephoneListPref.find(2);
1104         ASSERT_NE(TestFile.BusinessTelephoneListPref.end(), TestFileIntIter);
1105         ASSERT_EQ(75, TestFileIntIter->second);
1106         
1107         // Check the extra tokens.
1108         
1109         TestFileIter = TestFile.BusinessTelephoneListTokens.find(2);
1110         ASSERT_NE(TestFile.BusinessTelephoneListTokens.end(), TestFileIter);
1111         ASSERT_EQ("BEEP=Boop", TestFileIter->second);
1115 TEST(ContactLoad, LanguageTests){
1117         ContactDataObject TestFile;
1119         // Check that the vCard 4.0 file loads OK.
1121         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1123         std::map<int,wxString>::iterator TestFileIter;
1124         std::map<int,int>::iterator TestFileIntIter;
1125         
1126         // Start with the general language.
1127         
1128         TestFileIter = TestFile.GeneralLanguageList.find(0);
1129         ASSERT_NE(TestFile.GeneralLanguageList.end(), TestFileIter);
1130         ASSERT_EQ("kw", TestFileIter->second);
1131         
1132         // Check the ALTID section.
1133         
1134         TestFileIter = TestFile.GeneralLanguageListAltID.find(0);
1135         ASSERT_NE(TestFile.GeneralLanguageListAltID.end(), TestFileIter);
1136         ASSERT_EQ("20", TestFileIter->second);
1137         
1138         // Check the PID section.
1139         
1140         TestFileIter = TestFile.GeneralLanguageListPID.find(0);
1141         ASSERT_NE(TestFile.GeneralLanguageListPID.end(), TestFileIter);
1142         ASSERT_EQ("40", TestFileIter->second);
1143         
1144         // Check the PREF section.
1145         
1146         TestFileIntIter = TestFile.GeneralLanguageListPref.find(0);
1147         ASSERT_NE(TestFile.GeneralLanguageListPref.end(), TestFileIntIter);
1148         ASSERT_EQ(80, TestFileIntIter->second);
1149         
1150         // Check the extra tokens.
1151         
1152         TestFileIter = TestFile.GeneralLanguageListTokens.find(0);
1153         ASSERT_NE(TestFile.GeneralLanguageListTokens.end(), TestFileIter);
1154         ASSERT_EQ("GELFORN=Great", TestFileIter->second);
1155         
1156         // Start with the home language.
1157         
1158         TestFileIter = TestFile.HomeLanguageList.find(1);
1159         ASSERT_NE(TestFile.HomeLanguageList.end(), TestFileIter);
1160         ASSERT_EQ("en", TestFileIter->second);
1161         
1162         // Check the ALTID section.
1163         
1164         TestFileIter = TestFile.HomeLanguageListAltID.find(1);
1165         ASSERT_NE(TestFile.HomeLanguageListAltID.end(), TestFileIter);
1166         ASSERT_EQ("22", TestFileIter->second);
1167         
1168         // Check the PID section.
1169         
1170         TestFileIter = TestFile.HomeLanguageListPID.find(1);
1171         ASSERT_NE(TestFile.HomeLanguageListPID.end(), TestFileIter);
1172         ASSERT_EQ("45", TestFileIter->second);
1173         
1174         // Check the PREF section.
1175         
1176         TestFileIntIter = TestFile.HomeLanguageListPref.find(1);
1177         ASSERT_NE(TestFile.HomeLanguageListPref.end(), TestFileIntIter);
1178         ASSERT_EQ(90, TestFileIntIter->second);
1179         
1180         // Check the extra tokens.
1181         
1182         TestFileIter = TestFile.HomeLanguageListTokens.find(1);
1183         ASSERT_NE(TestFile.HomeLanguageListTokens.end(), TestFileIter);
1184         ASSERT_EQ("LANGUAGE=yes", TestFileIter->second);
1186         // Start with the business language.
1187         
1188         TestFileIter = TestFile.BusinessLanguageList.find(2);
1189         ASSERT_NE(TestFile.BusinessLanguageList.end(), TestFileIter);
1190         ASSERT_EQ("cy", TestFileIter->second);
1191         
1192         // Check the ALTID section.
1193         
1194         TestFileIter = TestFile.BusinessLanguageListAltID.find(2);
1195         ASSERT_NE(TestFile.BusinessLanguageListAltID.end(), TestFileIter);
1196         ASSERT_EQ("10", TestFileIter->second);
1197         
1198         // Check the PID section.
1199         
1200         TestFileIter = TestFile.BusinessLanguageListPID.find(2);
1201         ASSERT_NE(TestFile.BusinessLanguageListPID.end(), TestFileIter);
1202         ASSERT_EQ("15", TestFileIter->second);
1203         
1204         // Check the PREF section.
1205         
1206         TestFileIntIter = TestFile.BusinessLanguageListPref.find(2);
1207         ASSERT_NE(TestFile.BusinessLanguageListPref.end(), TestFileIntIter);
1208         ASSERT_EQ(20, TestFileIntIter->second);
1209         
1210         // Check the extra tokens.
1211         
1212         TestFileIter = TestFile.BusinessLanguageListTokens.find(2);
1213         ASSERT_NE(TestFile.BusinessLanguageListTokens.end(), TestFileIter);
1214         ASSERT_EQ("FFENSTRI=ie", TestFileIter->second);
1218 TEST(ContactLoad, GeographicTests){
1220         ContactDataObject TestFile;
1222         // Check that the vCard 4.0 file loads OK.
1224         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1226         std::map<int,wxString>::iterator TestFileIter;
1227         std::map<int,int>::iterator TestFileIntIter;
1228         
1229         // Start with the general Geoposition.
1230         
1231         TestFileIter = TestFile.GeneralGeographyList.find(0);
1232         ASSERT_NE(TestFile.GeneralGeographyList.end(), TestFileIter);
1233         ASSERT_EQ("geo:3.5,3.5", TestFileIter->second);
1234         
1235         // Check the ALTID section.
1236         
1237         TestFileIter = TestFile.GeneralGeographyListAltID.find(0);
1238         ASSERT_NE(TestFile.GeneralGeographyListAltID.end(), TestFileIter);
1239         ASSERT_EQ("13", TestFileIter->second);
1240         
1241         // Check the PID section.
1242         
1243         TestFileIter = TestFile.GeneralGeographyListPID.find(0);
1244         ASSERT_NE(TestFile.GeneralGeographyListPID.end(), TestFileIter);
1245         ASSERT_EQ("26", TestFileIter->second);
1246         
1247         // Check the MEDIATYPE section.
1248         
1249         TestFileIter = TestFile.GeneralGeographyListMediatype.find(0);
1250         ASSERT_NE(TestFile.GeneralGeographyListMediatype.end(), TestFileIter);
1251         ASSERT_EQ("text/plain", TestFileIter->second);
1252         
1253         // Check the PREF section.
1254         
1255         TestFileIntIter = TestFile.GeneralGeographyListPref.find(0);
1256         ASSERT_NE(TestFile.GeneralGeographyListPref.end(), TestFileIntIter);
1257         ASSERT_EQ(39, TestFileIntIter->second);
1258         
1259         // Check the extra tokens.
1260         
1261         TestFileIter = TestFile.GeneralGeographyListTokens.find(0);
1262         ASSERT_NE(TestFile.GeneralGeographyListTokens.end(), TestFileIter);
1263         ASSERT_EQ("POS=Yep", TestFileIter->second);
1265         // Start with the home Geoposition.
1266         
1267         TestFileIter = TestFile.HomeGeographyList.find(1);
1268         ASSERT_NE(TestFile.HomeGeographyList.end(), TestFileIter);
1269         ASSERT_EQ("geo:7.0,7.0", TestFileIter->second);
1270         
1271         // Check the ALTID section.
1272         
1273         TestFileIter = TestFile.HomeGeographyListAltID.find(1);
1274         ASSERT_NE(TestFile.HomeGeographyListAltID.end(), TestFileIter);
1275         ASSERT_EQ("140", TestFileIter->second);
1276         
1277         // Check the PID section.
1278         
1279         TestFileIter = TestFile.HomeGeographyListPID.find(1);
1280         ASSERT_NE(TestFile.HomeGeographyListPID.end(), TestFileIter);
1281         ASSERT_EQ("70", TestFileIter->second);
1282         
1283         // Check the MEDIATYPE section.
1284         
1285         TestFileIter = TestFile.HomeGeographyListMediatype.find(1);
1286         ASSERT_NE(TestFile.HomeGeographyListMediatype.end(), TestFileIter);
1287         ASSERT_EQ("text/ratherplain", TestFileIter->second);
1288         
1289         // Check the PREF section.
1290         
1291         TestFileIntIter = TestFile.HomeGeographyListPref.find(1);
1292         ASSERT_NE(TestFile.HomeGeographyListPref.end(), TestFileIntIter);
1293         ASSERT_EQ(1, TestFileIntIter->second);
1294         
1295         // Check the extra tokens.
1296         
1297         TestFileIter = TestFile.HomeGeographyListTokens.find(1);
1298         ASSERT_NE(TestFile.HomeGeographyListTokens.end(), TestFileIter);
1299         ASSERT_EQ("POS=Nope", TestFileIter->second);
1301         // Start with the business Geoposition.
1302         
1303         TestFileIter = TestFile.BusinessGeographyList.find(2);
1304         ASSERT_NE(TestFile.BusinessGeographyList.end(), TestFileIter);
1305         ASSERT_EQ("geo:14.0,14.0", TestFileIter->second);
1306         
1307         // Check the ALTID section.
1308         
1309         TestFileIter = TestFile.BusinessGeographyListAltID.find(2);
1310         ASSERT_NE(TestFile.BusinessGeographyListAltID.end(), TestFileIter);
1311         ASSERT_EQ("75", TestFileIter->second);
1312         
1313         // Check the PID section.
1314         
1315         TestFileIter = TestFile.BusinessGeographyListPID.find(2);
1316         ASSERT_NE(TestFile.BusinessGeographyListPID.end(), TestFileIter);
1317         ASSERT_EQ("32", TestFileIter->second);
1318         
1319         // Check the MEDIATYPE section.
1320         
1321         TestFileIter = TestFile.BusinessGeographyListMediatype.find(2);
1322         ASSERT_NE(TestFile.BusinessGeographyListMediatype.end(), TestFileIter);
1323         ASSERT_EQ("text/greenplain", TestFileIter->second);
1324         
1325         // Check the PREF section.
1326         
1327         TestFileIntIter = TestFile.BusinessGeographyListPref.find(2);
1328         ASSERT_NE(TestFile.BusinessGeographyListPref.end(), TestFileIntIter);
1329         ASSERT_EQ(4, TestFileIntIter->second);
1330         
1331         // Check the extra tokens.
1332         
1333         TestFileIter = TestFile.BusinessGeographyListTokens.find(2);
1334         ASSERT_NE(TestFile.BusinessGeographyListTokens.end(), TestFileIter);
1335         ASSERT_EQ("POS=Money", TestFileIter->second);
1339 TEST(ContactLoad, RelatedTests){
1341         ContactDataObject TestFile;
1343         // Check that the vCard 4.0 file loads OK.
1345         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1347         std::map<int,wxString>::iterator TestFileIter;
1348         std::map<int,int>::iterator TestFileIntIter;
1349         
1350         // Start with the first relation.
1351         
1352         TestFileIter = TestFile.GeneralRelatedList.find(0);
1353         ASSERT_NE(TestFile.GeneralRelatedList.end(), TestFileIter);
1354         ASSERT_EQ("Friend Test", TestFileIter->second);
1356         // Check the TYPE section.
1357         
1358         TestFileIter = TestFile.GeneralRelatedListType.find(0);
1359         ASSERT_NE(TestFile.GeneralRelatedListType.end(), TestFileIter);
1360         ASSERT_EQ("Kin", TestFileIter->second);
1362         // Check the ALTID section.
1363         
1364         TestFileIter = TestFile.GeneralRelatedListAltID.find(0);
1365         ASSERT_NE(TestFile.GeneralRelatedListAltID.end(), TestFileIter);
1366         ASSERT_EQ("5", TestFileIter->second);
1367         
1368         // Check the PID section.
1369         
1370         TestFileIter = TestFile.GeneralRelatedListPID.find(0);
1371         ASSERT_NE(TestFile.GeneralRelatedListPID.end(), TestFileIter);
1372         ASSERT_EQ("10", TestFileIter->second);
1373                 
1374         // Check the PREF section.
1375         
1376         TestFileIntIter = TestFile.GeneralRelatedListPref.find(0);
1377         ASSERT_NE(TestFile.GeneralRelatedListPref.end(), TestFileIntIter);
1378         ASSERT_EQ(20, TestFileIntIter->second);
1379         
1380         // Check the extra tokens.
1381         
1382         TestFileIter = TestFile.GeneralRelatedListTokens.find(0);
1383         ASSERT_NE(TestFile.GeneralRelatedListTokens.end(), TestFileIter);
1384         ASSERT_EQ("OPTION=Yes", TestFileIter->second);
1386         // Start with the second relation.
1387         
1388         TestFileIter = TestFile.GeneralRelatedList.find(1);
1389         ASSERT_NE(TestFile.GeneralRelatedList.end(), TestFileIter);
1390         ASSERT_EQ("Friend Test Two", TestFileIter->second);
1392         // Check the TYPE section.
1393         
1394         TestFileIter = TestFile.GeneralRelatedListType.find(1);
1395         ASSERT_NE(TestFile.GeneralRelatedListType.end(), TestFileIter);
1396         ASSERT_EQ("Spouse", TestFileIter->second);
1398         // Check the ALTID section.
1399         
1400         TestFileIter = TestFile.GeneralRelatedListAltID.find(1);
1401         ASSERT_NE(TestFile.GeneralRelatedListAltID.end(), TestFileIter);
1402         ASSERT_EQ("1", TestFileIter->second);
1403         
1404         // Check the PID section.
1405         
1406         TestFileIter = TestFile.GeneralRelatedListPID.find(1);
1407         ASSERT_NE(TestFile.GeneralRelatedListPID.end(), TestFileIter);
1408         ASSERT_EQ("2", TestFileIter->second);
1409                 
1410         // Check the PREF section.
1411         
1412         TestFileIntIter = TestFile.GeneralRelatedListPref.find(1);
1413         ASSERT_NE(TestFile.GeneralRelatedListPref.end(), TestFileIntIter);
1414         ASSERT_EQ(3, TestFileIntIter->second);
1415         
1416         // Check the extra tokens.
1417         
1418         TestFileIter = TestFile.GeneralRelatedListTokens.find(1);
1419         ASSERT_NE(TestFile.GeneralRelatedListTokens.end(), TestFileIter);
1420         ASSERT_EQ("OPTION=No", TestFileIter->second);
1421         
1422         // Start with the second relation.
1423         
1424         TestFileIter = TestFile.GeneralRelatedList.find(2);
1425         ASSERT_NE(TestFile.GeneralRelatedList.end(), TestFileIter);
1426         ASSERT_EQ("Friend Test Three", TestFileIter->second);
1428         // Check the TYPE section.
1429         
1430         TestFileIter = TestFile.GeneralRelatedListType.find(2);
1431         ASSERT_NE(TestFile.GeneralRelatedListType.end(), TestFileIter);
1432         ASSERT_EQ("Muse", TestFileIter->second);
1434         // Check the ALTID section.
1435         
1436         TestFileIter = TestFile.GeneralRelatedListAltID.find(2);
1437         ASSERT_NE(TestFile.GeneralRelatedListAltID.end(), TestFileIter);
1438         ASSERT_EQ("4", TestFileIter->second);
1439         
1440         // Check the PID section.
1441         
1442         TestFileIter = TestFile.GeneralRelatedListPID.find(2);
1443         ASSERT_NE(TestFile.GeneralRelatedListPID.end(), TestFileIter);
1444         ASSERT_EQ("5", TestFileIter->second);
1445                 
1446         // Check the PREF section.
1447         
1448         TestFileIntIter = TestFile.GeneralRelatedListPref.find(2);
1449         ASSERT_NE(TestFile.GeneralRelatedListPref.end(), TestFileIntIter);
1450         ASSERT_EQ(6, TestFileIntIter->second);
1451         
1452         // Check the extra tokens.
1453         
1454         TestFileIter = TestFile.GeneralRelatedListTokens.find(2);
1455         ASSERT_NE(TestFile.GeneralRelatedListTokens.end(), TestFileIter);
1456         ASSERT_EQ("OPTION=Maybe", TestFileIter->second);
1460 TEST(ContactLoad, URLTests){
1462         ContactDataObject TestFile;
1464         // Check that the vCard 4.0 file loads OK.
1466         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1468         std::map<int,wxString>::iterator TestFileIter;
1469         std::map<int,int>::iterator TestFileIntIter;
1471         // Start with the general URL.
1472         
1473         TestFileIter = TestFile.GeneralWebsiteList.find(0);
1474         ASSERT_NE(TestFile.GeneralWebsiteList.end(), TestFileIter);
1475         ASSERT_EQ("http://example.com/", TestFileIter->second);
1476         
1477         // Check the ALTID section.
1478         
1479         TestFileIter = TestFile.GeneralWebsiteListAltID.find(0);
1480         ASSERT_NE(TestFile.GeneralWebsiteListAltID.end(), TestFileIter);
1481         ASSERT_EQ("0", TestFileIter->second);
1482         
1483         // Check the PID section.
1484         
1485         TestFileIter = TestFile.GeneralWebsiteListPID.find(0);
1486         ASSERT_NE(TestFile.GeneralWebsiteListPID.end(), TestFileIter);
1487         ASSERT_EQ("1", TestFileIter->second);
1488         
1489         // Check the MEDIATYPE section.
1490         
1491         TestFileIter = TestFile.GeneralWebsiteListMediatype.find(0);
1492         ASSERT_NE(TestFile.GeneralWebsiteListMediatype.end(), TestFileIter);
1493         ASSERT_EQ("text/plain", TestFileIter->second);
1494         
1495         // Check the PREF section.
1496         
1497         TestFileIntIter = TestFile.GeneralWebsiteListPref.find(0);
1498         ASSERT_NE(TestFile.GeneralWebsiteListPref.end(), TestFileIntIter);
1499         ASSERT_EQ(2, TestFileIntIter->second);
1500         
1501         // Check the extra tokens.
1502         
1503         TestFileIter = TestFile.GeneralWebsiteListTokens.find(0);
1504         ASSERT_NE(TestFile.GeneralWebsiteListTokens.end(), TestFileIter);
1505         ASSERT_EQ("MEEP=Moo", TestFileIter->second);
1507         // Start with the home URL.
1509         TestFileIter = TestFile.HomeWebsiteList.find(1);
1510         ASSERT_NE(TestFile.HomeWebsiteList.end(), TestFileIter);
1511         ASSERT_EQ("http://example.com/home/", TestFileIter->second);
1512         
1513         // Check the ALTID section.
1514         
1515         TestFileIter = TestFile.HomeWebsiteListAltID.find(1);
1516         ASSERT_NE(TestFile.HomeWebsiteListAltID.end(), TestFileIter);
1517         ASSERT_EQ("10", TestFileIter->second);
1518         
1519         // Check the PID section.
1520         
1521         TestFileIter = TestFile.HomeWebsiteListPID.find(1);
1522         ASSERT_NE(TestFile.HomeWebsiteListPID.end(), TestFileIter);
1523         ASSERT_EQ("11", TestFileIter->second);
1524         
1525         // Check the MEDIATYPE section.
1526         
1527         TestFileIter = TestFile.HomeWebsiteListMediatype.find(1);
1528         ASSERT_NE(TestFile.HomeWebsiteListMediatype.end(), TestFileIter);
1529         ASSERT_EQ("grass/soggy", TestFileIter->second);
1530         
1531         // Check the PREF section.
1532         
1533         TestFileIntIter = TestFile.HomeWebsiteListPref.find(1);
1534         ASSERT_NE(TestFile.HomeWebsiteListPref.end(), TestFileIntIter);
1535         ASSERT_EQ(12, TestFileIntIter->second);
1536         
1537         // Check the extra tokens.
1538         
1539         TestFileIter = TestFile.HomeWebsiteListTokens.find(1);
1540         ASSERT_NE(TestFile.HomeWebsiteListTokens.end(), TestFileIter);
1541         ASSERT_EQ("BON=Bon", TestFileIter->second);
1542         
1543         // Start with the business URL.
1545         TestFileIter = TestFile.BusinessWebsiteList.find(2);
1546         ASSERT_NE(TestFile.BusinessWebsiteList.end(), TestFileIter);
1547         ASSERT_EQ("http://example.com/business/", TestFileIter->second);
1548         
1549         // Check the ALTID section.
1550         
1551         TestFileIter = TestFile.BusinessWebsiteListAltID.find(2);
1552         ASSERT_NE(TestFile.BusinessWebsiteListAltID.end(), TestFileIter);
1553         ASSERT_EQ("20", TestFileIter->second);
1554         
1555         // Check the PID section.
1556         
1557         TestFileIter = TestFile.BusinessWebsiteListPID.find(2);
1558         ASSERT_NE(TestFile.BusinessWebsiteListPID.end(), TestFileIter);
1559         ASSERT_EQ("21", TestFileIter->second);
1560         
1561         // Check the MEDIATYPE section.
1562         
1563         TestFileIter = TestFile.BusinessWebsiteListMediatype.find(2);
1564         ASSERT_NE(TestFile.BusinessWebsiteListMediatype.end(), TestFileIter);
1565         ASSERT_EQ("chocolate/yummy", TestFileIter->second);
1566         
1567         // Check the PREF section.
1568         
1569         TestFileIntIter = TestFile.BusinessWebsiteListPref.find(2);
1570         ASSERT_NE(TestFile.BusinessWebsiteListPref.end(), TestFileIntIter);
1571         ASSERT_EQ(22, TestFileIntIter->second);
1572         
1573         // Check the extra tokens.
1574         
1575         TestFileIter = TestFile.BusinessWebsiteListTokens.find(2);
1576         ASSERT_NE(TestFile.BusinessWebsiteListTokens.end(), TestFileIter);
1577         ASSERT_EQ("YES=No", TestFileIter->second);
1581 TEST(ContactLoad, TitleTests){
1583         ContactDataObject TestFile;
1585         // Check that the vCard 4.0 file loads OK.
1587         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1589         std::map<int,wxString>::iterator TestFileIter;
1590         std::map<int,int>::iterator TestFileIntIter;
1592         // Start with the general title.
1593         
1594         TestFileIter = TestFile.GeneralTitleList.find(0);
1595         ASSERT_NE(TestFile.GeneralTitleList.end(), TestFileIter);
1596         ASSERT_EQ("Lord of Light", TestFileIter->second);
1597         
1598         // Check the ALTID section.
1599         
1600         TestFileIter = TestFile.GeneralTitleListAltID.find(0);
1601         ASSERT_NE(TestFile.GeneralTitleListAltID.end(), TestFileIter);
1602         ASSERT_EQ("20", TestFileIter->second);
1603         
1604         // Check the PID section.
1605         
1606         TestFileIter = TestFile.GeneralTitleListPID.find(0);
1607         ASSERT_NE(TestFile.GeneralTitleListPID.end(), TestFileIter);
1608         ASSERT_EQ("21", TestFileIter->second);
1609         
1610         // Check the LANGUAGE section.
1611         
1612         TestFileIter = TestFile.GeneralTitleListLanguage.find(0);
1613         ASSERT_NE(TestFile.GeneralTitleListLanguage.end(), TestFileIter);
1614         ASSERT_EQ("text/plain", TestFileIter->second);
1615         
1616         // Check the PREF section.
1617         
1618         TestFileIntIter = TestFile.GeneralTitleListPref.find(0);
1619         ASSERT_NE(TestFile.GeneralTitleListPref.end(), TestFileIntIter);
1620         ASSERT_EQ(22, TestFileIntIter->second);
1621         
1622         // Check the extra tokens.
1623         
1624         TestFileIter = TestFile.GeneralTitleListTokens.find(0);
1625         ASSERT_NE(TestFile.GeneralTitleListTokens.end(), TestFileIter);
1626         ASSERT_EQ("EEP=LIGHT", TestFileIter->second);
1628         // Start with the home title.
1630         TestFileIter = TestFile.HomeTitleList.find(1);
1631         ASSERT_NE(TestFile.HomeTitleList.end(), TestFileIter);
1632         ASSERT_EQ("Lord of Darkness", TestFileIter->second);
1633         
1634         // Check the ALTID section.
1635         
1636         TestFileIter = TestFile.HomeTitleListAltID.find(1);
1637         ASSERT_NE(TestFile.HomeTitleListAltID.end(), TestFileIter);
1638         ASSERT_EQ("30", TestFileIter->second);
1639         
1640         // Check the PID section.
1641         
1642         TestFileIter = TestFile.HomeTitleListPID.find(1);
1643         ASSERT_NE(TestFile.HomeTitleListPID.end(), TestFileIter);
1644         ASSERT_EQ("31", TestFileIter->second);
1645         
1646         // Check the LANGUAGE section.
1647         
1648         TestFileIter = TestFile.HomeTitleListLanguage.find(1);
1649         ASSERT_NE(TestFile.HomeTitleListLanguage.end(), TestFileIter);
1650         ASSERT_EQ("grass/dry", TestFileIter->second);
1651         
1652         // Check the PREF section.
1653         
1654         TestFileIntIter = TestFile.HomeTitleListPref.find(1);
1655         ASSERT_NE(TestFile.HomeTitleListPref.end(), TestFileIntIter);
1656         ASSERT_EQ(32, TestFileIntIter->second);
1657         
1658         // Check the extra tokens.
1659         
1660         TestFileIter = TestFile.HomeTitleListTokens.find(1);
1661         ASSERT_NE(TestFile.HomeTitleListTokens.end(), TestFileIter);
1662         ASSERT_EQ("EEP=DARK", TestFileIter->second);
1663         
1664         // Start with the business title.
1666         TestFileIter = TestFile.BusinessTitleList.find(2);
1667         ASSERT_NE(TestFile.BusinessTitleList.end(), TestFileIter);
1668         ASSERT_EQ("Master of the Light & Darkness", TestFileIter->second);
1669         
1670         // Check the ALTID section.
1671         
1672         TestFileIter = TestFile.BusinessTitleListAltID.find(2);
1673         ASSERT_NE(TestFile.BusinessTitleListAltID.end(), TestFileIter);
1674         ASSERT_EQ("40", TestFileIter->second);
1675         
1676         // Check the PID section.
1677         
1678         TestFileIter = TestFile.BusinessTitleListPID.find(2);
1679         ASSERT_NE(TestFile.BusinessTitleListPID.end(), TestFileIter);
1680         ASSERT_EQ("41", TestFileIter->second);
1681         
1682         // Check the LANGUAGE section.
1683         
1684         TestFileIter = TestFile.BusinessTitleListLanguage.find(2);
1685         ASSERT_NE(TestFile.BusinessTitleListLanguage.end(), TestFileIter);
1686         ASSERT_EQ("moths/eew", TestFileIter->second);
1687         
1688         // Check the PREF section.
1689         
1690         TestFileIntIter = TestFile.BusinessTitleListPref.find(2);
1691         ASSERT_NE(TestFile.BusinessTitleListPref.end(), TestFileIntIter);
1692         ASSERT_EQ(42, TestFileIntIter->second);
1693         
1694         // Check the extra tokens.
1695         
1696         TestFileIter = TestFile.BusinessTitleListTokens.find(2);
1697         ASSERT_NE(TestFile.BusinessTitleListTokens.end(), TestFileIter);
1698         ASSERT_EQ("EEP=BOTH", TestFileIter->second);
1702 TEST(ContactLoad, RoleTests){
1704         ContactDataObject TestFile;
1706         // Check that the vCard 4.0 file loads OK.
1708         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1710         std::map<int,wxString>::iterator TestFileIter;
1711         std::map<int,int>::iterator TestFileIntIter;
1713         // Start with the general role.
1714         
1715         TestFileIter = TestFile.GeneralRoleList.find(0);
1716         ASSERT_NE(TestFile.GeneralRoleList.end(), TestFileIter);
1717         ASSERT_EQ("Ordinary Person", TestFileIter->second);
1718         
1719         // Check the ALTID section.
1720         
1721         TestFileIter = TestFile.GeneralRoleListAltID.find(0);
1722         ASSERT_NE(TestFile.GeneralRoleListAltID.end(), TestFileIter);
1723         ASSERT_EQ("50", TestFileIter->second);
1724         
1725         // Check the PID section.
1726         
1727         TestFileIter = TestFile.GeneralRoleListPID.find(0);
1728         ASSERT_NE(TestFile.GeneralRoleListPID.end(), TestFileIter);
1729         ASSERT_EQ("51", TestFileIter->second);
1730         
1731         // Check the LANGUAGE section.
1732         
1733         TestFileIter = TestFile.GeneralRoleListLanguage.find(0);
1734         ASSERT_NE(TestFile.GeneralRoleListLanguage.end(), TestFileIter);
1735         ASSERT_EQ("en", TestFileIter->second);
1736         
1737         // Check the PREF section.
1738         
1739         TestFileIntIter = TestFile.GeneralRoleListPref.find(0);
1740         ASSERT_NE(TestFile.GeneralRoleListPref.end(), TestFileIntIter);
1741         ASSERT_EQ(52, TestFileIntIter->second);
1742         
1743         // Check the extra tokens.
1744         
1745         TestFileIter = TestFile.GeneralRoleListTokens.find(0);
1746         ASSERT_NE(TestFile.GeneralRoleListTokens.end(), TestFileIter);
1747         ASSERT_EQ("ASTERISK=None", TestFileIter->second);
1749         // Start with the home role.
1751         TestFileIter = TestFile.HomeRoleList.find(1);
1752         ASSERT_NE(TestFile.HomeRoleList.end(), TestFileIter);
1753         ASSERT_EQ("Ordinary Lazy Person", TestFileIter->second);
1754         
1755         // Check the ALTID section.
1756         
1757         TestFileIter = TestFile.HomeRoleListAltID.find(1);
1758         ASSERT_NE(TestFile.HomeRoleListAltID.end(), TestFileIter);
1759         ASSERT_EQ("60", TestFileIter->second);
1760         
1761         // Check the PID section.
1762         
1763         TestFileIter = TestFile.HomeRoleListPID.find(1);
1764         ASSERT_NE(TestFile.HomeRoleListPID.end(), TestFileIter);
1765         ASSERT_EQ("61", TestFileIter->second);
1766         
1767         // Check the LANGUAGE section.
1768         
1769         TestFileIter = TestFile.HomeRoleListLanguage.find(1);
1770         ASSERT_NE(TestFile.HomeRoleListLanguage.end(), TestFileIter);
1771         ASSERT_EQ("en-GB", TestFileIter->second);
1772         
1773         // Check the PREF section.
1774         
1775         TestFileIntIter = TestFile.HomeRoleListPref.find(1);
1776         ASSERT_NE(TestFile.HomeRoleListPref.end(), TestFileIntIter);
1777         ASSERT_EQ(62, TestFileIntIter->second);
1778         
1779         // Check the extra tokens.
1780         
1781         TestFileIter = TestFile.HomeRoleListTokens.find(1);
1782         ASSERT_NE(TestFile.HomeRoleListTokens.end(), TestFileIter);
1783         ASSERT_EQ("SOMEWHERE=There", TestFileIter->second);
1784         
1785         // Start with the business role.
1787         TestFileIter = TestFile.BusinessRoleList.find(2);
1788         ASSERT_NE(TestFile.BusinessRoleList.end(), TestFileIter);
1789         ASSERT_EQ("Company Owner", TestFileIter->second);
1790         
1791         // Check the ALTID section.
1792         
1793         TestFileIter = TestFile.BusinessRoleListAltID.find(2);
1794         ASSERT_NE(TestFile.BusinessRoleListAltID.end(), TestFileIter);
1795         ASSERT_EQ("70", TestFileIter->second);
1796         
1797         // Check the PID section.
1798         
1799         TestFileIter = TestFile.BusinessRoleListPID.find(2);
1800         ASSERT_NE(TestFile.BusinessRoleListPID.end(), TestFileIter);
1801         ASSERT_EQ("71", TestFileIter->second);
1802         
1803         // Check the LANGUAGE section.
1804         
1805         TestFileIter = TestFile.BusinessRoleListLanguage.find(2);
1806         ASSERT_NE(TestFile.BusinessRoleListLanguage.end(), TestFileIter);
1807         ASSERT_EQ("en-AU", TestFileIter->second);
1808         
1809         // Check the PREF section.
1810         
1811         TestFileIntIter = TestFile.BusinessRoleListPref.find(2);
1812         ASSERT_NE(TestFile.BusinessRoleListPref.end(), TestFileIntIter);
1813         ASSERT_EQ(72, TestFileIntIter->second);
1814         
1815         // Check the extra tokens.
1816         
1817         TestFileIter = TestFile.BusinessRoleListTokens.find(2);
1818         ASSERT_NE(TestFile.BusinessRoleListTokens.end(), TestFileIter);
1819         ASSERT_EQ("HERE=Nope", TestFileIter->second);
1823 TEST(ContactLoad, OrganisationTests){
1825         ContactDataObject TestFile;
1827         // Check that the vCard 4.0 file loads OK.
1829         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1831         std::map<int,wxString>::iterator TestFileIter;
1832         std::map<int,int>::iterator TestFileIntIter;
1834         // Start with the general organisation.
1835         
1836         TestFileIter = TestFile.GeneralOrganisationsList.find(0);
1837         ASSERT_NE(TestFile.GeneralOrganisationsList.end(), TestFileIter);
1838         ASSERT_EQ("Ordinary Organisation", TestFileIter->second);
1839         
1840         // Check the SORT-AS section.
1842         TestFileIter = TestFile.GeneralOrganisationsListSortAs.find(0);
1843         ASSERT_NE(TestFile.GeneralOrganisationsListSortAs.end(), TestFileIter);
1844         ASSERT_EQ("Organisation, Ordinary", TestFileIter->second);
1845         
1846         // Check the ALTID section.
1847         
1848         TestFileIter = TestFile.GeneralOrganisationsListAltID.find(0);
1849         ASSERT_NE(TestFile.GeneralOrganisationsListAltID.end(), TestFileIter);
1850         ASSERT_EQ("50", TestFileIter->second);
1851         
1852         // Check the PID section.
1853         
1854         TestFileIter = TestFile.GeneralOrganisationsListPID.find(0);
1855         ASSERT_NE(TestFile.GeneralOrganisationsListPID.end(), TestFileIter);
1856         ASSERT_EQ("51", TestFileIter->second);
1857         
1858         // Check the LANGUAGE section.
1859         
1860         TestFileIter = TestFile.GeneralOrganisationsListLanguage.find(0);
1861         ASSERT_NE(TestFile.GeneralOrganisationsListLanguage.end(), TestFileIter);
1862         ASSERT_EQ("en", TestFileIter->second);
1863         
1864         // Check the PREF section.
1865         
1866         TestFileIntIter = TestFile.GeneralOrganisationsListPref.find(0);
1867         ASSERT_NE(TestFile.GeneralOrganisationsListPref.end(), TestFileIntIter);
1868         ASSERT_EQ(52, TestFileIntIter->second);
1869         
1870         // Check the extra tokens.
1871         
1872         TestFileIter = TestFile.GeneralOrganisationsListTokens.find(0);
1873         ASSERT_NE(TestFile.GeneralOrganisationsListTokens.end(), TestFileIter);
1874         ASSERT_EQ("ASTERISK=None", TestFileIter->second);
1876         // Start with the home Organisation.
1878         TestFileIter = TestFile.HomeOrganisationsList.find(1);
1879         ASSERT_NE(TestFile.HomeOrganisationsList.end(), TestFileIter);
1880         ASSERT_EQ("Ordinary Lazy Person", TestFileIter->second);
1881         
1882         // Check the SORT-AS section.
1883         
1884         TestFileIter = TestFile.HomeOrganisationsListSortAs.find(1);
1885         ASSERT_NE(TestFile.HomeOrganisationsListSortAs.end(), TestFileIter);
1886         ASSERT_EQ("Person, Ordinary Lazy", TestFileIter->second);
1887         
1888         // Check the ALTID section.
1889         
1890         TestFileIter = TestFile.HomeOrganisationsListAltID.find(1);
1891         ASSERT_NE(TestFile.HomeOrganisationsListAltID.end(), TestFileIter);
1892         ASSERT_EQ("60", TestFileIter->second);
1893         
1894         // Check the PID section.
1895         
1896         TestFileIter = TestFile.HomeOrganisationsListPID.find(1);
1897         ASSERT_NE(TestFile.HomeOrganisationsListPID.end(), TestFileIter);
1898         ASSERT_EQ("61", TestFileIter->second);
1899         
1900         // Check the LANGUAGE section.
1901         
1902         TestFileIter = TestFile.HomeOrganisationsListLanguage.find(1);
1903         ASSERT_NE(TestFile.HomeOrganisationsListLanguage.end(), TestFileIter);
1904         ASSERT_EQ("en-GB", TestFileIter->second);
1905         
1906         // Check the PREF section.
1907         
1908         TestFileIntIter = TestFile.HomeOrganisationsListPref.find(1);
1909         ASSERT_NE(TestFile.HomeOrganisationsListPref.end(), TestFileIntIter);
1910         ASSERT_EQ(62, TestFileIntIter->second);
1911         
1912         // Check the extra tokens.
1913         
1914         TestFileIter = TestFile.HomeOrganisationsListTokens.find(1);
1915         ASSERT_NE(TestFile.HomeOrganisationsListTokens.end(), TestFileIter);
1916         ASSERT_EQ("SOMEWHERE=There", TestFileIter->second);
1917         
1918         // Start with the business Organisation.
1920         TestFileIter = TestFile.BusinessOrganisationsList.find(2);
1921         ASSERT_NE(TestFile.BusinessOrganisationsList.end(), TestFileIter);
1922         ASSERT_EQ("Company Owner", TestFileIter->second);
1923         
1924         // Check the SORT-AS section.
1925         
1926         TestFileIter = TestFile.BusinessOrganisationsListSortAs.find(2);
1927         ASSERT_NE(TestFile.BusinessOrganisationsListSortAs.end(), TestFileIter);
1928         ASSERT_EQ("Owner, Company", TestFileIter->second);
1929         
1930         // Check the ALTID section.
1931         
1932         TestFileIter = TestFile.BusinessOrganisationsListAltID.find(2);
1933         ASSERT_NE(TestFile.BusinessOrganisationsListAltID.end(), TestFileIter);
1934         ASSERT_EQ("70", TestFileIter->second);
1935         
1936         // Check the PID section.
1937         
1938         TestFileIter = TestFile.BusinessOrganisationsListPID.find(2);
1939         ASSERT_NE(TestFile.BusinessOrganisationsListPID.end(), TestFileIter);
1940         ASSERT_EQ("71", TestFileIter->second);
1941         
1942         // Check the LANGUAGE section.
1943         
1944         TestFileIter = TestFile.BusinessOrganisationsListLanguage.find(2);
1945         ASSERT_NE(TestFile.BusinessOrganisationsListLanguage.end(), TestFileIter);
1946         ASSERT_EQ("en-AU", TestFileIter->second);
1947         
1948         // Check the PREF section.
1949         
1950         TestFileIntIter = TestFile.BusinessOrganisationsListPref.find(2);
1951         ASSERT_NE(TestFile.BusinessOrganisationsListPref.end(), TestFileIntIter);
1952         ASSERT_EQ(72, TestFileIntIter->second);
1953         
1954         // Check the extra tokens.
1955         
1956         TestFileIter = TestFile.BusinessOrganisationsListTokens.find(2);
1957         ASSERT_NE(TestFile.BusinessOrganisationsListTokens.end(), TestFileIter);
1958         ASSERT_EQ("HERE=Nope", TestFileIter->second);
1962 TEST(ContactLoad, NoteTests){
1964         ContactDataObject TestFile;
1966         // Check that the vCard 4.0 file loads OK.
1968         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
1970         std::map<int,wxString>::iterator TestFileIter;
1971         std::map<int,int>::iterator TestFileIntIter;
1972         
1973         // Start with the general note.
1974         
1975         TestFileIter = TestFile.GeneralNoteList.find(0);
1976         ASSERT_NE(TestFile.GeneralNoteList.end(), TestFileIter);
1977         ASSERT_EQ("Note\n\nLine 3\nLine 4\nLine 5", TestFileIter->second);
1978         
1979         // Check the ALTID section.
1980         
1981         TestFileIter = TestFile.GeneralNoteListAltID.find(0);
1982         ASSERT_NE(TestFile.GeneralNoteListAltID.end(), TestFileIter);
1983         ASSERT_EQ("90", TestFileIter->second);
1984         
1985         // Check the PID section.
1986         
1987         TestFileIter = TestFile.GeneralNoteListPID.find(0);
1988         ASSERT_NE(TestFile.GeneralNoteListPID.end(), TestFileIter);
1989         ASSERT_EQ("91", TestFileIter->second);
1990         
1991         // Check the LANGUAGE section.
1992         
1993         TestFileIter = TestFile.GeneralNoteListLanguage.find(0);
1994         ASSERT_NE(TestFile.GeneralNoteListLanguage.end(), TestFileIter);
1995         ASSERT_EQ("en", TestFileIter->second);
1996         
1997         // Check the PREF section.
1998         
1999         TestFileIntIter = TestFile.GeneralNoteListPref.find(0);
2000         ASSERT_NE(TestFile.GeneralNoteListPref.end(), TestFileIntIter);
2001         ASSERT_EQ(92, TestFileIntIter->second);
2002         
2003         // Check the extra tokens.
2004         
2005         TestFileIter = TestFile.GeneralNoteListTokens.find(0);
2006         ASSERT_NE(TestFile.GeneralNoteListTokens.end(), TestFileIter);
2007         ASSERT_EQ("WOO=WOOP", TestFileIter->second);
2009         // Start with the home note.
2010         
2011         TestFileIter = TestFile.HomeNoteList.find(1);
2012         ASSERT_NE(TestFile.HomeNoteList.end(), TestFileIter);
2013         ASSERT_EQ("Note\n\n\n\nLine 5\nLine 6\nLine 7", TestFileIter->second);
2014         
2015         // Check the ALTID section.
2016         
2017         TestFileIter = TestFile.HomeNoteListAltID.find(1);
2018         ASSERT_NE(TestFile.HomeNoteListAltID.end(), TestFileIter);
2019         ASSERT_EQ("80", TestFileIter->second);
2020         
2021         // Check the PID section.
2022         
2023         TestFileIter = TestFile.HomeNoteListPID.find(1);
2024         ASSERT_NE(TestFile.HomeNoteListPID.end(), TestFileIter);
2025         ASSERT_EQ("81", TestFileIter->second);
2026         
2027         // Check the LANGUAGE section.
2028         
2029         TestFileIter = TestFile.HomeNoteListLanguage.find(1);
2030         ASSERT_NE(TestFile.HomeNoteListLanguage.end(), TestFileIter);
2031         ASSERT_EQ("kw", TestFileIter->second);
2032         
2033         // Check the PREF section.
2034         
2035         TestFileIntIter = TestFile.HomeNoteListPref.find(1);
2036         ASSERT_NE(TestFile.HomeNoteListPref.end(), TestFileIntIter);
2037         ASSERT_EQ(82, TestFileIntIter->second);
2038         
2039         // Check the extra tokens.
2040         
2041         TestFileIter = TestFile.HomeNoteListTokens.find(1);
2042         ASSERT_NE(TestFile.HomeNoteListTokens.end(), TestFileIter);
2043         ASSERT_EQ("MOO=MEEP", TestFileIter->second);
2045         // Start with the business note.
2046         
2047         TestFileIter = TestFile.BusinessNoteList.find(2);
2048         ASSERT_NE(TestFile.BusinessNoteList.end(), TestFileIter);
2049         ASSERT_EQ("Note\n\n\n\nLine 8\nLine 9\nLine 10", TestFileIter->second);
2050         
2051         // Check the ALTID section.
2052         
2053         TestFileIter = TestFile.BusinessNoteListAltID.find(2);
2054         ASSERT_NE(TestFile.BusinessNoteListAltID.end(), TestFileIter);
2055         ASSERT_EQ("70", TestFileIter->second);
2056         
2057         // Check the PID section.
2058         
2059         TestFileIter = TestFile.BusinessNoteListPID.find(2);
2060         ASSERT_NE(TestFile.BusinessNoteListPID.end(), TestFileIter);
2061         ASSERT_EQ("71", TestFileIter->second);
2062         
2063         // Check the LANGUAGE section.
2064         
2065         TestFileIter = TestFile.BusinessNoteListLanguage.find(2);
2066         ASSERT_NE(TestFile.BusinessNoteListLanguage.end(), TestFileIter);
2067         ASSERT_EQ("fr", TestFileIter->second);
2068         
2069         // Check the PREF section.
2070         
2071         TestFileIntIter = TestFile.BusinessNoteListPref.find(2);
2072         ASSERT_NE(TestFile.BusinessNoteListPref.end(), TestFileIntIter);
2073         ASSERT_EQ(72, TestFileIntIter->second);
2074         
2075         // Check the extra tokens.
2076         
2077         TestFileIter = TestFile.BusinessNoteListTokens.find(2);
2078         ASSERT_NE(TestFile.BusinessNoteListTokens.end(), TestFileIter);
2079         ASSERT_EQ("BOING=BOOP", TestFileIter->second);
2083 TEST(ContactLoad, CategoryTests){
2085         ContactDataObject TestFile;
2087         // Check that the vCard 4.0 file loads OK.
2089         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
2091         std::map<int,wxString>::iterator TestFileIter;
2092         std::map<int,int>::iterator TestFileIntIter;    
2094         // Start with the first category.
2095         
2096         TestFileIter = TestFile.CategoriesList.find(0);
2097         ASSERT_NE(TestFile.CategoriesList.end(), TestFileIter);
2098         ASSERT_EQ("Category One", TestFileIter->second);
2099         
2100         // Check the TYPE section.
2101         
2102         TestFileIter = TestFile.CategoriesListType.find(0);
2103         ASSERT_EQ(TestFile.CategoriesListType.end(), TestFileIter);
2104         
2105         // Check the ALTID section.
2106         
2107         TestFileIter = TestFile.CategoriesListAltID.find(0);
2108         ASSERT_NE(TestFile.CategoriesListAltID.end(), TestFileIter);
2109         ASSERT_EQ("40", TestFileIter->second);
2110         
2111         // Check the PID section.
2112         
2113         TestFileIter = TestFile.CategoriesListPID.find(0);
2114         ASSERT_NE(TestFile.CategoriesListPID.end(), TestFileIter);
2115         ASSERT_EQ("41", TestFileIter->second);
2116         
2117         // Check the LANGUAGE section.
2118         
2119         TestFileIter = TestFile.CategoriesListLanguage.find(0);
2120         ASSERT_NE(TestFile.CategoriesListLanguage.end(), TestFileIter);
2121         ASSERT_EQ("en", TestFileIter->second);
2122         
2123         // Check the PREF section.
2124         
2125         TestFileIntIter = TestFile.CategoriesListPref.find(0);
2126         ASSERT_NE(TestFile.CategoriesListPref.end(), TestFileIntIter);
2127         ASSERT_EQ(42, TestFileIntIter->second);
2128         
2129         // Check the extra tokens.
2130         
2131         TestFileIter = TestFile.CategoriesListTokens.find(0);
2132         ASSERT_NE(TestFile.CategoriesListTokens.end(), TestFileIter);
2133         ASSERT_EQ("CAT=TAC", TestFileIter->second);
2134         
2135         // Start with the second & third category.
2136         // (Category Two, Category Three).
2137         
2138         TestFileIter = TestFile.CategoriesList.find(1);
2139         ASSERT_NE(TestFile.CategoriesList.end(), TestFileIter);
2140         ASSERT_EQ("Category Two", TestFileIter->second);
2141         
2142         TestFileIter = TestFile.CategoriesList.find(2);
2143         ASSERT_NE(TestFile.CategoriesList.end(), TestFileIter);
2144         ASSERT_EQ("Category Three", TestFileIter->second);
2146         // Check the TYPE section.
2147         
2148         TestFileIter = TestFile.CategoriesListType.find(1);
2149         ASSERT_NE(TestFile.CategoriesListType.end(), TestFileIter);
2150         ASSERT_EQ("home", TestFileIter->second);
2152         TestFileIter = TestFile.CategoriesListType.find(2);
2153         ASSERT_NE(TestFile.CategoriesListType.end(), TestFileIter);
2154         ASSERT_EQ("home", TestFileIter->second);
2155         
2156         // Check the ALTID section.
2157         
2158         TestFileIter = TestFile.CategoriesListAltID.find(1);
2159         ASSERT_NE(TestFile.CategoriesListAltID.end(), TestFileIter);
2160         ASSERT_EQ("44", TestFileIter->second);
2162         TestFileIter = TestFile.CategoriesListAltID.find(2);
2163         ASSERT_NE(TestFile.CategoriesListAltID.end(), TestFileIter);
2164         ASSERT_EQ("44", TestFileIter->second);
2165         
2166         // Check the PID section.
2167         
2168         TestFileIter = TestFile.CategoriesListPID.find(1);
2169         ASSERT_NE(TestFile.CategoriesListPID.end(), TestFileIter);
2170         ASSERT_EQ("46", TestFileIter->second);
2172         TestFileIter = TestFile.CategoriesListPID.find(2);
2173         ASSERT_NE(TestFile.CategoriesListPID.end(), TestFileIter);
2174         ASSERT_EQ("46", TestFileIter->second);
2175         
2176         // Check the LANGUAGE section.
2177         
2178         TestFileIter = TestFile.CategoriesListLanguage.find(1);
2179         ASSERT_NE(TestFile.CategoriesListLanguage.end(), TestFileIter);
2180         ASSERT_EQ("kw", TestFileIter->second);
2181         
2182         TestFileIter = TestFile.CategoriesListLanguage.find(2);
2183         ASSERT_NE(TestFile.CategoriesListLanguage.end(), TestFileIter);
2184         ASSERT_EQ("kw", TestFileIter->second);
2185         
2186         // Check the PREF section.
2187         
2188         TestFileIntIter = TestFile.CategoriesListPref.find(1);
2189         ASSERT_NE(TestFile.CategoriesListPref.end(), TestFileIntIter);
2190         ASSERT_EQ(48, TestFileIntIter->second);
2191         
2192         TestFileIntIter = TestFile.CategoriesListPref.find(2);
2193         ASSERT_NE(TestFile.CategoriesListPref.end(), TestFileIntIter);
2194         ASSERT_EQ(48, TestFileIntIter->second);
2195         
2196         // Check the extra tokens.
2197         
2198         TestFileIter = TestFile.CategoriesListTokens.find(1);
2199         ASSERT_NE(TestFile.CategoriesListTokens.end(), TestFileIter);
2200         ASSERT_EQ("TAC=CAT", TestFileIter->second);
2202         TestFileIter = TestFile.CategoriesListTokens.find(2);
2203         ASSERT_NE(TestFile.CategoriesListTokens.end(), TestFileIter);
2204         ASSERT_EQ("TAC=CAT", TestFileIter->second);
2206         // Start with the third, fourth & fifth category.
2207         // (Category Three,Category Four,Category Five).
2208         
2209         TestFileIter = TestFile.CategoriesList.find(3);
2210         ASSERT_NE(TestFile.CategoriesList.end(), TestFileIter);
2211         ASSERT_EQ("Category Four", TestFileIter->second.ToStdString());
2212         
2213         TestFileIter = TestFile.CategoriesList.find(4);
2214         ASSERT_NE(TestFile.CategoriesList.end(), TestFileIter);
2215         ASSERT_EQ("Category Five", TestFileIter->second.ToStdString());
2217         TestFileIter = TestFile.CategoriesList.find(5);
2218         ASSERT_NE(TestFile.CategoriesList.end(), TestFileIter);
2219         ASSERT_EQ("Category Six", TestFileIter->second);
2221         // Check the TYPE section.
2222         
2223         TestFileIter = TestFile.CategoriesListType.find(3);
2224         ASSERT_NE(TestFile.CategoriesListType.end(), TestFileIter);
2225         ASSERT_EQ("work", TestFileIter->second);
2227         TestFileIter = TestFile.CategoriesListType.find(4);
2228         ASSERT_NE(TestFile.CategoriesListType.end(), TestFileIter);
2229         ASSERT_EQ("work", TestFileIter->second);
2230         
2231         TestFileIter = TestFile.CategoriesListType.find(5);
2232         ASSERT_NE(TestFile.CategoriesListType.end(), TestFileIter);
2233         ASSERT_EQ("work", TestFileIter->second);
2234         
2235         // Check the ALTID section.
2236         
2237         TestFileIter = TestFile.CategoriesListAltID.find(3);
2238         ASSERT_NE(TestFile.CategoriesListAltID.end(), TestFileIter);
2239         ASSERT_EQ("84", TestFileIter->second);
2241         TestFileIter = TestFile.CategoriesListAltID.find(4);
2242         ASSERT_NE(TestFile.CategoriesListAltID.end(), TestFileIter);
2243         ASSERT_EQ("84", TestFileIter->second);
2245         TestFileIter = TestFile.CategoriesListAltID.find(5);
2246         ASSERT_NE(TestFile.CategoriesListAltID.end(), TestFileIter);
2247         ASSERT_EQ("84", TestFileIter->second);
2248         
2249         // Check the PID section.
2250         
2251         TestFileIter = TestFile.CategoriesListPID.find(3);
2252         ASSERT_NE(TestFile.CategoriesListPID.end(), TestFileIter);
2253         ASSERT_EQ("86", TestFileIter->second);
2255         TestFileIter = TestFile.CategoriesListPID.find(4);
2256         ASSERT_NE(TestFile.CategoriesListPID.end(), TestFileIter);
2257         ASSERT_EQ("86", TestFileIter->second);
2259         TestFileIter = TestFile.CategoriesListPID.find(5);
2260         ASSERT_NE(TestFile.CategoriesListPID.end(), TestFileIter);
2261         ASSERT_EQ("86", TestFileIter->second);
2262         
2263         // Check the LANGUAGE section.
2264         
2265         TestFileIter = TestFile.CategoriesListLanguage.find(3);
2266         ASSERT_NE(TestFile.CategoriesListLanguage.end(), TestFileIter);
2267         ASSERT_EQ("kw", TestFileIter->second);
2268         
2269         TestFileIter = TestFile.CategoriesListLanguage.find(4);
2270         ASSERT_NE(TestFile.CategoriesListLanguage.end(), TestFileIter);
2271         ASSERT_EQ("kw", TestFileIter->second);
2272         
2273         TestFileIter = TestFile.CategoriesListLanguage.find(5);
2274         ASSERT_NE(TestFile.CategoriesListLanguage.end(), TestFileIter);
2275         ASSERT_EQ("kw", TestFileIter->second);
2276         
2277         // Check the PREF section.
2278         
2279         TestFileIntIter = TestFile.CategoriesListPref.find(3);
2280         ASSERT_NE(TestFile.CategoriesListPref.end(), TestFileIntIter);
2281         ASSERT_EQ(88, TestFileIntIter->second);
2282         
2283         TestFileIntIter = TestFile.CategoriesListPref.find(4);
2284         ASSERT_NE(TestFile.CategoriesListPref.end(), TestFileIntIter);
2285         ASSERT_EQ(88, TestFileIntIter->second);
2286         
2287         TestFileIntIter = TestFile.CategoriesListPref.find(5);
2288         ASSERT_NE(TestFile.CategoriesListPref.end(), TestFileIntIter);
2289         ASSERT_EQ(88, TestFileIntIter->second);
2290         
2291         // Check the extra tokens.
2292         
2293         TestFileIter = TestFile.CategoriesListTokens.find(3);
2294         ASSERT_NE(TestFile.CategoriesListTokens.end(), TestFileIter);
2295         ASSERT_EQ("AAA=BBB", TestFileIter->second);
2297         TestFileIter = TestFile.CategoriesListTokens.find(4);
2298         ASSERT_NE(TestFile.CategoriesListTokens.end(), TestFileIter);
2299         ASSERT_EQ("AAA=BBB", TestFileIter->second);
2301         TestFileIter = TestFile.CategoriesListTokens.find(4);
2302         ASSERT_NE(TestFile.CategoriesListTokens.end(), TestFileIter);
2303         ASSERT_EQ("AAA=BBB", TestFileIter->second);
2307 TEST(ContactLoad, PhotoTests){
2309         ContactDataObject TestFile;
2311         // Check that the vCard 4.0 file loads OK.
2313         ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf"));
2315         std::map<int,std::string>::iterator TestStrIter;
2316         std::map<int,wxString>::iterator TestFileIter;
2317         std::map<int,int>::iterator TestFileIntIter;    
2319         // Start with the first photo.
2320         
2321         TestStrIter = TestFile.PicturesList.find(0);
2322         ASSERT_NE(TestFile.PicturesList.end(), TestStrIter);
2323         ASSERT_EQ("iVBORw0KGgoAAAANSUhEUgAAABEAAAAKCAIAAADdHiL1AAAAJUlEQVQoz2NkwAb+//8PYTAyMmLKMjGQDuilhxHudBrbM8zCDQCxHQkPeaUvawAAAABJRU5ErkJggg==", 
2324                 TestStrIter->second);
2326         // Check that it has the correct encoding.
2327         
2328         TestFileIter = TestFile.PicturesListPicEncType.find(0);
2329         ASSERT_NE(TestFile.PicturesListPicEncType.end(), TestFileIter);
2330         ASSERT_EQ("base64", TestFileIter->second);
2331         
2332         // Check that it has the correct image type.
2334         TestFileIter = TestFile.PicturesListPictureType.find(0);
2335         ASSERT_NE(TestFile.PicturesListPictureType.end(), TestFileIter);
2336         ASSERT_EQ("image/png", TestFileIter->second);
2337         
2338         // Check the ALTID section.
2339         
2340         TestFileIter = TestFile.PicturesListAltID.find(0);
2341         ASSERT_NE(TestFile.PicturesListAltID.end(), TestFileIter);
2342         ASSERT_EQ("70", TestFileIter->second);
2343         
2344         // Check the PID section.
2345         
2346         TestFileIter = TestFile.PicturesListPID.find(0);
2347         ASSERT_NE(TestFile.PicturesListPID.end(), TestFileIter);
2348         ASSERT_EQ("71", TestFileIter->second);
2349         
2350         // Check the MEDIATYPE section.
2351         
2352         TestFileIter = TestFile.PicturesListMediatype.find(0);
2353         ASSERT_NE(TestFile.PicturesListMediatype.end(), TestFileIter);
2354         ASSERT_EQ("image/png", TestFileIter->second);
2355         
2356         // Check the PREF section.
2357         
2358         TestFileIntIter = TestFile.PicturesListPref.find(0);
2359         ASSERT_NE(TestFile.PicturesListPref.end(), TestFileIntIter);
2360         ASSERT_EQ(72, TestFileIntIter->second);
2361         
2362         // Check the extra tokens.
2363         
2364         TestFileIter = TestFile.PicturesListTokens.find(0);
2365         ASSERT_NE(TestFile.PicturesListTokens.end(), TestFileIter);
2366         ASSERT_EQ("MEEP=MOO", TestFileIter->second);
2367         
2368         // Start with the second photo.
2369         
2370         TestStrIter = TestFile.PicturesList.find(1);
2371         ASSERT_NE(TestFile.PicturesList.end(), TestStrIter);
2372         ASSERT_EQ("iVBORw0KGgoAAAANSUhEUgAAABEAAAAKCAIAAADdHiL1AAAAHklEQVQoz2NkYPjPgAr+owkwMqIpYGIgHYzqGdx6AAKNAxMN5P6+AAAAAElFTkSuQmCC", 
2373                 TestStrIter->second);
2375         // Check that it has the correct encoding.
2376         
2377         TestFileIter = TestFile.PicturesListPicEncType.find(1);
2378         ASSERT_NE(TestFile.PicturesListPicEncType.end(), TestFileIter);
2379         ASSERT_EQ("base64", TestFileIter->second);
2380         
2381         // Check that it has the correct image type.
2383         TestFileIter = TestFile.PicturesListPictureType.find(1);
2384         ASSERT_NE(TestFile.PicturesListPictureType.end(), TestFileIter);
2385         ASSERT_EQ("image/png", TestFileIter->second);
2386         
2387         // Check the ALTID section.
2388         
2389         TestFileIter = TestFile.PicturesListAltID.find(1);
2390         ASSERT_NE(TestFile.PicturesListAltID.end(), TestFileIter);
2391         ASSERT_EQ("20", TestFileIter->second);
2392         
2393         // Check the PID section.
2394         
2395         TestFileIter = TestFile.PicturesListPID.find(1);
2396         ASSERT_NE(TestFile.PicturesListPID.end(), TestFileIter);
2397         ASSERT_EQ("21", TestFileIter->second);
2398         
2399         // Check the MEDIATYPE section.
2400         
2401         TestFileIter = TestFile.PicturesListMediatype.find(1);
2402         ASSERT_NE(TestFile.PicturesListMediatype.end(), TestFileIter);
2403         ASSERT_EQ("image/png", TestFileIter->second);
2404         
2405         // Check the PREF section.
2406         
2407         TestFileIntIter = TestFile.PicturesListPref.find(1);
2408         ASSERT_NE(TestFile.PicturesListPref.end(), TestFileIntIter);
2409         ASSERT_EQ(22, TestFileIntIter->second);
2410         
2411         // Check the extra tokens.
2412         
2413         TestFileIter = TestFile.PicturesListTokens.find(1);
2414         ASSERT_NE(TestFile.PicturesListTokens.end(), TestFileIter);
2415         ASSERT_EQ("BEEP=BOOP", TestFileIter->second);
2417         // Start with the second photo.
2418         
2419         TestStrIter = TestFile.PicturesList.find(2);
2420         ASSERT_NE(TestFile.PicturesList.end(), TestStrIter);
2421         ASSERT_EQ("iVBORw0KGgoAAAANSUhEUgAAABEAAAAKCAIAAADdHiL1AAAAIElEQVQoz2MUm53EgApepsxF4XfaoylgYiAdjOoZ3HoAeuQD2WdxRzcAAAAASUVORK5CYII=", 
2422                 TestStrIter->second);
2424         // Check that it has the correct encoding.
2425         
2426         TestFileIter = TestFile.PicturesListPicEncType.find(2);
2427         ASSERT_NE(TestFile.PicturesListPicEncType.end(), TestFileIter);
2428         ASSERT_EQ("base64", TestFileIter->second);
2429         
2430         // Check that it has the correct image type.
2432         TestFileIter = TestFile.PicturesListPictureType.find(2);
2433         ASSERT_NE(TestFile.PicturesListPictureType.end(), TestFileIter);
2434         ASSERT_EQ("image/png", TestFileIter->second);
2435         
2436         // Check the ALTID section.
2437         
2438         TestFileIter = TestFile.PicturesListAltID.find(2);
2439         ASSERT_NE(TestFile.PicturesListAltID.end(), TestFileIter);
2440         ASSERT_EQ("90", TestFileIter->second);
2441         
2442         // Check the PID section.
2443         
2444         TestFileIter = TestFile.PicturesListPID.find(2);
2445         ASSERT_NE(TestFile.PicturesListPID.end(), TestFileIter);
2446         ASSERT_EQ("91", TestFileIter->second);
2447         
2448         // Check the MEDIATYPE section.
2449         
2450         TestFileIter = TestFile.PicturesListMediatype.find(2);
2451         ASSERT_NE(TestFile.PicturesListMediatype.end(), TestFileIter);
2452         ASSERT_EQ("image/png", TestFileIter->second);
2453         
2454         // Check the PREF section.
2455         
2456         TestFileIntIter = TestFile.PicturesListPref.find(2);
2457         ASSERT_NE(TestFile.PicturesListPref.end(), TestFileIntIter);
2458         ASSERT_EQ(92, TestFileIntIter->second);
2459         
2460         // Check the extra tokens.
2461         
2462         TestFileIter = TestFile.PicturesListTokens.find(2);
2463         ASSERT_NE(TestFile.PicturesListTokens.end(), TestFileIter);
2464         ASSERT_EQ("PHOTO=YUP", TestFileIter->second);
2465         
2468 // TODO: Add tests for the Contact Loading process.
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