From a45c3a46e4e37da415a8b8da2aaabe6a4abc4551 Mon Sep 17 00:00:00 2001 From: Steve Brokenshire Date: Sun, 27 Dec 2015 00:28:33 +0000 Subject: [PATCH] Added source code, headers and unit testing for the KEY vCard property for ContactDataObject. --- source/contacteditor/ContactDataObject.cpp | 235 +++++++++++++++++ source/contacteditor/ContactDataObject.h | 1 + source/tests/LoadCheck-Load4.vcf | 119 +++++++++ source/tests/xestiaab_contactload.h | 279 ++++++++++++++++++++- 4 files changed, 631 insertions(+), 3 deletions(-) diff --git a/source/contacteditor/ContactDataObject.cpp b/source/contacteditor/ContactDataObject.cpp index 8bddc03..7531af0 100644 --- a/source/contacteditor/ContactDataObject.cpp +++ b/source/contacteditor/ContactDataObject.cpp @@ -103,6 +103,7 @@ ContactLoadStatus ContactDataObject::LoadFile(wxString Filename){ int CalendarCount = 0; int CalendarAddressCount = 0; int FreeBusyAddressCount = 0; + int KeyCount = 0; wxString ContactLine; wxString PropertyLine; wxString PropertySeg1; @@ -375,6 +376,13 @@ ContactLoadStatus ContactDataObject::LoadFile(wxString Filename){ ProcessCalendarFreeBusy(PropertySeg1, PropertySeg2, &FreeBusyAddressCount); FreeBusyAddressCount++; + } else if (Property == wxT("KEY")){ + + // See frmContactEditor-LoadKey.cpp + + ProcessKey(PropertySeg1, PropertySeg2, &KeyCount); + KeyCount++; + } } @@ -5201,6 +5209,233 @@ void ContactDataObject::ProcessCalendarFreeBusy(wxString PropertySeg1, wxString } +void ContactDataObject::ProcessKey(wxString PropertySeg1, wxString PropertySeg2, int *KeyCount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 5; + int intPref = 0; + int intType = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 4; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 4; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + if (PropertyName == wxT("ALTID")){ + + KeyListAltID.erase(*KeyCount); + KeyListAltID.insert(std::make_pair(*KeyCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + KeyListPID.erase(*KeyCount); + KeyListPID.insert(std::make_pair(*KeyCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + KeyListPref.erase(*KeyCount); + KeyListPref.insert(std::make_pair(*KeyCount, PriorityNumber)); + + } + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + for (int i = 0; i <= intPropertyLen; i++){ + + intSplitSize++; + + if (PropertySeg2.Mid(i, 1) == wxT(";") && PropertySeg2.Mid((i - 1), 1) != wxT("\\")){ + + intSplitsFound++; + SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1))); + + if (intSplitsFound == 6){ + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + break; + + } else { + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + + } + + intSplitSize = 0; + + } + + } + + wxString wxSKeyURI; + wxString wxSKeyMIME; + wxString wxSKeyEncoding; + wxString wxSKeyData; + std::string base64enc; + + if (intSplitsFound == 0){ + + } else { + + std::map::iterator striter; + + striter = SplitLength.find(1); + + wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":")); + + while (wSTDataType.HasMoreTokens() == TRUE){ + + wxSKeyURI = wSTDataType.GetNextToken(); + wxSKeyMIME = wSTDataType.GetNextToken(); + break; + + } + + if (wxSKeyURI == wxT("data")){ + + wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(",")); + + while (wSTDataInfo.HasMoreTokens() == TRUE){ + + wxSKeyEncoding = wSTDataInfo.GetNextToken(); + wxSKeyData = wSTDataInfo.GetNextToken(); + break; + + } + + } + + } + + // Add the data to the General/Home/Work address variables. + + if (wxSKeyURI == wxT("data")){ + + KeyListDataEncType.erase(*KeyCount); + KeyListKeyType.erase(*KeyCount); + KeyListDataEncType.insert(std::make_pair(*KeyCount, wxSKeyEncoding)); + KeyListKeyType.insert(std::make_pair(*KeyCount, TRUE)); + + KeyList.erase(*KeyCount); + KeyList.insert(std::make_pair(*KeyCount, wxSKeyData)); + + } else { + + KeyList.erase(*KeyCount); + KeyList.insert(std::make_pair(*KeyCount, PropertySeg2)); + + } + + KeyListDataType.insert(std::make_pair(*KeyCount, wxSKeyMIME)); + + switch (PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + KeyListType.insert(std::make_pair(*KeyCount, wxT("home"))); + break; + case PROPERTY_WORK: + KeyListType.insert(std::make_pair(*KeyCount, wxT("work"))); + break; + } + + if (!PropertyTokens.IsEmpty()){ + + KeyListTokens.insert(std::make_pair(*KeyCount, PropertyTokens)); + + } + +} + void SplitValues(wxString *PropertyLine, std::map *SplitPoints, std::map *SplitLength, diff --git a/source/contacteditor/ContactDataObject.h b/source/contacteditor/ContactDataObject.h index ccdc5db..8cb40d5 100644 --- a/source/contacteditor/ContactDataObject.h +++ b/source/contacteditor/ContactDataObject.h @@ -82,6 +82,7 @@ class ContactDataObject{ void ProcessCalendarURI(wxString PropertySeg1, wxString PropertySeg2, int *CalAdrCount); void ProcessCalendarAddressURI(wxString PropertySeg1, wxString PropertySeg2, int *CalAdrURICount); void ProcessCalendarFreeBusy(wxString PropertySeg1, wxString PropertySeg2, int *FreeBusyAddressCount); + void ProcessKey(wxString PropertySeg1, wxString PropertySeg2, int *KeyCount); public: diff --git a/source/tests/LoadCheck-Load4.vcf b/source/tests/LoadCheck-Load4.vcf index 180475f..e43f044 100644 --- a/source/tests/LoadCheck-Load4.vcf +++ b/source/tests/LoadCheck-Load4.vcf @@ -504,4 +504,123 @@ FBURL;TYPE=home;ALTID=84;PID=81;PREF=82;MEDIATYPE=text/dryplain;STATUS=FREE: http://example.com/home/freebusy FBURL;TYPE=work;ALTID=94;PID=91;PREF=92;MEDIATYPE=text/stillwetink;STATUS=BU SY:http://example.com/business/freebusy +KEY;ALTID=54;PID=51;PREF=52;KEYS=JUSTONE:data:application/pgp-keys;base64,LS + 0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9 + DSy0tLS0tClZlcnNpb246IEdudVBHIHYyCgptUU11QkZaL0JyWVJDQUN2cTNueUl4dXJPOFovMH + cwQWdkeUdhN1d2cWRpdk5OWVdEM3dmZkgrSi83R2o1dkNOClJwWFQ5TVI4SEdmR0Jwai9hc0Nsa + jltbjhnRENMcVZJaXFybXZXK3dHbnhBVWxFU05VT201cEx6NTRwTzBzOW0KYzJ5SDRkYWVYR3pR + TXFLUit2TDZaTWpDc0pSRk1UWVAzSDlTMlBFaHFFMXl4TnBpRi9ZTS9jNGNOYmU5bEZsTgpKMnJ + 2QzA2bzZuMFlzYWtuZTk3bWlndGNyTUpZVDljVDF4cjB5YUhDekcrVXZqOG1RMnlGT0tpVEpxeG + lCVEdhClRMWjJjTFBVZVFFbnpjSWNwNnhVTitQZlZYZzNNVllHWUZQakk0aUg0anNCQUFDc1BEM + mpYSExnYVVzLzJ5VHUKNVF4M1RKSHljVTArOXZidC85VDJKdGt3c1R5SXlqQnJ0eGd6QVFERENa + aFZoNU5oOFJuSWlSRDFzMzNmN1RoZgp4eENUMU0yWHI3dWh1WVFTZ1FmNUFRYkFscDZpUk9xTms + 5VVlBeHNSWVdPelRFd3RWMGlCLzBJamwyZFBUTm1YClJxNW9FN0JOT3JYZjEzMmM4NlFpNWdPbG + VHbWNoNFEvUUZTbUYwT05FZCs4aVNWemMvaVdFTUh4SzROZ1ZMN0kKc0FMMDVweGZhdWxpWlRlW + VVGcGM1ajZnWHFpUExyNy93ODB4Q05vOWZsWmZXQkZzYVhMZm10Z3I1MU9kYXhJNQpLZnFjRjg1 + cnVQSkZkZjJWb1hxRU81YXpHZ1VsS0xoZDg5NkZUR21tZEF0SUp5b0RtTldyVFgwS1VqQ05ELzM + 4Ck5UZDZrK3h6bW1NcTJCRy9VRy9NVGtlTUl1T3BEenZGQjBiR2NRZnlGSC9iVnRjQzBOS2lnT0 + crMStPZ1dMMGUKQzZqcGRyYXU3THNKeXcrbU9VSjdHWHFTN2pKWnU2ZjBZcWxLbEZrUllBZi9Ve + kVUL3lBU2VhQUV2a1BqMnF5Lwo4b1ZIQWdrVGFZSWUvSHF1UEN4RVc4bmgzWEp2emIxaWVlOHMr + T2lZaE1wWVFIdFVTYTdESWR1eTgzZllTS2REClZzUnNNWExiMFlyZ1IvamhxdVZhYzR3TXFvZ3J + JTGRoK3lhcDdtUEhwdUVrOCtLcGROUldJNkZMS0srekpxcVYKZWh6ckNDc1QzL09URUd6bnpTSl + lXOXdQWkhlbEViMVhjQjIvbXJZSWlaZkZvUUI5K1ozNkYzS051UDR5cTdGcQpacWV5L0NLRFN4O + Tl4ckJwaTlLVENJUTl6UE5QS0xiSk0xUWFSVlNMNEhIcmh6dFJQc2JtbzlOS01lVHliSkE5Clpv + Y0JZRno1d1Q1RWRuZEdRUG51eWhESHY4UHZrbStWQXJnRVpkdUdFL0tIT1N6amlOVFE0QUtzaWc + 2OThFWGYKb0xRc1JYaGhiWEJzWlNCVmMyVnlJQ2hKYm5aaGJHbGtLU0E4WlhoaGJYQnNaVUJsZU + dGdGNHeGxMbU52YlQ2SQpnUVFURVFnQUtRVUNWbjhHdGdJYkF3VUpBREJDQ2djTENRZ0hBd0lCQ + mhVSUFna0tDd1FXQWdNQkFoNEJBaGVBCkFBb0pFSWJ1TXE0ZVZZTFY0L01BL2lSUG41cUttdC9M + K0doWVlIcCtlNmRiTHdxRFpCRkI3WGRlTTNZNlVScC8KQVFDZ21NSGM4d21YS0M0QTJUMURPTHd + hMUNVVzFLWHBaWm9xWEEwLzFhcHBHcmtCalFSV2Z3YTJFQVlBbnZYZgp0OWg1QnYyWTdvckp2UG + QvTXNYTlZMc0E1UTh3TTc2TytrRjdWMktsNzBjZitJVDM5UUpWRGtKSk15NjFGUEQvClFoME5WN + m05VjVsZ0E0U2psamo0SzIvc0ExUlhkRHVtaWFrWk1naUN4eXBveEhjM09uOEdXdi9kZXl0WExp + U2YKQnRrVHpiZEZmMDVHdGk1NXc1cnREQmxEM1o2YmR6U0ZtRS8rK2VFYXR4Uzh5NXJBNTM2Wmp + oSm5RQm43dm1aSQpwb3FUeTR0SEQ3aU5oWjN5eXFjZlpBd3BzSmNpZy9RdGVhZWNFUVgvSVlvL0 + 1wQllMTkp1V1VSRVpqeERBQU1GCkJmOUxmVlZJakhBdWt3NzUxeHFsQmhaUTRCVVV5eHE4UTVic + jZXVjJzeVppNnhWSW5OS2h3Q2NGYkZNVjV4TUIKczg3eGFzc1UrVzlaZktuODdScDRpa3JxOEVv + V3FPZTVMQW93SUF6bHYxVUlzMWRpOENHeStlU1lhYVMzVGd0Ywo2REhGS004Vk5KUU8wVWZkUXN + wS2FuNUVLL1ZUNy9QQVJONGFKcFZxdjNtYkVFWkdJdDJHMStpUm15VW5LbFd4CkxoaUkyREs5Rm + 9CajhucXlJVG1KMTBVTmRib2lmeUtFNTFwU2VlYjN3Rm8yNGhNNlVkbEVwVitQVGJvU0dGZXAKN + GQrSVp3UVlFUWdBRHdVQ1ZuOEd0Z0liREFVSkFEQkNDZ0FLQ1JDRzdqS3VIbFdDMVlJT0FRQ0Fy + WXRSZDBqSQpFYWNPbUxRWUNNUzNGVUNQRDc3dFlxd1VqM3NjSGVYWTdBRDhEKzAvMWdDdlZXelJ + uZ1dBSFZidXZxSkhmUEFpCm1HVFVHa1ZHOGNZdlBlUT0KPWtxclcKLS0tLS1FTkQgUEdQIFBVQk + xJQyBLRVkgQkxPQ0stLS0tLQo= +KEY;TYPE=home;ALTID=64;PID=61;PREF=62;KEYS=NONE:data:application/pgp-keys;ba + se64,LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tClZlcnNpb246IEdudVBHIH + YyCgptUU11QkZaL0tiWVJDQUNqTDdwMDZEVTJaQTZwdmJkZ1BVQU5hd1dwTGt3ZlFnZHdWdkVNc + FQvRnZuQjNGbDV4CnFFL2dMRFJDZlhLTVF4UEF1NWRBWUVpZVhxN01KN0ZtVXVYbDhJSjZiY3pK + RUNmWUF6RFJ0VmJlMm5ReXMyUDcKaXBFcnREK1dOZFM5MEVPbFVYb2lhOGR3NmpXczl5QUIvb3B + ubXBDV21wQjI2UVBKNDlNWTBVNWZ1NzhwamJ2MAppMWxmUXIyaWp4QzRDWHZlOGxld05Uak1pOU + 5UNkt6R1lwUXc1MHpXUng0Zk9teENselE5c3lQUWFuZ1htaTVECmk5MytNYXBaSlZpY3UyT3I1V + kdqUlRXYWovUDNqN1p2REdtNGNwaUhqMURsNTFVam5ZM09xOXE4VnczMkEvK2YKbW9SWWxiY3dt + WU1LeVMzMHJxSjVCOE0xcTdsenJ3TTBGQXczQVFEN3FnOE9pR2E1emR1UnlYdGlQMFFNSVZBOAp + DZUxuR25xYUJQdytEYkhDUndmK05ZelJiNUxBUXZQTXpsNlkrUTczb3N4VXhMYzBHOUt5K2tNWV + RNSFg5S2xzCmV2UThoQkFEc3Y5WDhVeklBRXpLUUJVQ2tWT0JQT2xLMnJiaHdrRzZGendDdzJDe + mxmU0NXSzBxaWhPbGFQVEsKL0c1SVJEQWg2SkFXTitjM1c5SHp1TUN1T1Vhb3didENhU2cxcFdo + cWNEY2hoWFZtNGdPZ3F6cDNkWXdKU3FEQwpCWGV4KzRsWk84TzZSa3BPMVhmTHlkSWpxSlQrQUN + MdkFjek8zbW90c2J6OEZNWWZzVTQ2ZWsvd05DczZJdlFDCjJQcFFJbHFHU3NmZXFLUGpsUXVGbk + RQNHEvNUNlVU5odmZrMm5VeTcwTzc4Z2hFdEViUU44MXNxWUpROHBTdTcKRExjVS8zQ1oyYXJ0R + WxkVGJ5a0p1RTJ6a3BVMjA1WTJvU0lDMkI1eXFnZjlIeWZOemYxU3lsRVV5d3ZzZ3F2LwpuNUNz + bDdobDNML3BSQ1A0dEF0NTA5TFFiejNDRk8vSGk3Umg1V3luOFVXZ1EzU0dYdThWQjNrUGhmRkF + DNFZPCjJBUVdnMFlDeEthSSs1dUljUWRGSDR6b0s0cWNidmxZN0xWNXozOWIza2JGWUgzVytEZj + JkNkhJRzZaZUF2aXQKZXhZZWNlMGNpS0l6dklqVUJydUI0R3BRREhZbGN5QmpxcWtOVE5zTzU4a + EsvQisvangxMGdLUVJTa0lwc0VJVgpLa0dBRk5sVnlMTGthck1hYnRNWUlzZnBidWtoSjF3d09a + TXJITGJwSGxQSFFzSDJJczNIdmlkQ2RBdUdRMWQyCjE2U3lEMGFUMHFIMnlkY1V2WFAyUnIwRnF + zR3BLY2dWeThMOTcyQWpCTmRTRWU0YXVQVGhWRXE5RWtScENSVGIKQUxRdlJYaGhiWEJzWlNCVm + MyVnlJRElnS0VsdWRtRnNhV1FwSUR4bGVHRnRjR3hsTWtCbGVHRnRjR3hsTG1OdgpiVDZJZ1FRV + EVRZ0FLUVVDVm44cHRnSWJBd1VKQUNnMkNnY0xDUWdIQXdJQkJoVUlBZ2tLQ3dRV0FnTUJBaDRC + CkFoZUFBQW9KRUFBdVBvS2h3WmFqVmFFQkFMN01saU5wLzR0cy9QWkQwdlRCcTYySjBUV0hvTjB + DcHpqUXJKQUwKblNZeUFQMGJYY0Y4UHRFejNlUkJkazBkTlNFeU1EMkVWVGQ0K3hhZTRRNUx4Q3 + gxU0xrQmpRUldmeW0yRUFZQQp4eWs4dUQ4MnZTZ2xORFA0UlQ3ZzExSjdnTXROV1g0SjBEbmdoc + VZVc0svY2xFQm4yenZYN080eElpQnluVG9wCmRKeDZaeE5pdFBKVG0zZzI4alRLUElKeXlDVGVH + LzJiaWtFc0hUYlFpMStpaXBkcEpjZm9EcTlJMVBMVk41Mm8KaFVMaUJhdXdwNHFIeTFyTys3ajh + tbWVlL1M5ckpzM2NmQnZHR09acmpFK3g4TTRMdjJDeGlEWnJzRUFkdHNPUgpnMHgxMFFqNjJwOE + xuTHg2TzQ4ZWh0cGZTV1JnRmZOdU9vSEJVU3RwSW5pMHRrajJSQitGaUgwZWxkc1VyRndMCkFBT + UdCZ0NPYzk5bjB3OWEvelRDL0VxSnRjU2llRkNtckMvODYrcW12OEJ3aW5zdU1STUtVSG1UdFFk + R1RRQkcKL0ZXa2pKYm9YMEhZckp0d1JBaC9tM2N6UnNMZjZkT3QxL2hEUVF2ZGVIcVhuZ1Jleit + WNzAyY0pUVVdwVGg5RgpjYnZ3NFpjMk93Yzhzam13L3dYc2NMK0ZNU09mT3l6eC8xWmxBUDVoSk + Q5TTNnV1dEL0ZLSk0weUxSZDI5OW92CkpoNDZVVkIvaHdxelEyYnlEUzV2QXhXUlFsT0FHaEdXV + zNOcjlQRE82N2dsSWRPM2o5VzN4bENUNjJ4cmEvVmMKbDVDTU9qU0lad1FZRVFnQUR3VUNWbjhw + dGdJYkRBVUpBQ2cyQ2dBS0NSQUFMajZDb2NHV296aThBUUNqc09YbQpGdEFCcEU4b0EzVmtPT1o + 4b28wMFZTcUhKVFkxRzhpNXgvNmtZQUVBMC9kR0JmRHVhMDBxL2Z1Z3dYTmlPREJXCjh2a2hlME + VIOWFlYzJQaUd3VTg9Cj1ZWmZuCi0tLS0tRU5EIFBHUCBQVUJMSUMgS0VZIEJMT0NLLS0tLS0K +KEY;TYPE=work;ALTID=74;PID=71;PREF=72;KEYS=MISSING:data:application/pgp-keys + ;base64,LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tClZlcnNpb246IEdudVB + HIHYyCgptUU11QkZaL0x3d1JDQUN0cVNJa3hYN2NBWkJHNFlIUmRldkRudndvM1V4dEQ0ZmxmaW + 1NQmdTemUwbHJTMHNjCmEyaDRmMzJ1eklpR2Q1S0plT0psV3AwSUFBOXNCUW5lQVpXVm9XUjZaO + TlZZnNtUjhoSENZVERqTGpVRUFnMTYKYzNsbUpWbkRqTDF4bmhSR2RjUGJxS2VQOGVuZ0hQWE4w + M0tuSkVYcUNZSnFNc3NySFNlN3crMFNMeVJPQkJkeQprSE5Lb1B1bUdOUWIvakhLd0QzNFg1SEJ + MbUVkbXczR1gzNXVwbm9pVnNqSGJzcHY3bVBQRVJxdlNGMUtlTmVHCkhnSllHdlZiNUJZenpMQ3 + dRRXU0VFNVMFRLQytMeUZUUFpPZE9pVzU2RG5qbktrNk1Od2xCWTFDZXRzZFpwR2QKUXFWZmNYd + FRnNG1SNGZzVVJaQ0JXR0w3OFMrQ2tDUFh4NTRIQVFDbEhVbUFzK3hnV0ExbU11SzVva2FadDYz + eQoyb09CSXBseXZkcDhreCtVY3dmL2FWUGQ1dGZ2S3JPVTV0VVZDdlpMN0syVnlkNUNSckFTUG9 + 3VkwrWmxjYXNDCloyaDEvRGJKQ1FYOVVPTU5LNXVVMUZYNFErLy83OWR3ZlZVOEZYZUpzM1NKeD + hHQlB3Z0s4RStmait2MWVNSmMKTkhCMlV2eGtrU050akErUHB1dW5sYXhGYWpBRTU2ckt6N2U0N + GI5NUNjVldkUTAxbTByeGptSGhTUmtXeDlWNQp4cExsbUZ2Q1ZLMXFsMlV5eCtzZU9RQXJpMjBG + cUUzbktQMU9BNWt2QTd3b2NpZ1JVakVVWk1XOEFxL1daV2xnCnk2YW9pVTFPSlp6Q2tkeStPcWV + xL0djeWRIYmcwdUZ0N3UvSTROTWFLVlZMREhWdStSWXZlcGlzNy93TVMvclMKQTVwVk56NURRMX + R3cTlJTWV0NGNGRnBjOFdIeTVnR0pUNEFRVk1UYU5RZ0FuR1JqKytBTEpObCtsc1AzaDBjbwpTa + 0xqOElWbjlkaXRFUGMxRGVRbllUb092WStLSDA3a09MekJmbXcvdmRlTVdkZzd6VDZhQTRza2hB + L2VHNWdDCm1sL25IQmM1TS9pV2htRE9FUzFXZTRVYWMzbVNWeG9iSS9oYzNlM3pVcTlkQ0F5OFc + 4eUxvUThxMVArTnlScFkKd250bUxuZ2RVek00VTFLbEdMTWx3aGF1V3liQlBHTnlqYy9KUWtvdk + dVa1g5dHU0cGdzaVlOb2F1MjV5NUs3OQo0Z1MxQUtlQjgya3lteWlQaGQvdnZpK3VhRXIzdFQ5Z + 2x0WjRiaW1YR3ZQZG1xRnV1MkVYTXhmQXJGL21NSzJoClN5Z1BIUG5jVW9kc3NNV0ZxZjEvNWo1 + MkwrTzlUK1RLVXhxQ2RHMVFSOVZDU0NoUDY0c0NFaGpqeis5R1g1eHAKZGJRdlJYaGhiWEJzWlN + CVmMyVnlJRE1nS0VsdWRtRnNhV1FwSUR4bGVHRnRjR3hsTTBCbGVHRnRjR3hsTG1OdgpiVDZJZ1 + FRVEVRZ0FLUVVDVm44dkRBSWJBd1VKQUFuZU5BY0xDUWdIQXdJQkJoVUlBZ2tLQ3dRV0FnTUJBa + DRCCkFoZUFBQW9KRU1IakNSbG51dzVEOVFrQS9qWGFUTjJSVEhKSytMWEs1dXJEVDBLTElBTUVW + ak1lT1dQWmlyVXkKcldnRkFQd09XSi80eDVBT3dvZFVPTnh6Rk5NRXJBV2o5N3Y1bm5ZaURJcm1 + jUjl1ZzdrQmpRUldmeThNRUFZQQorVFBWcit3VGk2U0RxN25pd3pNZUo2c05QMHlwaXVJaTB3c2 + pXRDVndnJROGZqVE41STdtL3hldEhtcXdvbDdiCnhEL09iUE1GRm9Tdm1kRERlVlR5cnl0cDI3U + 05QNVgzUFlxTldKbW9XN09mUTBQRlIvbmprdVNGdmN0NkZDNTMKVjhvU0JPcVVuRWlZckRGSU1z + REdOQ25UZ1VUeG9GaFZ1MEVESFRhWVFxV2tYMWxldTJFQTlZTjJub3FFVVh2bgpEOE92TXZaWGx + QcTFzdDVmc2IyODB1RGJYMWRvWVpNK0pPRWo3bHp4bEtzUjJNZFlOallKci9RZUwwaEMxVlpmCk + FBTUZCZjR0bWdvRmt4a0Y4N2Z4ejB4eU9sYXhGclUzYnhVZXJiYTZPUGZJTjV3cXZmOEFsNGdwZ + XRRRitNQysKUnBlR01rYk5iaTRwV3MvV1BUbmhIN2R3UTI4a0c3VXFkSjdiMDdYUkpVbTJrenRu + NGRucFJpTGJBU1Z0MFVlRApxeWpNY1hRa21KTTFjVlNDMWpzY0ROUTl1anNjMXBQUi9iK2xPa0F + 2ZGJtK0x3RHZNMmVJa25LWDZsdkZsa0RlCng1dU82ZXpKTktLZEdMSW53c2hpVHdzSjZoTS9OL3 + JjbGFZeWpsSlBwY216VFhuaks5SmN1SU9MVHVsVXFwQUwKbHQyWXh1aUlad1FZRVFnQUR3VUNWb + jh2REFJYkRBVUpBQW5lTkFBS0NSREI0d2taWjdzT1E1Uk5BUUNUSHVjOQpjM1dORURZY1hhV2N6 + S3ZwN2R4aWJ1YS9FanNxRC85eHNUOHRZUUQrT2VqRndvRmVrbnpZa2RFMmdJb2ZuaDk0CjdKeUh + aNDUyTERkamZXQ1BZWFU9Cj16T3NxCi0tLS0tRU5EIFBHUCBQVUJMSUMgS0VZIEJMT0NLLS0tLS + 0K END:VCARD diff --git a/source/tests/xestiaab_contactload.h b/source/tests/xestiaab_contactload.h index 803d2a3..3886d4c 100644 --- a/source/tests/xestiaab_contactload.h +++ b/source/tests/xestiaab_contactload.h @@ -3495,7 +3495,7 @@ TEST(ContactLoad, FreeBusyTests){ std::map::iterator TestFileIter; std::map::iterator TestFileIntIter; - // Start with a general calendar request address. + // Start with a general calendar free busy address. TestFileIter = TestFile.FreeBusyList.find(0); ASSERT_NE(TestFile.FreeBusyList.end(), TestFileIter); @@ -3536,7 +3536,7 @@ TEST(ContactLoad, FreeBusyTests){ ASSERT_NE(TestFile.FreeBusyListTokens.end(), TestFileIter); ASSERT_EQ("STATUS=OUT", TestFileIter->second); - // Start with a home calendar request address. + // Start with a home calendar free busy address. TestFileIter = TestFile.FreeBusyList.find(1); ASSERT_NE(TestFile.FreeBusyList.end(), TestFileIter); @@ -3578,7 +3578,7 @@ TEST(ContactLoad, FreeBusyTests){ ASSERT_NE(TestFile.FreeBusyListTokens.end(), TestFileIter); ASSERT_EQ("STATUS=FREE", TestFileIter->second); - // Start with a business calendar request address. + // Start with a business calendar free busy address. TestFileIter = TestFile.FreeBusyList.find(2); ASSERT_NE(TestFile.FreeBusyList.end(), TestFileIter); @@ -3620,6 +3620,279 @@ TEST(ContactLoad, FreeBusyTests){ ASSERT_NE(TestFile.FreeBusyListTokens.end(), TestFileIter); ASSERT_EQ("STATUS=BUSY", TestFileIter->second); +} + +TEST(ContactLoad, KeyTests){ + + ContactDataObject TestFile; + + wxString KeyA = "LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tClZlcnNpb246IEdudVBHIHYyCgpt" + "UU11QkZaL0JyWVJDQUN2cTNueUl4dXJPOFovMHcwQWdkeUdhN1d2cWRpdk5OWVdEM3dmZkgrSi83" + "R2o1dkNOClJwWFQ5TVI4SEdmR0Jwai9hc0NsajltbjhnRENMcVZJaXFybXZXK3dHbnhBVWxFU05V" + "T201cEx6NTRwTzBzOW0KYzJ5SDRkYWVYR3pRTXFLUit2TDZaTWpDc0pSRk1UWVAzSDlTMlBFaHFF" + "MXl4TnBpRi9ZTS9jNGNOYmU5bEZsTgpKMnJ2QzA2bzZuMFlzYWtuZTk3bWlndGNyTUpZVDljVDF4" + "cjB5YUhDekcrVXZqOG1RMnlGT0tpVEpxeGlCVEdhClRMWjJjTFBVZVFFbnpjSWNwNnhVTitQZlZY" + "ZzNNVllHWUZQakk0aUg0anNCQUFDc1BEMmpYSExnYVVzLzJ5VHUKNVF4M1RKSHljVTArOXZidC85" + "VDJKdGt3c1R5SXlqQnJ0eGd6QVFERENaaFZoNU5oOFJuSWlSRDFzMzNmN1RoZgp4eENUMU0yWHI3" + "dWh1WVFTZ1FmNUFRYkFscDZpUk9xTms5VVlBeHNSWVdPelRFd3RWMGlCLzBJamwyZFBUTm1YClJx" + "NW9FN0JOT3JYZjEzMmM4NlFpNWdPbGVHbWNoNFEvUUZTbUYwT05FZCs4aVNWemMvaVdFTUh4SzRO" + "Z1ZMN0kKc0FMMDVweGZhdWxpWlRlWVVGcGM1ajZnWHFpUExyNy93ODB4Q05vOWZsWmZXQkZzYVhM" + "Zm10Z3I1MU9kYXhJNQpLZnFjRjg1cnVQSkZkZjJWb1hxRU81YXpHZ1VsS0xoZDg5NkZUR21tZEF0" + "SUp5b0RtTldyVFgwS1VqQ05ELzM4Ck5UZDZrK3h6bW1NcTJCRy9VRy9NVGtlTUl1T3BEenZGQjBi" + "R2NRZnlGSC9iVnRjQzBOS2lnT0crMStPZ1dMMGUKQzZqcGRyYXU3THNKeXcrbU9VSjdHWHFTN2pK" + "WnU2ZjBZcWxLbEZrUllBZi9VekVUL3lBU2VhQUV2a1BqMnF5Lwo4b1ZIQWdrVGFZSWUvSHF1UEN4" + "RVc4bmgzWEp2emIxaWVlOHMrT2lZaE1wWVFIdFVTYTdESWR1eTgzZllTS2REClZzUnNNWExiMFly" + "Z1IvamhxdVZhYzR3TXFvZ3JJTGRoK3lhcDdtUEhwdUVrOCtLcGROUldJNkZMS0srekpxcVYKZWh6" + "ckNDc1QzL09URUd6bnpTSllXOXdQWkhlbEViMVhjQjIvbXJZSWlaZkZvUUI5K1ozNkYzS051UDR5" + "cTdGcQpacWV5L0NLRFN4OTl4ckJwaTlLVENJUTl6UE5QS0xiSk0xUWFSVlNMNEhIcmh6dFJQc2Jt" + "bzlOS01lVHliSkE5ClpvY0JZRno1d1Q1RWRuZEdRUG51eWhESHY4UHZrbStWQXJnRVpkdUdFL0tI" + "T1N6amlOVFE0QUtzaWc2OThFWGYKb0xRc1JYaGhiWEJzWlNCVmMyVnlJQ2hKYm5aaGJHbGtLU0E4" + "WlhoaGJYQnNaVUJsZUdGdGNHeGxMbU52YlQ2SQpnUVFURVFnQUtRVUNWbjhHdGdJYkF3VUpBREJD" + "Q2djTENRZ0hBd0lCQmhVSUFna0tDd1FXQWdNQkFoNEJBaGVBCkFBb0pFSWJ1TXE0ZVZZTFY0L01B" + "L2lSUG41cUttdC9MK0doWVlIcCtlNmRiTHdxRFpCRkI3WGRlTTNZNlVScC8KQVFDZ21NSGM4d21Y" + "S0M0QTJUMURPTHdhMUNVVzFLWHBaWm9xWEEwLzFhcHBHcmtCalFSV2Z3YTJFQVlBbnZYZgp0OWg1" + "QnYyWTdvckp2UGQvTXNYTlZMc0E1UTh3TTc2TytrRjdWMktsNzBjZitJVDM5UUpWRGtKSk15NjFG" + "UEQvClFoME5WNm05VjVsZ0E0U2psamo0SzIvc0ExUlhkRHVtaWFrWk1naUN4eXBveEhjM09uOEdX" + "di9kZXl0WExpU2YKQnRrVHpiZEZmMDVHdGk1NXc1cnREQmxEM1o2YmR6U0ZtRS8rK2VFYXR4Uzh5" + "NXJBNTM2WmpoSm5RQm43dm1aSQpwb3FUeTR0SEQ3aU5oWjN5eXFjZlpBd3BzSmNpZy9RdGVhZWNF" + "UVgvSVlvL01wQllMTkp1V1VSRVpqeERBQU1GCkJmOUxmVlZJakhBdWt3NzUxeHFsQmhaUTRCVVV5" + "eHE4UTVicjZXVjJzeVppNnhWSW5OS2h3Q2NGYkZNVjV4TUIKczg3eGFzc1UrVzlaZktuODdScDRp" + "a3JxOEVvV3FPZTVMQW93SUF6bHYxVUlzMWRpOENHeStlU1lhYVMzVGd0Ywo2REhGS004Vk5KUU8w" + "VWZkUXNwS2FuNUVLL1ZUNy9QQVJONGFKcFZxdjNtYkVFWkdJdDJHMStpUm15VW5LbFd4CkxoaUky" + "REs5Rm9CajhucXlJVG1KMTBVTmRib2lmeUtFNTFwU2VlYjN3Rm8yNGhNNlVkbEVwVitQVGJvU0dG" + "ZXAKNGQrSVp3UVlFUWdBRHdVQ1ZuOEd0Z0liREFVSkFEQkNDZ0FLQ1JDRzdqS3VIbFdDMVlJT0FR" + "Q0FyWXRSZDBqSQpFYWNPbUxRWUNNUzNGVUNQRDc3dFlxd1VqM3NjSGVYWTdBRDhEKzAvMWdDdlZX" + "elJuZ1dBSFZidXZxSkhmUEFpCm1HVFVHa1ZHOGNZdlBlUT0KPWtxclcKLS0tLS1FTkQgUEdQIFBV" + "QkxJQyBLRVkgQkxPQ0stLS0tLQo="; + + wxString KeyB = "LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tClZlcnNpb246IEdudVBHIHYyCgpt" + "UU11QkZaL0tiWVJDQUNqTDdwMDZEVTJaQTZwdmJkZ1BVQU5hd1dwTGt3ZlFnZHdWdkVNcFQvRnZu" + "QjNGbDV4CnFFL2dMRFJDZlhLTVF4UEF1NWRBWUVpZVhxN01KN0ZtVXVYbDhJSjZiY3pKRUNmWUF6" + "RFJ0VmJlMm5ReXMyUDcKaXBFcnREK1dOZFM5MEVPbFVYb2lhOGR3NmpXczl5QUIvb3BubXBDV21w" + "QjI2UVBKNDlNWTBVNWZ1NzhwamJ2MAppMWxmUXIyaWp4QzRDWHZlOGxld05Uak1pOU5UNkt6R1lw" + "UXc1MHpXUng0Zk9teENselE5c3lQUWFuZ1htaTVECmk5MytNYXBaSlZpY3UyT3I1VkdqUlRXYWov" + "UDNqN1p2REdtNGNwaUhqMURsNTFVam5ZM09xOXE4VnczMkEvK2YKbW9SWWxiY3dtWU1LeVMzMHJx" + "SjVCOE0xcTdsenJ3TTBGQXczQVFEN3FnOE9pR2E1emR1UnlYdGlQMFFNSVZBOApDZUxuR25xYUJQ" + "dytEYkhDUndmK05ZelJiNUxBUXZQTXpsNlkrUTczb3N4VXhMYzBHOUt5K2tNWVRNSFg5S2xzCmV2" + "UThoQkFEc3Y5WDhVeklBRXpLUUJVQ2tWT0JQT2xLMnJiaHdrRzZGendDdzJDemxmU0NXSzBxaWhP" + "bGFQVEsKL0c1SVJEQWg2SkFXTitjM1c5SHp1TUN1T1Vhb3didENhU2cxcFdocWNEY2hoWFZtNGdP" + "Z3F6cDNkWXdKU3FEQwpCWGV4KzRsWk84TzZSa3BPMVhmTHlkSWpxSlQrQUNMdkFjek8zbW90c2J6" + "OEZNWWZzVTQ2ZWsvd05DczZJdlFDCjJQcFFJbHFHU3NmZXFLUGpsUXVGbkRQNHEvNUNlVU5odmZr" + "Mm5VeTcwTzc4Z2hFdEViUU44MXNxWUpROHBTdTcKRExjVS8zQ1oyYXJ0RWxkVGJ5a0p1RTJ6a3BV" + "MjA1WTJvU0lDMkI1eXFnZjlIeWZOemYxU3lsRVV5d3ZzZ3F2LwpuNUNzbDdobDNML3BSQ1A0dEF0" + "NTA5TFFiejNDRk8vSGk3Umg1V3luOFVXZ1EzU0dYdThWQjNrUGhmRkFDNFZPCjJBUVdnMFlDeEth" + "SSs1dUljUWRGSDR6b0s0cWNidmxZN0xWNXozOWIza2JGWUgzVytEZjJkNkhJRzZaZUF2aXQKZXhZ" + "ZWNlMGNpS0l6dklqVUJydUI0R3BRREhZbGN5QmpxcWtOVE5zTzU4aEsvQisvangxMGdLUVJTa0lw" + "c0VJVgpLa0dBRk5sVnlMTGthck1hYnRNWUlzZnBidWtoSjF3d09aTXJITGJwSGxQSFFzSDJJczNI" + "dmlkQ2RBdUdRMWQyCjE2U3lEMGFUMHFIMnlkY1V2WFAyUnIwRnFzR3BLY2dWeThMOTcyQWpCTmRT" + "RWU0YXVQVGhWRXE5RWtScENSVGIKQUxRdlJYaGhiWEJzWlNCVmMyVnlJRElnS0VsdWRtRnNhV1Fw" + "SUR4bGVHRnRjR3hsTWtCbGVHRnRjR3hsTG1OdgpiVDZJZ1FRVEVRZ0FLUVVDVm44cHRnSWJBd1VK" + "QUNnMkNnY0xDUWdIQXdJQkJoVUlBZ2tLQ3dRV0FnTUJBaDRCCkFoZUFBQW9KRUFBdVBvS2h3WmFq" + "VmFFQkFMN01saU5wLzR0cy9QWkQwdlRCcTYySjBUV0hvTjBDcHpqUXJKQUwKblNZeUFQMGJYY0Y4" + "UHRFejNlUkJkazBkTlNFeU1EMkVWVGQ0K3hhZTRRNUx4Q3gxU0xrQmpRUldmeW0yRUFZQQp4eWs4" + "dUQ4MnZTZ2xORFA0UlQ3ZzExSjdnTXROV1g0SjBEbmdocVZVc0svY2xFQm4yenZYN080eElpQnlu" + "VG9wCmRKeDZaeE5pdFBKVG0zZzI4alRLUElKeXlDVGVHLzJiaWtFc0hUYlFpMStpaXBkcEpjZm9E" + "cTlJMVBMVk41Mm8KaFVMaUJhdXdwNHFIeTFyTys3ajhtbWVlL1M5ckpzM2NmQnZHR09acmpFK3g4" + "TTRMdjJDeGlEWnJzRUFkdHNPUgpnMHgxMFFqNjJwOExuTHg2TzQ4ZWh0cGZTV1JnRmZOdU9vSEJV" + "U3RwSW5pMHRrajJSQitGaUgwZWxkc1VyRndMCkFBTUdCZ0NPYzk5bjB3OWEvelRDL0VxSnRjU2ll" + "RkNtckMvODYrcW12OEJ3aW5zdU1STUtVSG1UdFFkR1RRQkcKL0ZXa2pKYm9YMEhZckp0d1JBaC9t" + "M2N6UnNMZjZkT3QxL2hEUVF2ZGVIcVhuZ1JleitWNzAyY0pUVVdwVGg5RgpjYnZ3NFpjMk93Yzhz" + "am13L3dYc2NMK0ZNU09mT3l6eC8xWmxBUDVoSkQ5TTNnV1dEL0ZLSk0weUxSZDI5OW92CkpoNDZV" + "VkIvaHdxelEyYnlEUzV2QXhXUlFsT0FHaEdXVzNOcjlQRE82N2dsSWRPM2o5VzN4bENUNjJ4cmEv" + "VmMKbDVDTU9qU0lad1FZRVFnQUR3VUNWbjhwdGdJYkRBVUpBQ2cyQ2dBS0NSQUFMajZDb2NHV296" + "aThBUUNqc09YbQpGdEFCcEU4b0EzVmtPT1o4b28wMFZTcUhKVFkxRzhpNXgvNmtZQUVBMC9kR0Jm" + "RHVhMDBxL2Z1Z3dYTmlPREJXCjh2a2hlMEVIOWFlYzJQaUd3VTg9Cj1ZWmZuCi0tLS0tRU5EIFBH" + "UCBQVUJMSUMgS0VZIEJMT0NLLS0tLS0K"; + + wxString KeyC = "LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tClZlcnNpb246IEdudVB" + "HIHYyCgptUU11QkZaL0x3d1JDQUN0cVNJa3hYN2NBWkJHNFlIUmRldkRudndvM1V4dEQ0ZmxmaW" + "1NQmdTemUwbHJTMHNjCmEyaDRmMzJ1eklpR2Q1S0plT0psV3AwSUFBOXNCUW5lQVpXVm9XUjZaO" + "TlZZnNtUjhoSENZVERqTGpVRUFnMTYKYzNsbUpWbkRqTDF4bmhSR2RjUGJxS2VQOGVuZ0hQWE4w" + "M0tuSkVYcUNZSnFNc3NySFNlN3crMFNMeVJPQkJkeQprSE5Lb1B1bUdOUWIvakhLd0QzNFg1SEJ" + "MbUVkbXczR1gzNXVwbm9pVnNqSGJzcHY3bVBQRVJxdlNGMUtlTmVHCkhnSllHdlZiNUJZenpMQ3" + "dRRXU0VFNVMFRLQytMeUZUUFpPZE9pVzU2RG5qbktrNk1Od2xCWTFDZXRzZFpwR2QKUXFWZmNYd" + "FRnNG1SNGZzVVJaQ0JXR0w3OFMrQ2tDUFh4NTRIQVFDbEhVbUFzK3hnV0ExbU11SzVva2FadDYz" + "eQoyb09CSXBseXZkcDhreCtVY3dmL2FWUGQ1dGZ2S3JPVTV0VVZDdlpMN0syVnlkNUNSckFTUG9" + "3VkwrWmxjYXNDCloyaDEvRGJKQ1FYOVVPTU5LNXVVMUZYNFErLy83OWR3ZlZVOEZYZUpzM1NKeD" + "hHQlB3Z0s4RStmait2MWVNSmMKTkhCMlV2eGtrU050akErUHB1dW5sYXhGYWpBRTU2ckt6N2U0N" + "GI5NUNjVldkUTAxbTByeGptSGhTUmtXeDlWNQp4cExsbUZ2Q1ZLMXFsMlV5eCtzZU9RQXJpMjBG" + "cUUzbktQMU9BNWt2QTd3b2NpZ1JVakVVWk1XOEFxL1daV2xnCnk2YW9pVTFPSlp6Q2tkeStPcWV" + "xL0djeWRIYmcwdUZ0N3UvSTROTWFLVlZMREhWdStSWXZlcGlzNy93TVMvclMKQTVwVk56NURRMX" + "R3cTlJTWV0NGNGRnBjOFdIeTVnR0pUNEFRVk1UYU5RZ0FuR1JqKytBTEpObCtsc1AzaDBjbwpTa" + "0xqOElWbjlkaXRFUGMxRGVRbllUb092WStLSDA3a09MekJmbXcvdmRlTVdkZzd6VDZhQTRza2hB" + "L2VHNWdDCm1sL25IQmM1TS9pV2htRE9FUzFXZTRVYWMzbVNWeG9iSS9oYzNlM3pVcTlkQ0F5OFc" + "4eUxvUThxMVArTnlScFkKd250bUxuZ2RVek00VTFLbEdMTWx3aGF1V3liQlBHTnlqYy9KUWtvdk" + "dVa1g5dHU0cGdzaVlOb2F1MjV5NUs3OQo0Z1MxQUtlQjgya3lteWlQaGQvdnZpK3VhRXIzdFQ5Z" + "2x0WjRiaW1YR3ZQZG1xRnV1MkVYTXhmQXJGL21NSzJoClN5Z1BIUG5jVW9kc3NNV0ZxZjEvNWo1" + "MkwrTzlUK1RLVXhxQ2RHMVFSOVZDU0NoUDY0c0NFaGpqeis5R1g1eHAKZGJRdlJYaGhiWEJzWlN" + "CVmMyVnlJRE1nS0VsdWRtRnNhV1FwSUR4bGVHRnRjR3hsTTBCbGVHRnRjR3hsTG1OdgpiVDZJZ1" + "FRVEVRZ0FLUVVDVm44dkRBSWJBd1VKQUFuZU5BY0xDUWdIQXdJQkJoVUlBZ2tLQ3dRV0FnTUJBa" + "DRCCkFoZUFBQW9KRU1IakNSbG51dzVEOVFrQS9qWGFUTjJSVEhKSytMWEs1dXJEVDBLTElBTUVW" + "ak1lT1dQWmlyVXkKcldnRkFQd09XSi80eDVBT3dvZFVPTnh6Rk5NRXJBV2o5N3Y1bm5ZaURJcm1" + "jUjl1ZzdrQmpRUldmeThNRUFZQQorVFBWcit3VGk2U0RxN25pd3pNZUo2c05QMHlwaXVJaTB3c2" + "pXRDVndnJROGZqVE41STdtL3hldEhtcXdvbDdiCnhEL09iUE1GRm9Tdm1kRERlVlR5cnl0cDI3U" + "05QNVgzUFlxTldKbW9XN09mUTBQRlIvbmprdVNGdmN0NkZDNTMKVjhvU0JPcVVuRWlZckRGSU1z" + "REdOQ25UZ1VUeG9GaFZ1MEVESFRhWVFxV2tYMWxldTJFQTlZTjJub3FFVVh2bgpEOE92TXZaWGx" + "QcTFzdDVmc2IyODB1RGJYMWRvWVpNK0pPRWo3bHp4bEtzUjJNZFlOallKci9RZUwwaEMxVlpmCk" + "FBTUZCZjR0bWdvRmt4a0Y4N2Z4ejB4eU9sYXhGclUzYnhVZXJiYTZPUGZJTjV3cXZmOEFsNGdwZ" + "XRRRitNQysKUnBlR01rYk5iaTRwV3MvV1BUbmhIN2R3UTI4a0c3VXFkSjdiMDdYUkpVbTJrenRu" + "NGRucFJpTGJBU1Z0MFVlRApxeWpNY1hRa21KTTFjVlNDMWpzY0ROUTl1anNjMXBQUi9iK2xPa0F" + "2ZGJtK0x3RHZNMmVJa25LWDZsdkZsa0RlCng1dU82ZXpKTktLZEdMSW53c2hpVHdzSjZoTS9OL3" + "JjbGFZeWpsSlBwY216VFhuaks5SmN1SU9MVHVsVXFwQUwKbHQyWXh1aUlad1FZRVFnQUR3VUNWb" + "jh2REFJYkRBVUpBQW5lTkFBS0NSREI0d2taWjdzT1E1Uk5BUUNUSHVjOQpjM1dORURZY1hhV2N6" + "S3ZwN2R4aWJ1YS9FanNxRC85eHNUOHRZUUQrT2VqRndvRmVrbnpZa2RFMmdJb2ZuaDk0CjdKeUh" + "aNDUyTERkamZXQ1BZWFU9Cj16T3NxCi0tLS0tRU5EIFBHUCBQVUJMSUMgS0VZIEJMT0NLLS0tLS" + "0K"; + + // Check that the vCard 4.0 file loads OK. + + ASSERT_EQ(CONTACTLOAD_OK, TestFile.LoadFile("LoadCheck-Load4.vcf")); + + std::map::iterator TestFileIter; + std::map::iterator TestFileIntIter; + + // Start with a general key. + + TestFileIter = TestFile.KeyList.find(0); + ASSERT_NE(TestFile.KeyList.end(), TestFileIter); + ASSERT_EQ(KeyA, TestFileIter->second); + + // Check the encoding type. + + TestFileIter = TestFile.KeyListDataEncType.find(0); + ASSERT_NE(TestFile.KeyListDataEncType.end(), TestFileIter); + ASSERT_EQ("base64", TestFileIter->second.ToStdString()); + + // Check the file type. + + TestFileIter = TestFile.KeyListDataType.find(0); + ASSERT_NE(TestFile.KeyListDataType.end(), TestFileIter); + ASSERT_EQ("application/pgp-keys", TestFileIter->second); + + // Check the TYPE section. + + TestFileIter = TestFile.KeyListType.find(0); + ASSERT_EQ(TestFile.KeyListType.end(), TestFileIter); + + // Check the ALTID section. + + TestFileIter = TestFile.KeyListAltID.find(0); + ASSERT_NE(TestFile.KeyListAltID.end(), TestFileIter); + ASSERT_EQ("54", TestFileIter->second); + + // Check the PID section. + + TestFileIter = TestFile.KeyListPID.find(0); + ASSERT_NE(TestFile.KeyListPID.end(), TestFileIter); + ASSERT_EQ("51", TestFileIter->second); + + // Check the PREF section. + + TestFileIntIter = TestFile.KeyListPref.find(0); + ASSERT_NE(TestFile.KeyListPref.end(), TestFileIntIter); + ASSERT_EQ(52, TestFileIntIter->second); + + // Check the extra tokens. + + TestFileIter = TestFile.KeyListTokens.find(0); + ASSERT_NE(TestFile.KeyListTokens.end(), TestFileIter); + ASSERT_EQ("KEYS=JUSTONE", TestFileIter->second); + + // Start with a work key. + + TestFileIter = TestFile.KeyList.find(1); + ASSERT_NE(TestFile.KeyList.end(), TestFileIter); + ASSERT_EQ(KeyB, TestFileIter->second); + + // Check the encoding type. + + TestFileIter = TestFile.KeyListDataEncType.find(1); + ASSERT_NE(TestFile.KeyListDataEncType.end(), TestFileIter); + ASSERT_EQ("base64", TestFileIter->second.ToStdString()); + + // Check the file type. + + TestFileIter = TestFile.KeyListDataType.find(1); + ASSERT_NE(TestFile.KeyListDataType.end(), TestFileIter); + ASSERT_EQ("application/pgp-keys", TestFileIter->second); + + // Check the TYPE section. + + TestFileIter = TestFile.KeyListType.find(1); + ASSERT_NE(TestFile.KeyListType.end(), TestFileIter); + ASSERT_EQ("home", TestFileIter->second); + + // Check the ALTID section. + + TestFileIter = TestFile.KeyListAltID.find(1); + ASSERT_NE(TestFile.KeyListAltID.end(), TestFileIter); + ASSERT_EQ("64", TestFileIter->second); + + // Check the PID section. + + TestFileIter = TestFile.KeyListPID.find(1); + ASSERT_NE(TestFile.KeyListPID.end(), TestFileIter); + ASSERT_EQ("61", TestFileIter->second); + + // Check the PREF section. + + TestFileIntIter = TestFile.KeyListPref.find(1); + ASSERT_NE(TestFile.KeyListPref.end(), TestFileIntIter); + ASSERT_EQ(62, TestFileIntIter->second); + + // Check the extra tokens. + + TestFileIter = TestFile.KeyListTokens.find(1); + ASSERT_NE(TestFile.KeyListTokens.end(), TestFileIter); + ASSERT_EQ("KEYS=NONE", TestFileIter->second); + + // Start with a business key. + + TestFileIter = TestFile.KeyList.find(2); + ASSERT_NE(TestFile.KeyList.end(), TestFileIter); + ASSERT_EQ(KeyC, TestFileIter->second); + + // Check the encoding type. + + TestFileIter = TestFile.KeyListDataEncType.find(2); + ASSERT_NE(TestFile.KeyListDataEncType.end(), TestFileIter); + ASSERT_EQ("base64", TestFileIter->second.ToStdString()); + + // Check the file type. + + TestFileIter = TestFile.KeyListDataType.find(2); + ASSERT_NE(TestFile.KeyListDataType.end(), TestFileIter); + ASSERT_EQ("application/pgp-keys", TestFileIter->second); + + // Check the TYPE section. + + TestFileIter = TestFile.KeyListType.find(2); + ASSERT_NE(TestFile.KeyListType.end(), TestFileIter); + ASSERT_EQ("work", TestFileIter->second); + + // Check the ALTID section. + + TestFileIter = TestFile.KeyListAltID.find(2); + ASSERT_NE(TestFile.KeyListAltID.end(), TestFileIter); + ASSERT_EQ("74", TestFileIter->second); + + // Check the PID section. + + TestFileIter = TestFile.KeyListPID.find(2); + ASSERT_NE(TestFile.KeyListPID.end(), TestFileIter); + ASSERT_EQ("71", TestFileIter->second); + + // Check the PREF section. + + TestFileIntIter = TestFile.KeyListPref.find(2); + ASSERT_NE(TestFile.KeyListPref.end(), TestFileIntIter); + ASSERT_EQ(72, TestFileIntIter->second); + + // Check the extra tokens. + + TestFileIter = TestFile.KeyListTokens.find(2); + ASSERT_NE(TestFile.KeyListTokens.end(), TestFileIter); + ASSERT_EQ("KEYS=MISSING", TestFileIter->second); } -- 2.39.2