1 // Copyright (c) 2001-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 <cntdb.h>

    18 #include <cntitem.h>

    19 #include <cntfield.h>

    20 #include <cntfldst.h>

    21 #include <phbksync.h>

    22 

    23 #include "T_UTILS.H"

    24 #include "./TestSyncPlugIn/cnttestsynchroniser.h"

    25 

    26 // include templates for CleanupResetAndDestroyPushL(T)

    27 #include "cntviewprivate.h"

    28 

    29 

    30 /** 

    31  * @file

    32  * Test harness for CContactICCEntry and MContactSynchroniser interface.

    33  * todo Find out why telephone field won't match template correctly 

    34  *       (Maybe the ICC slot field needs to be added to the "golden" template)

    35  *

    36  */

    37 

    38 _LIT(KDatabaseFileName,"C:T_ICCENTRY");

    39 

    40 _LIT(KTestName,"Basic tests for CContactICCEntry");

    41 _LIT(KGivenName,"Given");

    42 _LIT(KGivenEditName,"EditedName");

    43 _LIT(KTelephoneNum,"020 79460111");

    44 _LIT(KTelephoneNumModified,"020 79460222");

    45 _LIT(KTemplateName,"SIM Card Contacts"); 

    46 

    47 _LIT(KPluginName,"phone book synchronizer Implementation");

    48 _LIT(KTestPluginName,"Test phone book synchronizer Implementation");

    49 

    50 CCntTest* CntTest=NULL;

    51 LOCAL_D RTest test(KTestName);

    52 

    53 LOCAL_D CContactTestSynchroniser* synchroniser;

    54 LOCAL_D CContactSyncChecker* syncChecker;

    55 

    56 LOCAL_C TInt findWordSplitterL(TAny *aParams)

    57 	{

    58 	SFindInTextDefWordParser *parser=(SFindInTextDefWordParser *)aParams;

    59 	parser->iWordArray->AppendL(*parser->iSearchString);

    60 	return(KErrNone);

    61 	}

    62 

    63 CContactIdArray* TestFindL(CContactDatabase& aDatabase, const TDesC& aText, const CContactItemFieldDef *aFieldDef, RTest& aTest)

    64 	{

    65 	CContactIdArray* retval = NULL;

    66 	

    67 	retval = aDatabase.FindLC(aText, aFieldDef);

    68 	aTest(retval == NULL);

    69 	CleanupStack::Pop( retval );

    70 	

    71 	return retval;

    72 	}

    73 	

    74 CContactIdArray* TestFindInTextDefL(CContactDatabase& aDatabase, const MDesCArray& aFindWords,CContactTextDef* aTextDef, const TCallBack &aWordParserCallback, RTest& aTest)

    75 	{

    76 	CContactIdArray* retval = NULL;

    77 	retval = aDatabase.FindInTextDefLC(aFindWords, aTextDef, aWordParserCallback);

    78 	aTest(retval==NULL);

    79 	CleanupStack::Pop( retval );

    80 	return retval;

    81 	}

    82 		

    83 /** 

    84  * Test Finding ICC Contacts when the ICC is locked.

    85  * @param aDb Contact database

    86  */

    87 

    88 void TestFindingL(CContactDatabase& aDb)

    89 	{

    90 	test.Next(_L("Test FindLC"));

    91 

    92 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrLocked);

    93 	syncChecker->SetValidateResponseL(MContactSynchroniser::ESearch,KErrLocked);

    94 	

    95 	CContactItemFieldDef* fieldDef=new(ELeave) CContactItemFieldDef;

    96 	CleanupStack::PushL(fieldDef);

    97 	fieldDef->AppendL(KUidContactFieldFamilyName); 

    98 	

    99 	

   100 	TRAPD(err,TestFindL(aDb, KGivenEditName, fieldDef, test) );

   101 	test(err==KErrLocked);

   102 	CleanupStack::PopAndDestroy(fieldDef);

   103 

   104 	CContactItemFieldDef* fieldDef2=new(ELeave) CContactItemFieldDef;

   105 	CleanupStack::PushL(fieldDef2);

   106 	fieldDef2->AppendL(KUidContactFieldPhoneNumber); 

   107 	TRAP(err, TestFindL(aDb, KTelephoneNum, fieldDef2, test) );

   108 	test(err==KErrLocked);

   109 	CleanupStack::PopAndDestroy(fieldDef2);

   110 

   111 	test.Next(_L("Test FindInTextDefL"));

   112 

   113 	TCallBack callBack(findWordSplitterL);

   114 	CContactTextDef* textDef=CContactTextDef::NewLC();

   115 	textDef->AppendL(TContactTextDefItem(KUidContactFieldFamilyName));

   116 	CDesCArray* desArray = new(ELeave) CDesCArrayFlat(5);

   117 	desArray->AppendL(_L("e"));

   118 	

   119 	CContactIdArray* arr = NULL;

   120 	TRAP(err,arr = TestFindInTextDefL(aDb,*desArray,textDef, callBack, test) );

   121 	

   122 //	test(err==KErrLocked);

   123 	desArray->Delete(0);

   124 	delete desArray;

   125 //FIX

   126 	delete arr;	

   127 	CleanupStack::PopAndDestroy(textDef); 

   128 

   129 	test.Next(_L("Test FindInTextDefL2"));

   130 

   131 	TCallBack callBack2(findWordSplitterL);

   132 	CContactTextDef* textDef2=CContactTextDef::NewLC();

   133 	textDef2->AppendL(TContactTextDefItem(KUidContactFieldFamilyName));

   134 	textDef2->AppendL(TContactTextDefItem(KUidContactFieldUrl));

   135 	CDesCArray* desArray2 = new(ELeave) CDesCArrayFlat(5);

   136 	desArray2->AppendL(_L("e"));

   137 	

   138 	TRAP(err,arr = TestFindInTextDefL(aDb,*desArray2,textDef2, callBack2, test) );

   139 //	test(err==KErrLocked);

   140 	desArray2->Delete(0);

   141 	delete desArray2;

   142 //FIX

   143 	delete arr;	

   144 	CleanupStack::PopAndDestroy(textDef2);

   145 	}

   146 

   147 

   148 /** 

   149  * Test ICC contacts can be matched using MatchPhoneNumberL API. The 

   150  * synchroniser is not called to validate the IDs at for this method because 

   151  * phone number resolution needs to be as quick as possible. 

   152  * Instead, validation is done when the client attempts to read the items.

   153  * @param aDb Contact database

   154  */

   155  

   156 

   157 void TestPhoneMatchingL(CContactDatabase& aDb)

   158 	{

   159 	test.Next(_L("Test phone match"));

   160 

   161 	CContactIdArray* array = aDb.MatchPhoneNumberL(KTelephoneNum,KMaxPhoneMatchLength);	

   162 	test(array->Count() == 4);

   163 	delete array;

   164 

   165 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   166 	syncChecker->SetValidateResponseL(MContactSynchroniser::EEdit, KErrNone);

   167 	syncChecker->SetValidateWriteResponseL(KErrNone);

   168 	aDb.SetDbViewContactType(KUidContactICCEntry);

   169 	TContactItemId id = (*aDb.SortedItemsL())[0];

   170 	CContactItem* item = aDb.OpenContactLX(id);

   171 	CleanupStack::PushL(item);

   172 	CContactItemFieldSet& fieldset = item->CardFields();

   173 	const TInt pos = fieldset.Find(KUidContactFieldPhoneNumber);	

   174 	CContactItemField& field = fieldset[pos];

   175 	CContactTextField* textfield = field.TextStorage();

   176 	textfield->SetTextL(KTelephoneNumModified);

   177 	aDb.CommitContactL(*item);

   178 	CleanupStack::PopAndDestroy(2); //item, lock record

   179 

   180 	CContactIdArray* array2 = aDb.MatchPhoneNumberL(KTelephoneNumModified,KMaxPhoneMatchLength);	

   181 	test(array2->Count() == 1);

   182 	delete array2;

   183 	}

   184 

   185 

   186 /** 

   187  * Test database iteration using TContactIter.

   188  * @param aDb Contact database

   189  */

   190  

   191 

   192 void TestDatabaseIterationL(CContactDatabase& aDb)

   193 	{

   194 	test.Next(_L("Test database iteration"));

   195 

   196 	aDb.SetDbViewContactType(KUidContactICCEntry);

   197 	TContactIter iterator(aDb);

   198 	TContactItemId id = iterator.FirstL();

   199 	while (id!=KNullContactId)

   200 		{

   201 		CContactItem* item = aDb.ReadContactLC(id);

   202 		test(item->Type() == KUidContactICCEntry);

   203 		CleanupStack::PopAndDestroy(item);

   204 		id = iterator.NextL();

   205 		}

   206 	}

   207 

   208 

   209 

   210 CContactItem* ReadItemL( CContactDatabase& aDatabase, TContactItemId aId )

   211 	{

   212 	CContactItem* retval = NULL;

   213 	retval = aDatabase.ReadMinimalContactLC( aId );

   214 	CleanupStack::Pop( retval );

   215 	return retval;

   216 	}

   217 

   218 /** 

   219  * Verify that the plug-in implementation is called when the 

   220  * ReadMinimalContactL API is used. 

   221  * 

   222  * Tests methods:

   223  * IMPORT_C CContactItem* ReadMinimalContactL(TContactItemId aContactId);

   224  * IMPORT_C CContactItem* ReadMinimalContactLC(TContactItemId aContactId);

   225  * 

   226  * @param aDb Contact database

   227  * @param aId Contact item ID to read

   228  */

   229 void TestReadMinimalContactL(CContactDatabase& aDb, TContactItemId aId)

   230 	{

   231 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   232 	syncChecker->ResetMethodCallCountsL();

   233 	test(syncChecker->ValidateMethodCallCountL() == 0);	

   234 	CContactItem* item = aDb.ReadMinimalContactLC(aId);

   235 	test(syncChecker->ValidateMethodCallCountL() == 1);	

   236 	CleanupStack::PopAndDestroy(item);

   237 

   238 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrAccessDenied);

   239 	syncChecker->ResetMethodCallCountsL();

   240 	test(syncChecker->ValidateMethodCallCountL() == 0);

   241 	item=NULL;

   242 	//TRAPD(err, item = aDb.ReadMinimalContactLC(aId));

   243 	TRAPD( err, item = ReadItemL( aDb, aId ) );

   244 	delete item;

   245 	test(err==KErrAccessDenied);

   246 	test(syncChecker->ValidateMethodCallCountL() == 1);	

   247 	}

   248 

   249 /** 

   250  * Verify that the plug-in implementation is called when the 

   251  * ReadContactL API is used. 

   252  * 

   253  * Tests code called by methods:

   254  * IMPORT_C CContactItem* ReadContactL(TContactItemId aContactId);

   255  * IMPORT_C CArrayPtr<CContactItem>* ReadContactAndAgentL(TContactItemId aContactId);

   256  * IMPORT_C CContactItem* ReadContactL(TContactItemId aContactId,const CContactItemViewDef& aViewDef);

   257  * IMPORT_C CContactItem* ReadContactLC(TContactItemId aContactId);

   258  * IMPORT_C CContactItem* ReadContactLC(TContactItemId aContactId,const CContactItemViewDef& aViewDef);

   259  * 

   260  * @param aDb Contact database

   261  * @param aId Contact item ID to read

   262  */

   263 void TestReadContactL(CContactDatabase& aDb, TContactItemId aId)

   264 	{

   265 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   266 	syncChecker->ResetMethodCallCountsL();

   267 	test(syncChecker->ValidateMethodCallCountL() == 0);	

   268 	CContactItem* item = aDb.ReadContactLC(aId);

   269 	test(syncChecker->ValidateMethodCallCountL() == 1);	

   270 	CleanupStack::PopAndDestroy(item);

   271 

   272 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrAccessDenied);

   273 	syncChecker->ResetMethodCallCountsL();

   274 	test(syncChecker->ValidateMethodCallCountL() == 0);

   275 	item=NULL;

   276 	TRAPD(err, item = aDb.ReadContactL(aId));

   277 	delete item;

   278 	test(err==KErrAccessDenied);

   279 	test(syncChecker->ValidateMethodCallCountL() == 1);	

   280 	}

   281 

   282 /** 

   283  * Verify that read validation is done for ReadContactTextDefL

   284  * 

   285  * @param aDb Contact database

   286  * @param aId Contact item ID to read

   287  */

   288 void TestReadTextDefinitionL(CContactDatabase& aDb, TContactItemId aId)

   289 	{

   290 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   291 	syncChecker->ResetMethodCallCountsL();

   292 	test(syncChecker->ValidateMethodCallCountL() == 0);

   293 	TBuf<64> textDef;

   294 	aDb.ReadContactTextDefL(aId,textDef);

   295 	test(syncChecker->ValidateMethodCallCountL() == 1);	

   296 

   297 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrAccessDenied);

   298 	syncChecker->ResetMethodCallCountsL();

   299 	test(syncChecker->ValidateMethodCallCountL() == 0);

   300 	TRAPD(err, aDb.ReadContactTextDefL(aId,textDef));

   301 	test(err==KErrAccessDenied);

   302 	test(syncChecker->ValidateMethodCallCountL() == 1);	

   303 	}

   304 

   305 /** 

   306  * Create example ICC Entry 

   307  * @param aDb Contact database

   308  */

   309 TContactItemId CreateTestICCEntryL(CContactDatabase& aDb)

   310 	{

   311 	TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook);

   312 	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

   313 	CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate);

   314 	CleanupStack::PopAndDestroy(iccTemplate);

   315 	CleanupStack::PushL(entry);

   316 	SetNameL(*entry,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,KGivenName,EFalse);

   317 	SetNameL(*entry,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,KTelephoneNum,EFalse);

   318 

   319 	//Add to database

   320 	syncChecker->SetValidateWriteResponseL(KErrNone);

   321 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   322 	syncChecker->SetDeleteContactResponseL(KErrNone);

   323 

   324 	TContactItemId id = aDb.AddNewContactL(*entry); 

   325 

   326 	CleanupStack::PopAndDestroy(entry);	

   327 	test(id!=KNullContactId);

   328 	return id;

   329 	}

   330 

   331 /**

   332  * Verify Read validation is being done for reading items.

   333  * @param aDb Contact database

   334  */

   335 

   336 void TestReadL(CContactDatabase& aDb)

   337 	{

   338 	TContactItemId id = CreateTestICCEntryL(aDb);

   339 	test.Next(_L("TestReadMinimalContactL"));

   340 

   341 	TestReadMinimalContactL(aDb,id);

   342 	test.Next(_L("TestReadContactL"));

   343 

   344 	TestReadContactL(aDb,id);

   345 	test.Next(_L("TestReadTextDefinitionL"));

   346 

   347 	TestReadTextDefinitionL(aDb,id);

   348 	}

   349 

   350 /**

   351  * Verify that edit validation is being done for ICC entries

   352  * and write validation is done when Commit is called.

   353  * @param aDb Contact database

   354  * @param aId Item Id to edit

   355  */

   356 void TestSuccessfulEditL(CContactDatabase& aDb, TContactItemId aId)

   357 	{

   358 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   359 	syncChecker->SetValidateResponseL(MContactSynchroniser::EEdit, KErrNone);

   360 	syncChecker->SetValidateWriteResponseL(KErrNone);

   361 	syncChecker->ResetMethodCallCountsL();

   362 	test(syncChecker->ValidateMethodCallCountL() == 0);

   363 	CContactItem* item = aDb.OpenContactLX(aId);

   364 	CleanupStack::PushL(item);

   365 	test(syncChecker->ValidateMethodCallCountL() == 2);	

   366 

   367 	CContactItemFieldSet& fieldset = item->CardFields();

   368 	const TInt pos = fieldset.Find(KUidContactFieldFamilyName);	

   369 	CContactItemField& field = fieldset[pos];

   370 	CContactTextField* textfield = field.TextStorage();

   371 	textfield->SetTextL(KGivenEditName);

   372 

   373 	aDb.CommitContactL(*item);

   374 	test(syncChecker->ValidateMethodCallCountL() == 4);	

   375 	CleanupStack::PopAndDestroy(2); //item, lock record

   376 	}

   377 

   378 /**

   379  * Unsuccessful edit. Fail the edit validation request

   380  * @param aDb Contact database

   381  * @param aId Item Id to edit

   382  */

   383 void FailEditValidationL(CContactDatabase& aDb, TContactItemId aId)

   384 	{

   385 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   386 	syncChecker->SetValidateResponseL(MContactSynchroniser::EEdit, KErrAccessDenied);

   387 	syncChecker->ResetMethodCallCountsL();

   388 	test(syncChecker->ValidateMethodCallCountL() == 0);

   389 	TRAPD(err, aDb.OpenContactL(aId));

   390 	test(syncChecker->ValidateMethodCallCountL() == 2);	

   391 	test(err==KErrAccessDenied);

   392 	}

   393 

   394 /**

   395  * Unsuccessful edit. Fail the write validation request

   396  * @param aDb Contact database

   397  * @param aId Item Id to edit

   398  */

   399 void FailWriteValidationL(CContactDatabase& aDb, TContactItemId aId)

   400 	{

   401 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   402 	syncChecker->SetValidateResponseL(MContactSynchroniser::EEdit, KErrNone);

   403 	syncChecker->SetValidateWriteResponseL(KErrAccessDenied);

   404 	syncChecker->ResetMethodCallCountsL();

   405 

   406 	CContactItem* item = aDb.OpenContactLX(aId);

   407 	CleanupStack::PushL(item);

   408 	CContactItemFieldSet& fieldset = item->CardFields();

   409 	const TInt pos = fieldset.Find(KUidContactFieldFamilyName);	

   410 	CContactItemField& field = fieldset[pos];

   411 	CContactTextField* textfield = field.TextStorage();

   412 	textfield->SetTextL(KGivenEditName);

   413 

   414 	TRAPD(err, aDb.CommitContactL(*item));

   415 	test(syncChecker->ValidateMethodCallCountL() == 4);	

   416 	test(err==KErrAccessDenied);

   417 

   418 	CleanupStack::PopAndDestroy(2); //item, lock record

   419 	}

   420 

   421 /**

   422  * Verify that edit validation is being done for ICC entries

   423  * and write validation is done when Commit is called.

   424  * @param aDb Contact database

   425  */

   426 

   427 void TestEditL(CContactDatabase& aDb)

   428 	{

   429 	TContactItemId id = CreateTestICCEntryL(aDb);

   430 	test.Next(_L("Test successful edit"));

   431 

   432 	TestSuccessfulEditL(aDb,id);

   433 	test.Next(_L("Test unsuccessful edit - fail edit"));

   434 

   435 	FailEditValidationL(aDb,id);

   436 	test.Next(_L("Test unsuccessful edit - fail write"));

   437 

   438 	FailWriteValidationL(aDb,id);

   439 	}

   440 

   441 /** 

   442  * Test an unsuccessful delete

   443  * @param aDb Contact database

   444  */

   445 void TestUnsuccessfulDeleteL(CContactDatabase& aDb)

   446 	{

   447 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   448 	syncChecker->SetValidateResponseL(MContactSynchroniser::EEdit, KErrNone);

   449 	TContactItemId id = CreateTestICCEntryL(aDb);

   450 	// Creating the contact sets the delete error to KErrNone, so must do this afterwards

   451 	syncChecker->SetDeleteContactResponseL(KErrCorrupt);

   452 	syncChecker->ResetMethodCallCountsL();

   453 	TRAPD(err, aDb.DeleteContactL(id));

   454 	test(syncChecker->ValidateMethodCallCountL() == 2);

   455 	test(err==KErrCorrupt);

   456 	//Read contact to check it wasn't deleted anyway

   457 	CContactItem* item = NULL;

   458 	TRAP(err,item = aDb.ReadContactL(id));

   459 	test(err==KErrNone);

   460 	delete item;

   461 	}

   462 

   463 

   464 /** 

   465  * Verify that delete validation is being done for ICC entries.

   466  * @param aDb Contact database

   467  */

   468 

   469 void TestDeleteL(CContactDatabase& aDb)

   470 	{

   471 	test.Next(_L("Test successful delete"));

   472 

   473 	TContactItemId id = CreateTestICCEntryL(aDb);

   474 	syncChecker->ResetMethodCallCountsL();

   475 	aDb.DeleteContactL(id);

   476 	test(syncChecker->ValidateMethodCallCountL() == 2);

   477 	test.Next(_L("Test unsuccessful delete"));

   478 

   479 	TestUnsuccessfulDeleteL(aDb);

   480 	}

   481 

   482 

   483 /** 

   484  * Create template card for ICC contact items 

   485  * @param aDb Contact database

   486  */

   487 TContactItemId CreateICCTemplateL(CContactDatabase& aDb)

   488 	{

   489 	CContactItem* temp = aDb.CreateContactCardTemplateLC(KTemplateName);

   490 	TContactItemId templateId = temp->Id();

   491 	CleanupStack::PopAndDestroy(temp);

   492 	temp=NULL;

   493 

   494 	//Remove all the unnecessary fields

   495 	temp = aDb.OpenContactLX(templateId);

   496 	CleanupStack::PushL(temp);	

   497 	const TInt fieldCount = temp->CardFields().Count();

   498 	for(TInt i=fieldCount-1;i>=0;i--)

   499 		temp->RemoveField(i);

   500 		

   501 	CContactItemField* name = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldFamilyName);

   502 	name->SetMapping(KUidContactFieldVCardMapUnusedN);

   503 	temp->AddFieldL(*name);

   504 	CleanupStack::Pop(name);

   505 

   506 	CContactItemField* number = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPhoneNumber);

   507 	number->SetMapping(KUidContactFieldVCardMapTEL);

   508 	temp->AddFieldL(*number);

   509 	CleanupStack::Pop(number);

   510 				

   511 	CContactItemField* slotnum = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldICCSlot);

   512 	temp->AddFieldL(*slotnum);

   513 	CleanupStack::Pop(slotnum);

   514 

   515 	CContactItemField* phonebook = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldICCPhonebook);

   516 	temp->AddFieldL(*phonebook);

   517 	CleanupStack::Pop(phonebook);

   518 

   519 	aDb.CommitContactL(*temp);

   520 	CleanupStack::PopAndDestroy(2);	// temp, close template	

   521 	

   522 	return templateId;

   523 	}

   524 

   525 /**

   526  * Test SetDbViewContactType can be used for KUidContactICCEntry items.

   527  * @param aDb Contact database

   528  */

   529 void TestDatabaseViewL(CContactDatabase& aDb)

   530 	{

   531 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   532 	syncChecker->SetValidateWriteResponseL(KErrNone);

   533 	CntTest->CloseDatabase();

   534 	CntTest->DeleteDatabaseL();

   535 	// re-initialise the TLS

   536 	syncChecker->EnableVerboseLoggingL();

   537 

   538 	CntTest->CreateDatabaseL();	

   539 	CntTest->OpenDatabaseL();

   540 	delete synchroniser;

   541 	synchroniser = CContactTestSynchroniser::NewL();

   542 	// test with GSM ADN phonebook only

   543 	//test(KErrNone == syncChecker->SetGsmPhonebook());

   544 

   545 	// Start from clean

   546 	CContactItem* card = CContactCard::NewLC();

   547 	aDb.AddNewContactL(*card);

   548 	aDb.CreateContactGroupLC();

   549 	aDb.CreateOwnCardLC();

   550 	TContactItemId id=CreateICCTemplateL(aDb);

   551 	test(KErrNone == syncChecker->UpdatePhonebookEntryL(KUidIccGlobalAdnPhonebook, id, KNullContactId));

   552 	TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook);

   553 	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

   554 	CContactICCEntry* iccentry = CContactICCEntry::NewL(*iccTemplate);

   555 	CleanupStack::PopAndDestroy(iccTemplate);

   556 	CleanupStack::PushL(iccentry);

   557 	aDb.AddNewContactL(*iccentry);

   558 	TContactItemId iccId = iccentry->Id();

   559 	CleanupStack::PopAndDestroy(4); //card,group,owncard,iccentry

   560 	

   561 	test(aDb.SortedItemsL()->Count() == 5); //default view includes ALL contact types

   562 	CntTest->CloseDatabase();

   563 	delete synchroniser;

   564 	synchroniser = NULL;

   565 	CntTest->OpenDatabaseL();

   566 	aDb.SetDbViewContactType(KUidContactICCEntry);

   567 	test(aDb.SortedItemsL()->Count() == 1);

   568 	test((*aDb.SortedItemsL())[0]==iccId);

   569 	}

   570 

   571 /** 

   572  * Create phonebook group 

   573  * @param aDb Contact database

   574  */

   575 TContactItemId CreatePhonebookGroupL(CContactDatabase& aDb)

   576 	{

   577 	_LIT(KPhbkGroup,"ADN Phonebook"); 

   578 	CContactItem* group = aDb.CreateContactGroupLC(KPhbkGroup);

   579 	TContactItemId groupId = group->Id();

   580 	CleanupStack::PopAndDestroy(group);	

   581 	return groupId;

   582 	}

   583 

   584 /** 

   585  * Verify that the template was correctly added 

   586  * @param aTemplate CContactCardTemplate template item

   587  */

   588 void CheckTemplateL(CContactItem& aTemplate)

   589 	{

   590 	test(aTemplate.Type() == KUidContactCardTemplate);

   591 	test(aTemplate.TemplateRefId() == KNullContactId);

   592 	test(static_cast<CContactCardTemplate&>(aTemplate).GetTemplateLabelL() == KTemplateName);

   593 	CContactItemFieldSet& fieldset = aTemplate.CardFields();

   594 	TInt pos = fieldset.Find(KUidContactFieldTemplateLabel);

   595 	test(pos!=KErrNotFound);

   596 	TInt count = fieldset.Count();

   597 	test(count==5); //label, name, number, ICC slot, phonebook

   598 	}

   599 

   600 

   601 /** 

   602  * Check that the field of type aFieldType has the same content as 

   603  * aExpectedContent

   604  * @param aFieldset Contact item fieldset

   605  * @param aFieldType Field type to test

   606  * @param aExpectedContent Expected data

   607  */

   608 void CheckFieldContentL(CContactItemFieldSet& aFieldset, TFieldType aFieldType, const TDesC& aExpectedContent)

   609 	{

   610 	TInt pos = aFieldset.Find(aFieldType);

   611 	CContactItemField& field = aFieldset[pos];

   612 	CContactTextField* textField = field.TextStorage();

   613 	test(textField != NULL);

   614 	test(textField->Text() == aExpectedContent);

   615 	}

   616 

   617 /** 

   618  * Test creation of CContactICCEntry items.

   619  * 

   620  * Set-up appropriate template and group ready...

   621  * @param aDb Contact database

   622  */

   623 

   624 /**

   625 

   626 @SYMTestCaseID     PIM-T-ICCENTRY-0001

   627 

   628 */

   629 

   630 void TestCreationL(CContactDatabase& aDb)

   631 	{

   632 	_LIT(KTestCreation,"@SYMTESTCaseID:PIM-T-ICCENTRY-0001 Create CContactICCEntry item");

   633 	test.Start(KTestCreation);

   634 

   635 	//System Template

   636 	TContactItemId systemTemplateId = aDb.TemplateId();

   637 	CContactItem* systemTemplate = aDb.ReadContactLC(systemTemplateId);

   638 	CContactICCEntry* entry = CContactICCEntry::NewL(*systemTemplate);

   639 	CleanupStack::PopAndDestroy(systemTemplate);

   640 	CleanupStack::PushL(entry);

   641 	

   642 	//Test CContactICCEntry items can be identified from normal contact cards

   643 	test(entry->Type() == KUidContactICCEntry);

   644 	test(entry->TemplateRefId() == systemTemplateId);

   645 	CleanupStack::PopAndDestroy(entry);

   646 

   647 	//Create user defined template for ICC contacts

   648 	test.Next(_L("CContactDatabase::ICCTemplateL()"));

   649 

   650 	TContactItemId templateId = CreateICCTemplateL(aDb);

   651 	test(KErrNone == syncChecker->UpdatePhonebookEntryL(KUidIccGlobalAdnPhonebook, templateId, KNullContactId));

   652 

   653 	//Check that contacts model calls the plug-in when asked for the

   654 	//template ID.

   655 	TInt callCount = syncChecker->ValidateMethodCallCountL();

   656 	test(callCount==0);

   657 	TContactItemId templateIdFromCntmodel;

   658 	templateIdFromCntmodel = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook);

   659 

   660 	test(syncChecker->ValidateMethodCallCountL() == 1);

   661 	test(templateId == templateIdFromCntmodel);

   662 	

   663 	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

   664 	CheckTemplateL(*iccTemplate);

   665 	//create ICC contact

   666 	CContactICCEntry* iccentry = CContactICCEntry::NewL(*iccTemplate);

   667 	CleanupStack::PopAndDestroy(iccTemplate);

   668 	CleanupStack::PushL(iccentry);

   669 	test(iccentry->Type() == KUidContactICCEntry);

   670 	test(iccentry->TemplateRefId() == templateId);

   671 	CleanupStack::PopAndDestroy(iccentry);

   672 	

   673 	test.End();

   674 	}

   675 

   676 

   677 

   678 /** 

   679  * Test successful addition to database.

   680  * @param aDb Contact database

   681  */

   682 void TestSuccessfulAddL(CContactDatabase& aDb)

   683 	{

   684 	//Create group 

   685 	TContactItemId groupId = CreatePhonebookGroupL(aDb);

   686 	test(KErrNone == syncChecker->UpdatePhonebookGroupIdL(KUidIccGlobalAdnPhonebook, groupId));

   687 	//Create item and add fields

   688 	TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook);

   689 	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

   690 	CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate);

   691 	CleanupStack::PopAndDestroy(iccTemplate);

   692 	CleanupStack::PushL(entry);

   693 	SetNameL(*entry,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,KGivenName,EFalse);

   694 	SetNameL(*entry,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,KTelephoneNum,EFalse);

   695 

   696 	//Add to database

   697 	syncChecker->ResetMethodCallCountsL();

   698 	syncChecker->SetValidateWriteResponseL(KErrNone);

   699 	syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone);

   700 

   701 	test(syncChecker->ValidateMethodCallCountL() == 0);

   702 	TContactItemId id = aDb.AddNewContactL(*entry); 

   703 	CleanupStack::PopAndDestroy(entry);	

   704 	test(syncChecker->ValidateMethodCallCountL() == 3);

   705 	test(id!=KNullContactId);

   706 

   707 	CContactICCEntry* fetchedItem = static_cast<CContactICCEntry*>(aDb.ReadContactL(id));

   708 	CleanupStack::PushL(fetchedItem);

   709 	//Check group membership	

   710 	const CContactIdArray* owned = fetchedItem->GroupsJoined();

   711 	test(owned!=NULL && owned->Count() == 1);

   712 	test((*owned)[0]==groupId);

   713 	

   714 	//Check number of fields and content

   715 	

   716 	CContactItemFieldSet& fieldset = fetchedItem->CardFields();

   717 	TInt pos = fieldset.Find(KUidContactFieldTemplateLabel);

   718 	test(pos==KErrNotFound);

   719 	

   720 //	test(fieldset.Count() == 3); 

   721 	

   722 /*	for (TInt i=0; i<fieldset.Count(); i++)

   723 		{

   724 		CContactItemField& field = fieldset[i];

   725 		TInt count = field.ContentType().FieldTypeCount();

   726 		for (TInt j=0; j<count; j++)

   727 			{

   728 			TFieldType ft= field.ContentType().FieldType(j);

   729 			}

   730 

   731 

   732 		TUid mapping = field.ContentType().Mapping();

   733 		}

   734 */	

   735 	CheckFieldContentL(fieldset,KUidContactFieldFamilyName,KGivenName);

   736 //	CheckFieldContentL(fieldset,KUidContactFieldPhoneNumber,KTelephoneNum);

   737 

   738 	CleanupStack::PopAndDestroy(fetchedItem);

   739 	}

   740 

   741 /** 

   742  * Test an unsuccessful addition to the database

   743  * @param aDb Contact database

   744  */

   745 void TestUnsuccessfulAddL(CContactDatabase& aDb)

   746 	{

   747 	TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook);

   748 	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

   749 	CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate);

   750 	CleanupStack::PopAndDestroy(iccTemplate);

   751 	CleanupStack::PushL(entry);

   752 	SetNameL(*entry,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,KGivenName,EFalse);

   753 	SetNameL(*entry,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,KTelephoneNum,EFalse);

   754 

   755 	syncChecker->ResetMethodCallCountsL();

   756 	syncChecker->SetValidateWriteResponseL(KErrAccessDenied);

   757 	TRAPD(error, aDb.AddNewContactL(*entry)); 	

   758 	test(error==KErrAccessDenied);

   759 	test(syncChecker->ValidateMethodCallCountL() == 1);

   760 	CleanupStack::PopAndDestroy(entry);

   761 	}

   762 

   763 /** 

   764  * Test addition to database without adding to a group

   765  * @param aDb Contact database

   766  */

   767 void TestAddingWithoutGroupL(CContactDatabase& aDb)

   768 	{

   769 	TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook);

   770 	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

   771 	CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate);

   772 	CleanupStack::PopAndDestroy(iccTemplate);

   773 	CleanupStack::PushL(entry);

   774 	SetNameL(*entry,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,KGivenName,EFalse);

   775 	SetNameL(*entry,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,KTelephoneNum,EFalse);

   776 

   777 	syncChecker->ResetMethodCallCountsL();

   778 	syncChecker->SetValidateWriteResponseL(KErrNone);

   779 	TInt oldGroupId = syncChecker->GroupIdL(KUidIccGlobalAdnPhonebook);

   780 	test(KErrNone == syncChecker->UpdatePhonebookGroupIdL(KUidIccGlobalAdnPhonebook, KNullContactId));

   781 	TContactItemId id = aDb.AddNewContactL(*entry); 	

   782 	test(syncChecker->ValidateMethodCallCountL() == 3);

   783 	CleanupStack::PopAndDestroy(entry);

   784 

   785 	CContactICCEntry* fetchedItem = static_cast<CContactICCEntry*>(aDb.ReadContactL(id));

   786 	CleanupStack::PushL(fetchedItem);

   787 	//Check group membership	

   788 	const CContactIdArray* owned = fetchedItem->GroupsJoined();

   789 	test(owned==NULL || owned->Count() == 0);

   790 	CleanupStack::PopAndDestroy(fetchedItem);

   791 		

   792 	test(KErrNone == syncChecker->UpdatePhonebookGroupIdL(KUidIccGlobalAdnPhonebook, oldGroupId));

   793 	}

   794 

   795 /** 

   796  * Verify that adding contact cards doesn't call the synchroniser interface

   797  * @param aDb Contact database

   798  */

   799 void TestAddingContactCardL(CContactDatabase& aDb)

   800 	{

   801 	CContactCard* card = CContactCard::NewLC();

   802 	syncChecker->ResetMethodCallCountsL();

   803 	aDb.AddNewContactL(*card);

   804 	test(syncChecker->ValidateMethodCallCountL() == 0);

   805 	CleanupStack::PopAndDestroy(card);

   806 	}

   807 

   808 /** 

   809  * Test addition of CContactICCEntry items.

   810  * @param aDb Contact database

   811  */

   812 void TestAddL(CContactDatabase& aDb)

   813 	{

   814 	TestCreationL(aDb);

   815 	TestSuccessfulAddL(aDb);

   816 	TestUnsuccessfulAddL(aDb);

   817 	TestAddingWithoutGroupL(aDb);

   818 	TestAddingContactCardL(aDb);

   819 	}

   820 

   821 /** 

   822  * Test PhonebookGroupIdL method.

   823  * @param aDb Contact database

   824  */

   825 void TestPhonebookGroupIdL(CContactDatabase& aDb)

   826 	{

   827 	synchroniser = CContactTestSynchroniser::NewL();

   828 	const TContactItemId expectedGroupId(KNullContactId);

   829 	test(KErrNone == syncChecker->UpdatePhonebookGroupIdL(KUidIccGlobalAdnPhonebook, expectedGroupId));

   830 	TContactItemId id = aDb.PhonebookGroupIdL();

   831 	test(id == expectedGroupId);

   832 	}

   833 

   834 

   835 void CheckForPhbkSyncPluginL()

   836 	{

   837 	test.Next(_L("Check for PhbkSync test plug-in"));

   838 

   839 

   840 	RImplInfoPtrArray	implInfoArray;

   841 	CleanupResetAndDestroyPushL(implInfoArray);

   842 	REComSession::ListImplementationsL(KUidEcomCntPhBkSyncInterface, implInfoArray);

   843 	//Find implementations of KUidEcomCntPhBkSyncInterface

   844 	TInt availCount = implInfoArray.Count(); 

   845 	TInt count;

   846 	for(count = 0; count < availCount; count++)

   847 		{

   848 		//const TUid firstImplementationFound = implInfoArray[count]->ImplementationUid();

   849 		CImplementationInformation *info = implInfoArray[count];

   850 		test.Printf(_L("\n"));

   851 		test.Printf(_L("PhbkSync plugin #%i, Implementation UID 0x%08X version %i\n"),

   852 			count + 1, info->ImplementationUid(), info->Version());

   853 		test.Printf(_L("Plugin name = \"%S\"\n"), &(info->DisplayName()));

   854 		}

   855 

   856 	// is telephony's plug-in in the list?

   857 	for(count = 0; count < availCount; count++)

   858 		{

   859 		//const TUid firstImplementationFound = implInfoArray[count]->ImplementationUid();

   860 		CImplementationInformation *info = implInfoArray[count];

   861 		if(info->DisplayName() == KTestPluginName)

   862 			{

   863 			test.Printf(_L("\n"));

   864 			test.Printf(_L("This test has now loaded the test plugin"));

   865 			test.Printf(_L("\n"));

   866 			availCount = 1;

   867 			break;

   868 			}		

   869 		

   870 		if(info->DisplayName() == KPluginName)

   871 			{

   872 			test.Printf(_L("\n"));

   873 			test.Printf(_L("This test only works with Contacts the test plugin and not the original phonebooksync plugin."));

   874 			test.Printf(_L("Depending on the build to removed the plugin in different ways:"));

   875 			test.Printf(_L("hardware - delete the line \"ECOM_PLUGIN(phbksyncplugin.dll,1020428C.rsc)\" from phbksync.iby"));

   876 			test.Printf(_L("winscw - delete phbksyncplugin.dll from %epocroot%/epoc32/release/winscw/udeb or similarly named directory"));

   877 			test.Printf(_L("\n"));

   878 			test(0);  // stop

   879 			break;

   880 			}

   881 		}

   882 

   883 	// only continue test if there is exactly one plug-in present

   884 	test(availCount == 1);	

   885 	CleanupStack::PopAndDestroy(&implInfoArray);

   886 	}

   887 

   888 /** Lists tests to execute */

   889 

   890 void DoTestsL()

   891     {

   892 	test.Start(_L("Basic tests for CContactICCEntry"));

   893 

   894 

   895 	CheckForPhbkSyncPluginL();

   896 

   897 	CntTest->CreateDatabaseL();	

   898 	CntTest->OpenDatabaseL();

   899 

   900 	syncChecker = CContactSyncChecker::NewL();

   901 	synchroniser = CContactTestSynchroniser::NewL();

   902 	syncChecker->ResetL();

   903 	syncChecker->EnableVerboseLoggingL();

   904 	// test with GSM ADN phonebook only

   905 	test(KErrNone == syncChecker->SetGsmPhonebookL());

   906 	

   907 	CContactDatabase& db= *CntTest->Db();

   908 	TestAddL(db);

   909 	TestReadL(db);

   910 	TestEditL(db);

   911 	TestPhoneMatchingL(db);

   912 	TestFindingL(db);

   913 	TestDeleteL(db);

   914 	TestDatabaseIterationL(db);

   915 	TestDatabaseViewL(db);

   916 	TestPhonebookGroupIdL(db);

   917 	

   918 	CntTest->CloseDatabase();

   919 	CntTest->DeleteDatabaseL();

   920 

   921 	delete synchroniser;

   922 	synchroniser = NULL;

   923 	delete syncChecker;

   924 	syncChecker = NULL;

   925     }

   926 

   927 /** Standard E32Main method */

   928 GLDEF_C TInt E32Main()

   929 	{

   930 	__UHEAP_MARK;

   931     CntTest=new(ELeave) CCntTest;

   932 	CntTest->ConstructL(test,KDatabaseFileName);

   933     TRAPD(err,DoTestsL());

   934 	if (err)

   935 		{

   936 		// delete globals

   937 		delete synchroniser;

   938 		synchroniser = NULL;

   939 		delete syncChecker;

   940 		syncChecker = NULL;

   941 		}

   942 	CntTest->EndTestLib(err);

   943 	__UHEAP_MARKEND;

   944 	return KErrNone;

   945     }