|
1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include <e32test.h> |
|
17 #include <f32file.h> |
|
18 #include <s32file.h> |
|
19 #include <cntdb.h> |
|
20 #include <cntitem.h> |
|
21 #include <cntfield.h> |
|
22 #include <cntfldst.h> |
|
23 #include <bautils.h> |
|
24 #include <barsc.h> |
|
25 #include <barsread.h> |
|
26 #include <cntmodel.rsg> |
|
27 #include "T_UTILS.H" |
|
28 |
|
29 CCntTest* CntTest=NULL; |
|
30 LOCAL_D RTest test(_L("T_TEMPL")); |
|
31 |
|
32 const TPtrC KDatabaseFileName=_L("C:T_TEMPL"); |
|
33 |
|
34 const TInt KTotalFindRecords=20; |
|
35 |
|
36 #define KCardGivenName _L("Given Name #%d") |
|
37 #define KCardFamilyName _L("Family Name #%d") |
|
38 #define KCardFieldText _L("Card id %d, text field #%d") |
|
39 #define KCardFieldEditedText _L("UPDATED Card id %d, text field #%d") |
|
40 |
|
41 LOCAL_C void CreateDatabaseL() |
|
42 // |
|
43 // Create a database in a store and add some contact cards |
|
44 // |
|
45 { |
|
46 CContactDatabase *db=CntTest->CreateDatabaseL(); |
|
47 test.Next(_L("Add basic cards")); |
|
48 CContactCard* card=CContactCard::NewL(); |
|
49 CleanupStack::PushL(card); |
|
50 for (TInt ii=0;ii<20;ii++) |
|
51 { |
|
52 db->AddNewContactL(*card); |
|
53 } |
|
54 CleanupStack::PopAndDestroy(); // card |
|
55 CntTest->CloseDatabase(); |
|
56 } |
|
57 |
|
58 LOCAL_C void AddFieldL(CContactItem *aItem,TFieldType aFieldType, const TDesC &aLabel, const TDesC &aFieldText) |
|
59 { |
|
60 CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,aFieldType); |
|
61 field->SetLabelL(aLabel); |
|
62 aItem->AddFieldL(*field); |
|
63 if (aFieldText.Length()>0) |
|
64 field->TextStorage()->SetTextL(aFieldText); |
|
65 CleanupStack::Pop(); // field |
|
66 } |
|
67 |
|
68 LOCAL_C void AddDateFieldL(CContactItem *aItem,TFieldType aFieldType, const TDesC &aLabel, TDateTime *aDateTime) |
|
69 { |
|
70 CContactItemField* field=CContactItemField::NewLC(KStorageTypeDateTime,aFieldType); |
|
71 field->SetLabelL(aLabel); |
|
72 aItem->AddFieldL(*field); |
|
73 if (aDateTime) |
|
74 field->DateTimeStorage()->SetTime(*aDateTime); |
|
75 CleanupStack::Pop(); // field |
|
76 } |
|
77 |
|
78 LOCAL_C CContactItem* ReadContactIncHiddenFieldsLC(CContactDatabase* aDb, TContactItemId aContactId) |
|
79 { |
|
80 CContactItemViewDef *viewDef=CContactItemViewDef::NewLC(CContactItemViewDef::EMaskFields,CContactItemViewDef::EIncludeHiddenFields); |
|
81 CContactItem *contact=aDb->ReadContactL(aContactId,*viewDef); |
|
82 CleanupStack::PopAndDestroy(); // viewDef |
|
83 CleanupStack::PushL(contact); |
|
84 return(contact); |
|
85 } |
|
86 |
|
87 LOCAL_C void doTestTemplate(CContactDatabase* aDb, TContactItemId aTemplateId,CContactTemplate* aContactTemplate, TBool aTemplateLabelRemoved) |
|
88 { |
|
89 CContactItem *checkTemplate=ReadContactIncHiddenFieldsLC(aDb,aTemplateId); |
|
90 test(CompareItemFields(aContactTemplate,checkTemplate)); |
|
91 CleanupStack::PopAndDestroy(); // checkTemplate |
|
92 // |
|
93 CContactCard *copy=CContactCard::NewLC(aContactTemplate); |
|
94 // fails due to template lable being removed. // test code needs fixing |
|
95 test(CompareItemFields(aContactTemplate,copy,EFalse,aTemplateLabelRemoved)); |
|
96 CleanupStack::PopAndDestroy(); // copy |
|
97 } |
|
98 |
|
99 LOCAL_C void CheckDefaultTemplate(CContactDatabase* aDb, RFs& aFs, TContactItemId aSystemTemplateId) |
|
100 { |
|
101 test.Next(_L("System template")); |
|
102 |
|
103 _LIT(KCntSystemTemplate,"z:\\resource\\cntmodel\\cntmodel.rsc"); |
|
104 |
|
105 TFileName fileName(KCntSystemTemplate); |
|
106 BaflUtils::NearestLanguageFile(aFs,fileName); |
|
107 // |
|
108 RResourceFile resourceFile; |
|
109 resourceFile.OpenL(CntTest->Fs(),fileName); |
|
110 CleanupClosePushL(resourceFile); |
|
111 resourceFile.ConfirmSignatureL(4); |
|
112 TResourceReader resReader; |
|
113 resReader.SetBuffer(resourceFile.AllocReadLC(R_CNTUI_NEW_FIELD_DEFNS)); |
|
114 // |
|
115 CContactTemplate *testTemplate=CContactTemplate::NewLC(); |
|
116 TInt count=resReader.ReadInt16(); // num fields |
|
117 while(count--) |
|
118 { |
|
119 TStorageType storageType=resReader.ReadInt32(); |
|
120 TUid contactFieldUid=TUid::Uid(resReader.ReadInt32()); |
|
121 TUid vCardMappingUid=TUid::Uid(resReader.ReadInt32()); |
|
122 // |
|
123 CContactItemField* field=CContactItemField::NewLC(storageType); |
|
124 // |
|
125 field->SetMapping(vCardMappingUid); |
|
126 if (contactFieldUid!=KUidContactFieldNone) |
|
127 field->AddFieldTypeL(contactFieldUid); |
|
128 // |
|
129 TInt mappingCount; |
|
130 if((mappingCount=resReader.ReadInt16())!=0) |
|
131 { |
|
132 while(mappingCount--) |
|
133 field->AddFieldTypeL(TUid::Uid(resReader.ReadInt32())); |
|
134 } |
|
135 field->SetUserFlags(resReader.ReadInt32()); |
|
136 field->SetLabel(resReader.ReadHBufCL()); |
|
137 TUint flags=resReader.ReadInt32(); |
|
138 if (flags&EContactFieldFlagHidden) |
|
139 field->SetHidden(ETrue); |
|
140 if (flags&EContactFieldFlagReadOnly) |
|
141 field->SetReadOnly(ETrue); |
|
142 if (flags&EContactFieldFlagSynchronize) |
|
143 field->SetSynchronize(ETrue); |
|
144 if (flags&EContactFieldFlagDisabled) |
|
145 field->SetDisabled(ETrue); |
|
146 // |
|
147 testTemplate->AddFieldL(*field); |
|
148 CleanupStack::Pop(); |
|
149 } |
|
150 doTestTemplate(aDb,aSystemTemplateId,testTemplate,ETrue); |
|
151 CleanupStack::PopAndDestroy(3); // testTemplate,resourceFile close, resBuffer |
|
152 } |
|
153 |
|
154 LOCAL_C void SetNameL(CContactItem& aItem,TUid aType,const TDesC& aName, TBool aAddField) |
|
155 // |
|
156 // Set the contents of a text field, creating the field if required |
|
157 // |
|
158 { |
|
159 CContactItemFieldSet& fieldSet=aItem.CardFields(); |
|
160 const TInt pos=fieldSet.Find(aType); |
|
161 if (!aAddField && pos!=KErrNotFound) |
|
162 fieldSet[pos].TextStorage()->SetTextL(aName); |
|
163 else |
|
164 { |
|
165 CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,aType); |
|
166 field->SetMapping(KUidContactFieldVCardMapUnusedN); |
|
167 field->TextStorage()->SetTextL(aName); |
|
168 aItem.AddFieldL(*field); |
|
169 CleanupStack::Pop(); // item |
|
170 } |
|
171 } |
|
172 |
|
173 LOCAL_C void AddFindRecordsL(CContactDatabase* aDb) |
|
174 { |
|
175 CContactItem* systemTemplate=ReadContactIncHiddenFieldsLC(aDb,aDb->TemplateId()); |
|
176 for (TInt ii=0;ii<KTotalFindRecords;ii++) |
|
177 { |
|
178 CContactItem* item=CContactCard::NewLC(systemTemplate); |
|
179 TBuf<16> name; |
|
180 if (ii%2) |
|
181 { |
|
182 name.Format(_L("Bates %d"),ii); |
|
183 SetNameL(*item,KUidContactFieldJobTitle,name,EFalse); |
|
184 //SetNameL(*item,KUidContactFieldFamilyName,name,EFalse); |
|
185 SetNameL(*item,KUidContactFieldGivenName,_L("Norman"),EFalse); |
|
186 } |
|
187 else |
|
188 { |
|
189 name.Format(_L("Sod %d"),ii); |
|
190 SetNameL(*item,KUidContactFieldFamilyName,name,EFalse); |
|
191 SetNameL(*item,KUidContactFieldGivenName,_L("Silly"),EFalse); |
|
192 } |
|
193 if (ii%3) |
|
194 { |
|
195 CContactItemField* field=CContactItemField::NewLC(KStorageTypeDateTime,KUidContactFieldBirthday); |
|
196 field->DateTimeStorage()->SetTime(TDateTime(1990+ii,(TMonth)(ii%12),(ii*3)%28,1,2,3,4)); |
|
197 item->AddFieldL(*field); |
|
198 CleanupStack::Pop(); // field |
|
199 } |
|
200 aDb->AddNewContactL(*item); |
|
201 CleanupStack::PopAndDestroy(); // item |
|
202 } |
|
203 CleanupStack::PopAndDestroy(); // systemTemplate |
|
204 } |
|
205 |
|
206 LOCAL_C void TestSystemTemplateL() |
|
207 { |
|
208 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
209 // add fields to cards to system template |
|
210 CheckDefaultTemplate(db,CntTest->Fs(),db->TemplateId()); |
|
211 // |
|
212 CContactTemplate *contactTemplate=(CContactTemplate *)db->OpenContactLX(db->TemplateId()); |
|
213 CleanupStack::PushL(contactTemplate); |
|
214 AddFieldL(contactTemplate,TUid::Uid(1),_L("Uid1"),_L("")); |
|
215 AddFieldL(contactTemplate,TUid::Uid(2),_L("Uid2"),_L("")); |
|
216 AddFieldL(contactTemplate,TUid::Uid(3),_L("Uid3"),_L("")); |
|
217 AddDateFieldL(contactTemplate,TUid::Uid(4),_L("Uid4"),NULL); |
|
218 db->CommitContactL(*contactTemplate); |
|
219 doTestTemplate(db,db->TemplateId(),contactTemplate,ETrue); |
|
220 CleanupStack::PopAndDestroy(2); // contactTemplate,contactTemplate.Close() |
|
221 // |
|
222 AddFindRecordsL(db); |
|
223 |
|
224 CContactItemFieldDef* fieldDef=new(ELeave) CContactItemFieldDef; |
|
225 CleanupStack::PushL(fieldDef); |
|
226 fieldDef->AppendL(KUidContactFieldJobTitle); |
|
227 CContactIdArray* idarray=db->FindLC(_L("Bates 3"),fieldDef); |
|
228 test(idarray->Count()==1); |
|
229 // |
|
230 // Now change the field KUidContactFieldFamilyName field type to Uid(44) and check |
|
231 // the records field type also changes. |
|
232 // |
|
233 contactTemplate=(CContactTemplate *)db->OpenContactLX(db->TemplateId()); |
|
234 CleanupStack::PushL(contactTemplate); |
|
235 CContactItemFieldSet& fieldSet=contactTemplate->CardFields(); |
|
236 TInt fieldNum=fieldSet.Find(KUidContactFieldJobTitle); |
|
237 CContentType &ct=(CContentType&)fieldSet[fieldNum].ContentType(); |
|
238 ct.RemoveFieldType(KUidContactFieldJobTitle); |
|
239 TUid newUidType=TUid::Uid(44); |
|
240 ct.AddFieldTypeL(newUidType); |
|
241 db->CommitContactL(*contactTemplate); |
|
242 // |
|
243 CContactItem *checkItem=(CContactTemplate *)db->ReadContactLC((*idarray)[0]); |
|
244 CContactItemFieldSet& templateFieldSet=checkItem->CardFields(); |
|
245 test(templateFieldSet.Find(KUidContactFieldJobTitle)==KErrNotFound); |
|
246 test(templateFieldSet.Find(newUidType)!=KErrNotFound); |
|
247 CleanupStack::PopAndDestroy(1); // checkItem |
|
248 // |
|
249 // Check finding using the new field type also works |
|
250 // |
|
251 fieldDef->Delete(0); |
|
252 fieldDef->AppendL(newUidType); |
|
253 CContactIdArray* idarray2=db->FindLC(_L("Bates 3"),fieldDef); |
|
254 test(idarray2->Count()==1); |
|
255 test((*idarray2)[0]==(*idarray)[0]); |
|
256 CleanupStack::PopAndDestroy(5); // fieldDef,idarray2,idarray,contactTemplate,contactTemplate.Close() |
|
257 // |
|
258 CntTest->CloseDatabase(); |
|
259 } |
|
260 |
|
261 LOCAL_C void TestSystemTemplateRestorationL() |
|
262 { |
|
263 // Any field values present in the template are stripped out when the template is |
|
264 // added to the database. However, it is still possible to store default values in |
|
265 // a template if the template is first added, and then updated with default data present. |
|
266 |
|
267 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
268 |
|
269 // create a new contact template |
|
270 CContactItem* contactTemplate=db->CreateContactCardTemplateLC(_L("fieldDataNotRestoredTemplate")); |
|
271 TContactItemId id=contactTemplate->Id(); |
|
272 CleanupStack::PopAndDestroy(contactTemplate); |
|
273 // add some data to one of the template fields |
|
274 CContactTemplate *openTemplate=(CContactTemplate *)db->OpenContactLX(id); |
|
275 CleanupStack::PushL(openTemplate); |
|
276 CContactItemFieldSet& fieldSet=openTemplate->CardFields(); |
|
277 TInt pos=fieldSet.Find(KUidContactFieldGivenName); |
|
278 test(fieldSet[pos].TextStorage()->Text() == KNullDesC); |
|
279 TBuf<12> givenName = _L("a given name"); |
|
280 SetNameL(*openTemplate,KUidContactFieldGivenName,givenName,EFalse); |
|
281 // check the field value is set |
|
282 CContactItemFieldSet& fieldSet2=openTemplate->CardFields(); |
|
283 pos=fieldSet2.Find(KUidContactFieldGivenName); |
|
284 test(fieldSet2[pos].TextStorage()->Text() == givenName); |
|
285 db->CommitContactL(*openTemplate); |
|
286 CleanupStack::PopAndDestroy(2); // openTemplate, openTemplate.Close() |
|
287 // the field value should still be set |
|
288 CContactItem* contactTemplate2=db->ReadContactLC(id); |
|
289 CContactItemFieldSet& fieldSet3=contactTemplate2->CardFields(); |
|
290 pos=fieldSet3.Find(KUidContactFieldGivenName); |
|
291 test(fieldSet3[pos].TextStorage()->Text() == givenName); |
|
292 CleanupStack::PopAndDestroy(contactTemplate2); |
|
293 |
|
294 CntTest->CloseDatabase(); |
|
295 } |
|
296 |
|
297 LOCAL_C void TestTemplateLabelsL() |
|
298 { |
|
299 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
300 // |
|
301 CContactItem *contactTemplate=ReadContactIncHiddenFieldsLC(db,db->TemplateId()); |
|
302 CContactItem *card=CContactCard::NewLC(contactTemplate); |
|
303 CContactItemFieldSet& fieldSet=card->CardFields(); |
|
304 fieldSet[0].TextStorage()->SetTextL(_L("Sum text")); |
|
305 fieldSet[2].TextStorage()->SetTextL(_L("Some more text")); |
|
306 TContactItemId id1=db->AddNewContactL(*card); |
|
307 // |
|
308 CContactItem *card2=ReadContactIncHiddenFieldsLC(db,id1); |
|
309 test(CompareItemFields(contactTemplate,card2,EFalse,ETrue)); |
|
310 // |
|
311 CContactItem *contactTemplate2=ReadContactIncHiddenFieldsLC(db,db->TemplateId()); |
|
312 |
|
313 CContactItem *card3=CContactCard::NewLC(contactTemplate2); |
|
314 CContactItemFieldSet& fieldSet2=card3->CardFields(); |
|
315 fieldSet2[0].SetLabelL(_L("Label Zero")); |
|
316 fieldSet2[0].TextStorage()->SetTextL(_L("x")); |
|
317 fieldSet2[1].TextStorage()->SetTextL(_L("x")); |
|
318 fieldSet2[2].SetLabelL(_L("Label Too")); |
|
319 TContactItemId id2=db->AddNewContactL(*card3); |
|
320 fieldSet2[1].SetLabelL(fieldSet[1].Label()); // Should be reset because SetLabelUnspecified is true |
|
321 fieldSet2[2].SetLabelL(fieldSet[2].Label()); // Should be reset because field is empty |
|
322 // |
|
323 CContactItem *card4=ReadContactIncHiddenFieldsLC(db,id2); |
|
324 test(CompareItemFields(card3,card4,EFalse)); |
|
325 CleanupStack::PopAndDestroy(3); // template2,card3,card4 |
|
326 CleanupStack::PopAndDestroy(3); // card,card2,template,template.Close() |
|
327 // |
|
328 CContactTemplate *openTemplate=(CContactTemplate *)db->OpenContactLX(db->TemplateId()); |
|
329 CleanupStack::PushL(openTemplate); |
|
330 CContactItemFieldSet& templateFieldSet=openTemplate->CardFields(); |
|
331 templateFieldSet[1].SetDisabled(ETrue); |
|
332 templateFieldSet[1].SetReadOnly(ETrue); |
|
333 db->CommitContactL(*openTemplate); |
|
334 CContactItem *card5=ReadContactIncHiddenFieldsLC(db,id1); |
|
335 test(CompareItemFields(openTemplate,card5,EFalse,ETrue)); |
|
336 CleanupStack::PopAndDestroy(3); // card5, openTemplate, openTemplate.Close() |
|
337 // |
|
338 openTemplate=(CContactTemplate *)db->OpenContactLX(db->TemplateId()); |
|
339 CleanupStack::PushL(openTemplate); |
|
340 openTemplate->CardFields()[1].SetReadOnly(EFalse); |
|
341 openTemplate->CardFields()[1].SetDisabled(EFalse); |
|
342 db->CommitContactL(*openTemplate); |
|
343 CleanupStack::PopAndDestroy(2); // openTemplate, openTemplate.Close() |
|
344 // |
|
345 CntTest->CloseDatabase(); |
|
346 } |
|
347 |
|
348 LOCAL_C CContactItemField *doAddFieldL(CContactItem *aItem,TFieldType aMapping,TInt aPos, const TDesC &aLabel,TFieldType *aFieldType1,TFieldType *aFieldType2,TFieldType *aFieldType3) |
|
349 { |
|
350 CContactItemField* field=CContactItemField::NewLC(KStorageTypeText); |
|
351 field->SetMapping(aMapping); |
|
352 field->SetLabelL(aLabel); |
|
353 if (aFieldType1) |
|
354 { |
|
355 field->AddFieldTypeL(*aFieldType1); |
|
356 if (aFieldType2) |
|
357 { |
|
358 field->AddFieldTypeL(*aFieldType2); |
|
359 if (aFieldType3) |
|
360 field->AddFieldTypeL(*aFieldType3); |
|
361 } |
|
362 } |
|
363 if (aPos<0) |
|
364 aItem->AddFieldL(*field); |
|
365 else |
|
366 aItem->InsertFieldL(*field,aPos); |
|
367 CleanupStack::Pop(); // field |
|
368 return(field); |
|
369 } |
|
370 |
|
371 LOCAL_C CContactItemField *InsertFieldL(CContactItem *aItem,TFieldType aMapping,TInt aPos,const TDesC &aLabel,TFieldType *aFieldType1=NULL,TFieldType *aFieldType2=NULL,TFieldType *aFieldType3=NULL) |
|
372 { |
|
373 return(doAddFieldL(aItem,aMapping,aPos,aLabel,aFieldType1,aFieldType2,aFieldType3)); |
|
374 } |
|
375 |
|
376 LOCAL_C CContactItemField *AddFieldL(CContactItem *aItem,TFieldType aMapping,const TDesC &aLabel,TFieldType *aFieldType1=NULL,TFieldType *aFieldType2=NULL,TFieldType *aFieldType3=NULL) |
|
377 { |
|
378 return(doAddFieldL(aItem,aMapping,-1,aLabel,aFieldType1,aFieldType2,aFieldType3)); |
|
379 } |
|
380 |
|
381 struct TTemplateMapTest |
|
382 { |
|
383 public: |
|
384 inline TTemplateMapTest(TFieldType aMapping,TFieldType *aFieldType1,TFieldType *aFieldType2,TFieldType *aFieldType3, const TDesC &aFieldName, TInt aFieldNumber, TBool aExactContentMatch, TFieldType *aExtraField=NULL, TFieldType *aMissingField=NULL) : |
|
385 iMapping(aMapping),iFieldType1(aFieldType1),iFieldType2(aFieldType2),iFieldType3(aFieldType3),iFieldNumber(aFieldNumber),iExactContentMatch(aExactContentMatch),iExtraField(aExtraField),iMissingField(aMissingField) |
|
386 {iFieldName.Set(aFieldName);}; |
|
387 CContentType *ContentTypeLC() const; |
|
388 public: |
|
389 TFieldType iMapping; |
|
390 TFieldType *iFieldType1; |
|
391 TFieldType *iFieldType2; |
|
392 TFieldType *iFieldType3; |
|
393 TPtrC iFieldName; |
|
394 TInt iFieldNumber; |
|
395 TBool iExactContentMatch; |
|
396 TFieldType *iExtraField; |
|
397 TFieldType *iMissingField; |
|
398 }; |
|
399 |
|
400 CContentType *TTemplateMapTest::ContentTypeLC() const |
|
401 { |
|
402 CContentType *ct=CContentType::NewL(*iFieldType1,iMapping); |
|
403 CleanupStack::PushL(ct); |
|
404 if (iFieldType2) |
|
405 ct->AddFieldTypeL(*iFieldType2); |
|
406 if (iFieldType3) |
|
407 ct->AddFieldTypeL(*iFieldType3); |
|
408 return(ct); |
|
409 } |
|
410 |
|
411 LOCAL_C void AddTestField(CContactCard* aCard,TTemplateMapTest *aTmtest, const TDesC &aText, TInt &aExtraFields) |
|
412 { |
|
413 if (aTmtest) |
|
414 { |
|
415 CContactItemField *field=AddFieldL(aCard,aTmtest->iMapping,aTmtest->iFieldName,aTmtest->iFieldType1,aTmtest->iFieldType2,aTmtest->iFieldType3); |
|
416 field->TextStorage()->SetTextL(aText); |
|
417 if (aTmtest->iExtraField) |
|
418 aExtraFields++; |
|
419 } |
|
420 } |
|
421 |
|
422 LOCAL_C void CheckFieldMappings(CContactDatabase* aDb, CContactItem *aTemplateItem, TTemplateMapTest *aTmtest1,TTemplateMapTest *aTmtest2=NULL,TTemplateMapTest *aTmtest3=NULL,TTemplateMapTest *aTmtest4=NULL) |
|
423 { |
|
424 CContactCard* card=CContactCard::NewLC(aTemplateItem); |
|
425 // |
|
426 TInt extraFields=0; |
|
427 AddTestField(card,aTmtest1,_L("Test 1"),extraFields); |
|
428 AddTestField(card,aTmtest2,_L("Test 2"),extraFields); |
|
429 AddTestField(card,aTmtest3,_L("Test 3"),extraFields); |
|
430 AddTestField(card,aTmtest4,_L("Test 4"),extraFields); |
|
431 TContactItemId testCardId=aDb->AddNewContactL(*card); |
|
432 CleanupStack::PopAndDestroy(); // card |
|
433 // |
|
434 TTemplateMapTest *testData[4]={aTmtest1,aTmtest2,aTmtest3,aTmtest4}; |
|
435 //ere |
|
436 CContactItem *readCard=ReadContactIncHiddenFieldsLC(aDb,testCardId); |
|
437 CContactItemFieldSet& fieldSet=readCard->CardFields(); |
|
438 CContactItemFieldSet& templateFieldSet=aTemplateItem->CardFields(); |
|
439 test((templateFieldSet.Count()+extraFields)==fieldSet.Count()); |
|
440 TInt loop=0; |
|
441 for(;loop<templateFieldSet.Count();loop++) |
|
442 { |
|
443 const CContactItemField &field=fieldSet[loop]; |
|
444 const CContactItemField &templateField=templateFieldSet[loop]; |
|
445 for(TInt loop2=0;loop2<4;loop2++) |
|
446 { |
|
447 TBuf<8> fieldText; |
|
448 fieldText.Format(_L("Test %d"),loop2+1); |
|
449 if (field.TextStorage()->Text()==fieldText) |
|
450 { |
|
451 TPtrC temp = testData[loop2]->iFieldName; |
|
452 test(field.Label()==temp); |
|
453 TInt fieldNumber=testData[loop2]->iFieldNumber; |
|
454 test((loop+1)==fieldNumber); |
|
455 CContentType *ct=testData[loop2]->ContentTypeLC(); |
|
456 test(field.ContentType()==*ct); |
|
457 TBool templateContentMatch=(templateField.ContentType()==*ct); |
|
458 test(testData[loop2]->iExactContentMatch?templateContentMatch:!templateContentMatch); |
|
459 test(templateField.UserFlags()==field.UserFlags()); |
|
460 test(templateField.ContentType()==aDb->TemplateContentType(field)); |
|
461 CleanupStack::PopAndDestroy(); // ct |
|
462 } |
|
463 } |
|
464 } |
|
465 TInt nextTmTest=0; |
|
466 for(;loop<fieldSet.Count();loop++) |
|
467 { |
|
468 while(testData[nextTmTest]->iExtraField==NULL && testData[nextTmTest]->iMissingField==NULL) |
|
469 nextTmTest++; |
|
470 if (testData[nextTmTest]->iExtraField) |
|
471 test(fieldSet[loop].ContentType().ContainsFieldType(*testData[nextTmTest]->iExtraField)); |
|
472 if (testData[nextTmTest]->iMissingField) |
|
473 { |
|
474 test(!fieldSet[loop].ContentType().ContainsFieldType(*testData[nextTmTest]->iMissingField)); |
|
475 test(aDb->TemplateContentType(fieldSet[loop]).ContainsFieldType(*testData[nextTmTest]->iMissingField)); |
|
476 } |
|
477 nextTmTest++; |
|
478 } |
|
479 CleanupStack::PopAndDestroy(); // readCard |
|
480 // |
|
481 aDb->DeleteContactL(testCardId); |
|
482 } |
|
483 |
|
484 LOCAL_C void TestTemplateFieldMatchingL() |
|
485 { |
|
486 test.Next(_L("Create template")); |
|
487 CreateDatabaseL(); |
|
488 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
489 CntTest->DeleteAllTemplateFieldsL(); |
|
490 // |
|
491 _LIT(KField1,"Field 1"); |
|
492 _LIT(KField2,"Field 2"); |
|
493 _LIT(KField3,"Field 3"); |
|
494 _LIT(KField4,"Field 4"); |
|
495 _LIT(KField5,"Field 5"); |
|
496 _LIT(KField6,"Field 6"); |
|
497 _LIT(KField7,"Field 7"); |
|
498 _LIT(KField8,"Field 8"); |
|
499 _LIT(KField9,"Field 9"); |
|
500 _LIT(KFieldX1,"Field X1"); |
|
501 _LIT(KFieldX2,"Field X2"); |
|
502 _LIT(KFieldHome,"Field Home"); |
|
503 _LIT(KFieldWork,"Field Work"); |
|
504 // |
|
505 CContactTemplate *contactTemplate=(CContactTemplate *)db->OpenContactLX(db->TemplateId()); |
|
506 CleanupStack::PushL(contactTemplate); |
|
507 TFieldType mapping1(TUid::Uid(1)); |
|
508 TFieldType mapping2(TUid::Uid(2)); |
|
509 TFieldType mapping3(TUid::Uid(3)); |
|
510 TFieldType mapping4(TUid::Uid(4)); |
|
511 TFieldType mappingX(KUidContactFieldVCardMapUnusedN); |
|
512 TFieldType fieldType1(TUid::Uid(101)); |
|
513 TFieldType fieldType2(TUid::Uid(102)); |
|
514 TFieldType fieldType3(TUid::Uid(103)); |
|
515 TFieldType fieldType4(TUid::Uid(104)); |
|
516 TFieldType fieldType5(TUid::Uid(105)); |
|
517 TFieldType fieldTypeHome(TUid::Uid(KIntContactFieldVCardMapHOME)); |
|
518 TFieldType fieldTypeWork(TUid::Uid(KIntContactFieldVCardMapWORK)); |
|
519 AddFieldL(contactTemplate,mapping1,KField1()); |
|
520 SetUserFlags(contactTemplate,1); |
|
521 AddFieldL(contactTemplate,mapping2,KField2(),&fieldType2); |
|
522 SetUserFlags(contactTemplate,2); |
|
523 AddFieldL(contactTemplate,mapping2,KField3(),&fieldType3); |
|
524 SetUserFlags(contactTemplate,3); |
|
525 AddFieldL(contactTemplate,mapping3,KField4(),&fieldType2); |
|
526 SetUserFlags(contactTemplate,0); |
|
527 AddFieldL(contactTemplate,mapping3,KField5(),&fieldType2,&fieldType4); |
|
528 SetUserFlags(contactTemplate,1); |
|
529 AddFieldL(contactTemplate,mapping3,KField6(),&fieldType2,&fieldType1); |
|
530 SetUserFlags(contactTemplate,2); |
|
531 AddFieldL(contactTemplate,mapping4,KField8(),&fieldType4); |
|
532 SetUserFlags(contactTemplate,3); |
|
533 InsertFieldL(contactTemplate,mapping4,6,KField7()); |
|
534 SetUserFlags(contactTemplate,0); |
|
535 AddFieldL(contactTemplate,mapping4,KField9(),&fieldType4,&fieldType2,&fieldType1); |
|
536 SetUserFlags(contactTemplate,1); |
|
537 AddFieldL(contactTemplate,mappingX,KFieldX1()); |
|
538 SetUserFlags(contactTemplate,2); |
|
539 AddFieldL(contactTemplate,mappingX,KFieldX2(),&fieldType2); |
|
540 SetUserFlags(contactTemplate,3); |
|
541 AddFieldL(contactTemplate,mapping1,KFieldHome(),&fieldType1,&fieldType5,&fieldTypeHome); |
|
542 SetUserFlags(contactTemplate,0); |
|
543 AddFieldL(contactTemplate,mapping1,KFieldWork(),&fieldType1,&fieldType5,&fieldTypeWork); |
|
544 |
|
545 SetUserFlags(contactTemplate,0); |
|
546 db->CommitContactL(*contactTemplate); |
|
547 CleanupStack::PopAndDestroy(); // contactTemplate |
|
548 CleanupStack::Pop(); // contactTemplate.Close() |
|
549 // |
|
550 TTemplateMapTest tmTest1(mapping1,&fieldType4,NULL,NULL,KField1(),1,EFalse); |
|
551 TTemplateMapTest tmTest2(mapping2,&fieldType1,NULL,NULL,KField2(),2,EFalse); |
|
552 TTemplateMapTest tmTest3(mapping2,&fieldType2,NULL,NULL,KField2(),2,ETrue); |
|
553 TTemplateMapTest tmTest4(mapping2,&fieldType3,NULL,NULL,KField3(),3,ETrue); |
|
554 TTemplateMapTest tmTest5(mapping3,&fieldType4,NULL,NULL,KField5(),5,EFalse); |
|
555 TTemplateMapTest tmTest6(mapping3,&fieldType1,NULL,NULL,KField6(),6,EFalse); |
|
556 TTemplateMapTest tmTest7(mapping3,&fieldType2,&fieldType4,NULL,KField5(),5,ETrue); |
|
557 TTemplateMapTest tmTest8(mapping4,&fieldType3,NULL,NULL,KField7(),7,EFalse); |
|
558 TTemplateMapTest tmTest9(mapping4,&fieldType4,NULL,NULL,KField8(),8,ETrue); |
|
559 TTemplateMapTest tmTest10(mapping4,&fieldType4,&fieldType2,NULL,KField9(),9,EFalse); |
|
560 TTemplateMapTest tmTestX1(mappingX,&fieldType4,NULL,NULL,KFieldX1(),10,EFalse,&mappingX); |
|
561 TTemplateMapTest tmTestX2(mappingX,&fieldType2,NULL,NULL,KFieldX2(),11,ETrue); |
|
562 TTemplateMapTest tmTestWork(mapping1,&fieldType1,&fieldType5,NULL,KFieldWork(),13,EFalse,NULL,&fieldTypeWork);//zzz change to work |
|
563 contactTemplate=(CContactTemplate *)ReadContactIncHiddenFieldsLC(db,db->TemplateId()); |
|
564 CheckFieldMappings(db,contactTemplate,&tmTest1); |
|
565 CheckFieldMappings(db,contactTemplate,&tmTest1,&tmTest3,&tmTest4); |
|
566 CheckFieldMappings(db,contactTemplate,&tmTest5,&tmTest2,&tmTest1,&tmTest6); |
|
567 CheckFieldMappings(db,contactTemplate,&tmTest7,&tmTest10,&tmTest8); |
|
568 CheckFieldMappings(db,contactTemplate,&tmTest9); |
|
569 CheckFieldMappings(db,contactTemplate,&tmTestX1); |
|
570 CheckFieldMappings(db,contactTemplate,&tmTestX2); |
|
571 CheckFieldMappings(db,contactTemplate,&tmTestWork); |
|
572 // |
|
573 CleanupStack::PopAndDestroy(); // contactTemplate |
|
574 CntTest->CloseDatabase(); |
|
575 } |
|
576 |
|
577 LOCAL_C void TestTemplateContentTypeL() |
|
578 { |
|
579 CreateDatabaseL(); |
|
580 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
581 CContactItem* systemTemplate=ReadContactIncHiddenFieldsLC(db,db->TemplateId()); |
|
582 CContactCard *card=CContactCard::NewLC(systemTemplate); |
|
583 CContactItemFieldSet& fieldSet=card->CardFields(); |
|
584 for(TInt loop=0;loop<fieldSet.Count();loop++) |
|
585 test(db->TemplateContentType(fieldSet[loop])==fieldSet[loop].ContentType()); |
|
586 CleanupStack::PopAndDestroy(2); // systemTemplate,card |
|
587 CntTest->CloseDatabase(); |
|
588 } |
|
589 |
|
590 LOCAL_C void TestMultiTemplateCacheL() |
|
591 { |
|
592 test.Next(_L("Create template")); |
|
593 CreateDatabaseL(); |
|
594 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
595 CntTest->DeleteAllTemplateFieldsL(); |
|
596 // |
|
597 CContactTemplate* contactTemplate=CContactTemplate::NewLC(); |
|
598 TContactItemId id1=db->AddNewContactL(*contactTemplate); |
|
599 CleanupStack::PopAndDestroy(); // contactTemplate |
|
600 contactTemplate=(CContactTemplate *)db->ReadContactLC(id1); |
|
601 // add fields to cards |
|
602 AddFieldL(contactTemplate,KUidContactFieldGivenName,_L("First name"),_L("Bilbo")); |
|
603 AddFieldL(contactTemplate,KUidContactFieldFamilyName,_L("Surname"),_L("Baggins")); |
|
604 AddFieldL(contactTemplate,KUidContactFieldCompanyName,_L("Company"),_L("Great Ape Software")); |
|
605 TDateTime dt(1965,EJuly,15,0,0,0,0); |
|
606 AddDateFieldL(contactTemplate,KUidContactFieldNone,_L("Birthday"),&dt); |
|
607 // |
|
608 TContactItemId templateId=db->AddNewContactL(*contactTemplate); |
|
609 // |
|
610 doTestTemplate(db,templateId,contactTemplate,EFalse); |
|
611 CleanupStack::PopAndDestroy(); // contactTemplate |
|
612 CntTest->CloseDatabase(); |
|
613 } |
|
614 |
|
615 LOCAL_C void TestTemplateL() |
|
616 { |
|
617 test.Next(_L("Create template")); |
|
618 CreateDatabaseL(); |
|
619 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
620 CntTest->DeleteAllTemplateFieldsL(); |
|
621 // |
|
622 CContactTemplate* contactTemplate=CContactTemplate::NewLC(); |
|
623 TContactItemId id1=db->AddNewContactL(*contactTemplate); |
|
624 CleanupStack::PopAndDestroy(); // contactTemplate |
|
625 contactTemplate=(CContactTemplate *)db->ReadContactLC(id1); |
|
626 // add fields to cards |
|
627 AddFieldL(contactTemplate,KUidContactFieldGivenName,_L("First name"),_L("Bilbo")); |
|
628 AddFieldL(contactTemplate,KUidContactFieldFamilyName,_L("Surname"),_L("Baggins")); |
|
629 AddFieldL(contactTemplate,KUidContactFieldCompanyName,_L("Company"),_L("Great Ape Software")); |
|
630 TDateTime dt(1965,EJuly,15,0,0,0,0); |
|
631 AddDateFieldL(contactTemplate,KUidContactFieldNone,_L("Birthday"),&dt); |
|
632 // |
|
633 TContactItemId templateId=db->AddNewContactL(*contactTemplate); |
|
634 // |
|
635 doTestTemplate(db,templateId,contactTemplate,EFalse); |
|
636 CleanupStack::PopAndDestroy(); // contactTemplate |
|
637 CntTest->CloseDatabase(); |
|
638 } |
|
639 |
|
640 LOCAL_C void TestSystemTemplateFieldsL() |
|
641 { |
|
642 // create a new db and checks the template fields for instances of LOGO, PHOTO, JOB TITLE |
|
643 CContactDatabase* db=CntTest->CreateDatabaseL(); |
|
644 |
|
645 CContactTemplate *contactTemplate=(CContactTemplate *)db->OpenContactLX(db->TemplateId()); |
|
646 CleanupStack::PushL(contactTemplate); |
|
647 CContactItemFieldSet& templateFieldSet = contactTemplate->CardFields(); |
|
648 TInt templateFieldCount = templateFieldSet.Count(); |
|
649 TBool titleFound=EFalse; |
|
650 TBool logoFound=EFalse; |
|
651 TBool photoFound=EFalse; |
|
652 for (TInt ii=0; ii < templateFieldCount; ii++) |
|
653 { |
|
654 |
|
655 // JOB TITLE SEARCH |
|
656 if (templateFieldSet[ii].ContentType().ContainsFieldType(KUidContactFieldVCardMapTITLE)) |
|
657 { |
|
658 // SATISFIED |
|
659 titleFound=ETrue; |
|
660 } |
|
661 |
|
662 // LOGO SEARCH |
|
663 if (templateFieldSet[ii].ContentType().ContainsFieldType(KUidContactFieldVCardMapLOGO)) |
|
664 { |
|
665 // SATISFIED |
|
666 logoFound=ETrue; |
|
667 } |
|
668 |
|
669 // LOGO SEARCH |
|
670 if (templateFieldSet[ii].ContentType().ContainsFieldType(KUidContactFieldVCardMapPHOTO)) |
|
671 { |
|
672 // SATISFIED |
|
673 photoFound=ETrue; |
|
674 } |
|
675 }; |
|
676 test(photoFound); |
|
677 test(logoFound); |
|
678 test(titleFound); |
|
679 |
|
680 CleanupStack::PopAndDestroy(2); // contactTemplate,contactTemplate.Close() |
|
681 // |
|
682 CntTest->CloseDatabase(); |
|
683 } |
|
684 |
|
685 |
|
686 /** |
|
687 * Regression testcode for EDNSKSA-53ZKXM "Problem with TemplateRefId" |
|
688 */ |
|
689 void TestTemplateReferenceCountingL() |
|
690 { |
|
691 CreateDatabaseL(); |
|
692 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
693 //create a template and a card based on it |
|
694 _LIT(KUserDefinedTemplate,"MyTemplate"); |
|
695 CContactItem* temp = db->CreateContactCardTemplateLC(KUserDefinedTemplate); |
|
696 CContactItem* card = CContactCard::NewLC(temp); |
|
697 TContactItemId one= db->AddNewContactL(*card); |
|
698 CleanupStack::PopAndDestroy(card); |
|
699 CleanupStack::PopAndDestroy(temp); |
|
700 //increment reference count (simulate synchronisation) |
|
701 CContactItem* card2 = db->OpenContactLX(one); |
|
702 CleanupStack::PushL(card2); |
|
703 card2->IncAccessCount(); |
|
704 db->CommitContactL(*card2); |
|
705 CleanupStack::PopAndDestroy(card2); |
|
706 CleanupStack::PopAndDestroy();//lock record |
|
707 //delete both synchronised copies |
|
708 db->DeleteContactL(one); |
|
709 db->DeleteContactL(one); |
|
710 CntTest->CloseDatabase(); |
|
711 } |
|
712 |
|
713 |
|
714 /** |
|
715 * Test Case required for INC078981 "Contacts model field type mathching urgent fix" |
|
716 */ |
|
717 LOCAL_C void TestTemplateFieldTypeMatchingL() |
|
718 { |
|
719 test.Next(_L("Create template")); |
|
720 CreateDatabaseL(); |
|
721 CContactDatabase* db=CntTest->OpenDatabaseL(); |
|
722 CntTest->DeleteAllTemplateFieldsL(); |
|
723 |
|
724 _LIT(KField1,"Field 1"); |
|
725 |
|
726 CContactTemplate *contactTemplate=(CContactTemplate *)db->OpenContactLX(db->TemplateId()); |
|
727 CleanupStack::PushL(contactTemplate); |
|
728 TFieldType mapping1(TUid::Uid(KIntContactFieldVCardMapSIPID)); |
|
729 TFieldType mappingX(TUid::Uid(KIntContactFieldVCardMapSIPID)); |
|
730 TFieldType mapping2(TUid::Uid(KIntContactFieldVCardMapVOIP)); |
|
731 TFieldType mapping3(TUid::Uid(3)); |
|
732 TFieldType mapping4(TUid::Uid(4)); |
|
733 TFieldType fieldType1(TUid::Uid(KUidContactFieldSIPIDValue)); |
|
734 TFieldType fieldType2(TUid::Uid(KIntContactFieldVCardMapVOIP)); |
|
735 |
|
736 AddFieldL(contactTemplate,mapping1,KField1(),&fieldType1,&mappingX); |
|
737 |
|
738 AddFieldL(contactTemplate,mapping1,KField1(),&fieldType1,&mapping2); |
|
739 AddFieldL(contactTemplate,mapping1,KField1(),&fieldType1,&mapping3); |
|
740 AddFieldL(contactTemplate,mapping1,KField1(),&fieldType1,&mapping4); |
|
741 |
|
742 db->CommitContactL(*contactTemplate); |
|
743 |
|
744 CleanupStack::PopAndDestroy(); // contactTemplate |
|
745 CleanupStack::Pop(); // contactTemplate.Close() |
|
746 |
|
747 TTemplateMapTest tmTest1(mapping1,&fieldType1,&mappingX,NULL,KField1(),1,ETrue); |
|
748 TTemplateMapTest tmTest2(mapping1,&fieldType1,&mapping2,NULL,KField1(),2,ETrue); |
|
749 TTemplateMapTest tmTest3(mapping1,&fieldType1,&mapping3,NULL,KField1(),3,ETrue); |
|
750 TTemplateMapTest tmTest4(mapping1,&fieldType1,&mapping4,NULL,KField1(),4,ETrue); |
|
751 TTemplateMapTest tmTest5(mapping1,&fieldType2,&mappingX,NULL,KField1(),1,EFalse); |
|
752 |
|
753 contactTemplate=(CContactTemplate *)ReadContactIncHiddenFieldsLC(db,db->TemplateId()); |
|
754 CheckFieldMappings(db,contactTemplate,&tmTest1); |
|
755 CheckFieldMappings(db,contactTemplate,&tmTest3); |
|
756 CheckFieldMappings(db,contactTemplate,&tmTest2); |
|
757 CheckFieldMappings(db,contactTemplate,&tmTest4); |
|
758 CheckFieldMappings(db,contactTemplate,&tmTest5); |
|
759 |
|
760 CleanupStack::PopAndDestroy(); // contactTemplate |
|
761 CntTest->CloseDatabase(); |
|
762 } |
|
763 |
|
764 |
|
765 /** |
|
766 @SYMTestCaseID PIM-T-TEMPL-INC100029-0001 |
|
767 @SYMTestType UT |
|
768 @SYMTestPriority Critical |
|
769 @SYMDEF INC100029 |
|
770 @SYMTestCaseDesc Tests that if an attempt is made to commit the System template |
|
771 with a field which contains data that the commit leaves with KErrNotSupported. |
|
772 |
|
773 @SYMTestActions |
|
774 1. Open the System template. |
|
775 2. Add data to the field KUidContactFieldGivenName. |
|
776 3. Commit the System template. |
|
777 4. Check that step 3 leaves with error KErrNotSupported. |
|
778 |
|
779 @SYMTestExpectedResults As per Test Action 4. |
|
780 */ |
|
781 LOCAL_C void TestTemplateFieldModificationL() |
|
782 { |
|
783 test.Next( _L("@SYMTestCaseID:PIM-T-TEMPL-INC100029-0001 Validate template field modification") ); |
|
784 |
|
785 CContactDatabase* db = CntTest->OpenDatabaseL(); |
|
786 |
|
787 // |
|
788 // 1. Open the System template. |
|
789 // |
|
790 CContactTemplate* contactTemplate = static_cast<CContactTemplate*>( db->OpenContactLX( db->TemplateId() ) ); |
|
791 CleanupStack::PushL( contactTemplate ); |
|
792 |
|
793 // |
|
794 // 2. Add data to the field KUidContactFieldGivenName. |
|
795 // |
|
796 SetNameL(*contactTemplate, KUidContactFieldGivenName, _L("Invalid"), EFalse ); |
|
797 |
|
798 // |
|
799 // 3. Commit the System template. |
|
800 // |
|
801 TRAPD( err, db->CommitContactL( *contactTemplate ) ); |
|
802 |
|
803 // |
|
804 // 4. Check that step 3 leaves with error KErrNotSupported. |
|
805 // |
|
806 test( err == KErrNotSupported ); |
|
807 |
|
808 CleanupStack::PopAndDestroy(2); // contactTemplate and lock. |
|
809 CntTest->CloseDatabase(); |
|
810 } |
|
811 |
|
812 LOCAL_C void TestAsyncOpenDbAndAddTemplateL() |
|
813 { |
|
814 //test if necesary sanity check was made |
|
815 test.Next( _L("Open async database and simulate a template add events")); |
|
816 |
|
817 TRequestStatus requestStatus(0); |
|
818 CContactOpenOperation* op = CContactDatabase::Open(KDatabaseFileName, requestStatus); |
|
819 // note: op doesn't have to be on CS |
|
820 User::WaitForRequest(requestStatus); |
|
821 CContactDatabase* database = op->TakeDatabase(); |
|
822 CleanupStack::PushL(database); |
|
823 |
|
824 //simulate a template add event |
|
825 TContactDbObserverEvent event; |
|
826 event.iType = EContactDbObserverEventTemplateAdded; |
|
827 database->HandleDatabaseEventL(event); |
|
828 |
|
829 CleanupStack::PopAndDestroy(database); |
|
830 } |
|
831 |
|
832 LOCAL_C void TestAsyncOpenDbAndDeleteTemplateL() |
|
833 { |
|
834 //test if necesary sanity check was made |
|
835 test.Next( _L("Open async database and simulate a template delete event")); |
|
836 |
|
837 TRequestStatus requestStatus(0); |
|
838 CContactOpenOperation* op = CContactDatabase::Open(KDatabaseFileName, requestStatus); |
|
839 // note: op doesn't have to be on CS |
|
840 User::WaitForRequest(requestStatus); |
|
841 CContactDatabase* database = op->TakeDatabase(); |
|
842 CleanupStack::PushL(database); |
|
843 |
|
844 //simulate a template remove event |
|
845 TContactDbObserverEvent event; |
|
846 event.iType = EContactDbObserverEventTemplateDeleted; |
|
847 database->HandleDatabaseEventL(event); |
|
848 |
|
849 CleanupStack::PopAndDestroy(database); |
|
850 } |
|
851 |
|
852 LOCAL_C void TestAsyncOpenDbAndDeleteContactL() |
|
853 { |
|
854 //test if necesary sanity check was made |
|
855 test.Next( _L("Open async database and simulate a template delete event")); |
|
856 |
|
857 TRequestStatus requestStatus(0); |
|
858 CContactOpenOperation* op = CContactDatabase::Open(KDatabaseFileName, requestStatus); |
|
859 // note: op doesn't have to be on CS |
|
860 User::WaitForRequest(requestStatus); |
|
861 CContactDatabase* database = op->TakeDatabase(); |
|
862 CleanupStack::PushL(database); |
|
863 |
|
864 TContactItemId contactId = 1; //anything but not system template |
|
865 database->DeleteContactL(contactId); //aim is to check if it's safe to delete from template |
|
866 |
|
867 CleanupStack::PopAndDestroy(database); |
|
868 } |
|
869 |
|
870 /** |
|
871 |
|
872 @SYMTestCaseID PIM-T-TEMPL-0001 |
|
873 |
|
874 */ |
|
875 |
|
876 void DoTestsL() |
|
877 { |
|
878 test.Start(_L("@SYMTestCaseID:PIM-T-TEMPL-0001 Create new database")); |
|
879 CreateDatabaseL(); |
|
880 TestTemplateLabelsL(); |
|
881 TestSystemTemplateL(); |
|
882 TestSystemTemplateRestorationL(); |
|
883 TestTemplateContentTypeL(); |
|
884 TestTemplateL(); |
|
885 TestMultiTemplateCacheL(); |
|
886 TestTemplateFieldMatchingL(); |
|
887 TestSystemTemplateFieldsL(); |
|
888 TestTemplateReferenceCountingL(); |
|
889 TestTemplateFieldTypeMatchingL(); |
|
890 TestTemplateFieldModificationL(); |
|
891 TestAsyncOpenDbAndAddTemplateL(); |
|
892 TestAsyncOpenDbAndDeleteTemplateL(); |
|
893 TestAsyncOpenDbAndDeleteContactL(); |
|
894 test.Next(_L("Delete database")); |
|
895 CntTest->DeleteDatabaseL(); |
|
896 } |
|
897 |
|
898 GLDEF_C TInt E32Main() |
|
899 { |
|
900 CntTest=new(ELeave) CCntTest; |
|
901 CntTest->ConstructL(test,KDatabaseFileName); |
|
902 TRAPD(err,DoTestsL()); |
|
903 CntTest->EndTestLib(err); |
|
904 return KErrNone; |
|
905 } |
|
906 |
|
907 |
|
908 |
|
909 |
|
910 |
|
911 |
|
912 |
|
913 |
|
914 |
|
915 |
|
916 |
|
917 |
|
918 |
|
919 |
|
920 |
|
921 |
|
922 |
|
923 |