diff -r 11319788d38f -r d11de32a5e6f phonebookengines_old/contactsmodel/tsrc/T_CARDTM.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines_old/contactsmodel/tsrc/T_CARDTM.CPP	Tue Jun 15 14:45:31 2010 +0100
@@ -0,0 +1,1478 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32test.h>
+#include <f32file.h>
+#include <s32file.h>
+#include <cntdb.h>
+#include <cntitem.h>
+#include <cntfield.h>
+#include <cntfldst.h>
+#include <bautils.h>
+#include <barsc.h>
+#include <barsread.h>
+#include <cntmodel.rsg>
+#include "T_UTILS.H"
+
+CCntTest* CntTest=NULL;
+LOCAL_D RTest test(_L("T_CARDTM"));
+
+const TPtrC KDatabaseFileName=_L("C:T_CARDTM");
+const TPtrC KTestName=_L("Test Name No%d");
+const TPtrC KTestAddress=_L("Address %d");
+const TPtrC KTestLabel = _L("Test label No %d");
+const TPtrC KTestEmail = _L("Test@Email.com No %d");
+const TPtrC KTestCountry = _L("Test Country No %d");
+const TPtrC KTestCompany = _L("Test Company No %d");
+const TPtrC KTestFamilyName=_L("Test Family Name No %d");
+const TInt KTotalNumRecords=50;
+
+
+#define KCardGivenName _L("Given Name #%d")
+#define KCardFamilyName _L("Family Name #%d")
+#define KCardFieldText _L("Card id %d, text field #%d")
+#define KCardFieldEditedText _L("UPDATED Card id %d, text field #%d")
+#define KTestData _L("test data")
+
+
+
+/** 
+ * Added to understand what support Contacts provides for user-defined templates...
+ */
+/*
+void TestCardTemplateCreationL(CContactDatabase& aDb)
+	{
+	_LIT(KCardTemplateName,"CContactCardTemplate");
+	CContactItem* temp = aDb.CreateContactCardTemplateLC(KCardTemplateName);
+	TContactItemId templateId = temp->Id();
+	TContactItemId templateRefId = temp->TemplateRefId();
+	__ASSERT_ALWAYS(templateRefId==KNullContactId, User::Invariant()); //templates must not reference other cards
+	__ASSERT_ALWAYS(temp->Type()==KUidContactCardTemplate, User::Invariant()); //correct type?
+	CContactItemFieldSet& fieldSet = temp->CardFields();
+	TInt fieldSetCount = fieldSet.Count();
+	TInt labelPosition = fieldSet.Find(KUidContactFieldTemplateLabel);
+	__ASSERT_ALWAYS(labelPosition!=KErrNotFound, User::Invariant());
+	CContactItemField& labelField = fieldSet[labelPosition];
+	__ASSERT_ALWAYS(labelField.TextStorage()->Text()==KCardTemplateName, User::Invariant());
+	
+
+	//Create a card based on the template
+	CContactItem* card = CContactCard::NewLC(temp);
+	TContactItemId cardTemplateRefId = card->TemplateRefId();
+	__ASSERT_ALWAYS(cardTemplateRefId==templateId, User::Invariant()); 
+	__ASSERT_ALWAYS(card->Type()==KUidContactCard, User::Invariant());
+	CContactItemFieldSet& cardFieldSet = card->CardFields();
+	TInt cardFieldSetCount = cardFieldSet.Count();
+	TInt cardLabelPosition = cardFieldSet.Find(KUidContactFieldTemplateLabel);
+	__ASSERT_ALWAYS(cardLabelPosition==KErrNotFound, User::Invariant());
+
+	TContactItemId cardId = aDb.AddNewContactL(*card);
+	CleanupStack::PopAndDestroy(card);
+	
+	CleanupStack::PopAndDestroy(temp);
+
+
+	//Modify the template - does the card get the changes?
+	CContactItem* modifiedTemp = aDb.OpenContactLX(templateId);
+	CleanupStack::PushL(modifiedTemp);	
+	const TInt fieldCount = modifiedTemp->CardFields().Count();
+	for(TInt i=fieldCount-1;i>=0;i--)
+		temp->RemoveField(i);
+		
+	CContactItemField* name = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldGivenName);
+	name->SetMapping(KUidContactFieldVCardMapUnusedN);
+	modifiedTemp->AddFieldL(*name);
+	CleanupStack::Pop(name);
+
+	CContactItemField* number = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPhoneNumber);
+	number->SetMapping(KUidContactFieldVCardMapTEL);
+	modifiedTemp->AddFieldL(*number);
+	CleanupStack::Pop(number);
+			
+	CContactItemField* slotnum = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldICCSlot);
+	modifiedTemp->AddFieldL(*slotnum);
+	CleanupStack::Pop(slotnum);
+
+	aDb.CommitContactL(*modifiedTemp);
+	CleanupStack::PopAndDestroy(2);	// temp, close template
+
+	CContactItem* fetchedCard = aDb.ReadContactLC(cardId);
+	TInt cardFieldsCount = fetchedCard->CardFields().Count();
+	CleanupStack::PopAndDestroy(fetchedCard);	
+
+
+	//Add a new contact with the modified template
+	CContactItem* fetchedTemplate = aDb.ReadContactLC(templateId);
+	CContactItem* newCard = CContactCard::NewLC(fetchedTemplate);
+	TInt newCardFieldsCount = newCard->CardFields().Count();
+	
+	TInt pos = newCard->CardFields().Find(KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN);
+	if (pos!=KErrNotFound)
+		{
+		CContactItemField& field=fieldSet[pos];
+		field.TextStorage()->SetTextL(_L("Chris"));
+		}
+	TContactItemId id = aDb.AddNewContactL(*newCard);
+	CleanupStack::PopAndDestroy(newCard);	
+	
+	CContactItem* it = aDb.ReadContactLC(id);
+	TInt fit = it->CardFields().Count();
+	CleanupStack::PopAndDestroy(it);	
+	
+	
+
+	//ICC contacts then..
+	CContactItem* iccCard = CContactICCEntry::NewL(*fetchedTemplate);
+	CleanupStack::PushL(iccCard);
+	TInt iccFieldsCount = iccCard->CardFields().Count();
+	
+	TInt p = iccCard->CardFields().Find(KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN);
+	if (p!=KErrNotFound)
+		{
+		CContactItemField& field=fieldSet[p];
+		field.TextStorage()->SetTextL(_L("Chris"));
+		}
+	TContactItemId iccId = aDb.AddNewContactL(*iccCard);
+	CleanupStack::PopAndDestroy(iccCard);
+	
+	CContactItem* fetchedIcc = aDb.ReadContactLC(iccId);
+	TInt fetchedIccCount = fetchedIcc->CardFields().Count();
+	CleanupStack::PopAndDestroy(fetchedIcc);
+	
+	
+	
+	
+	CleanupStack::PopAndDestroy(fetchedTemplate);
+	}
+*/
+
+
+
+
+
+
+
+//
+//
+//	SUPPORT MODULES
+//
+//
+
+LOCAL_C void SetNameL(CContactItem& aItem,TUid aType,const TDesC& aName)
+//
+// Set the contents of a text field, creating the field if required
+//
+	{
+	CContactItemFieldSet& fieldSet=aItem.CardFields();
+	const TInt pos=fieldSet.Find(aType);
+	if (pos!=KErrNotFound)
+		fieldSet[pos].TextStorage()->SetTextL(aName);
+	}
+
+
+LOCAL_C void CompareFieldSetsL(CContactItem* aContact, CContactItem* aTemplate)
+//
+// check new card fields are the same as the templates
+//
+	{
+	CContactItemFieldSet& contactFields = aContact->CardFields();
+	CContactItemFieldSet& templateFields = aTemplate->CardFields();
+	test(contactFields.Count() == (templateFields.Count() - 1)); 
+	//-1 label field
+	for (TInt jj=1;jj < (contactFields.Count()-1);jj++) 
+		// need to start at 1 since label field wont exist in contact card
+		{	
+		CContactItemField& tempField = (templateFields)[jj];
+		TBool exists = EFalse;
+		for (TInt counter=0;counter<contactFields.Count();counter++)
+			{
+			CContactItemField& contField = (contactFields)[counter];
+			if (contField.ContentType()==tempField.ContentType())
+				{	
+				exists=ETrue;
+				break;
+				}		
+			}
+		test(exists);
+		}
+	}
+
+LOCAL_C void CompareFieldSetsWithTextL(CContactItem* aContact, CContactItem* aTemplate)
+//
+// check new card fields are the same as the templates
+//
+	{
+	CContactItemFieldSet& contactFields = aContact->CardFields();
+	CContactItemFieldSet& templateFields = aTemplate->CardFields();
+	test(contactFields.Count() == (templateFields.Count()-1));
+	//-1 label field
+	for (TInt jj=1;jj < (contactFields.Count()-1);jj++)
+		{	
+		CContactItemField& tempField = (templateFields)[jj];
+		TBool exists = EFalse;
+		for (TInt counter=0;counter<contactFields.Count();counter++)
+			{
+			CContactItemField& contField = (contactFields)[counter];
+			if (contField.ContentType()==tempField.ContentType())
+				{	
+				exists=ETrue;
+				if (contField.StorageType()==KStorageTypeText)
+					{
+					exists=ETrue;
+					break;
+					}
+				}		
+			}
+		test(exists);
+		}
+	}
+
+LOCAL_C void PopulateDatabaseL(CContactItem& aTemplate, TInt aNumberToPopulate, TBool aPhoneNumbers, TBool aWithTime)
+//
+// Create and populate the database
+//
+	{
+	TTime before=TTime();
+	if (aWithTime)
+		before.UniversalTime();
+	for (TInt counter=0;counter<aNumberToPopulate;counter++)
+		{
+		CContactItem* item=CContactCard::NewLC(&aTemplate);
+		TBuf<16> name;
+		name.Format(KTestName,counter);
+   		SetNameL(*item,KUidContactFieldGivenName,name);
+		if (aPhoneNumbers)
+			{
+			TBuf<20> number;
+			switch(counter%3)
+				{
+				case 0:
+					number.Format(_L("0171-%03d %04d"),(counter*9)%1000,((counter+11)*23)%10000);
+					break;
+				case 1:
+					number.Format(_L("%04d:%04d:%04d:%04d"),(counter*123)%10000,(counter*666)%10000,(counter*234)%10000);
+					break;
+				case 2:
+					number.Format(_L("+00%d-%03d %04d"),(counter*123)%100,(counter*13)%1000,((counter+13)*17)%10000);
+					break;
+				}
+   			SetNameL(*item,KUidContactFieldPhoneNumber,number);
+			if (!(counter%2))
+				{
+				number.Format(_L("0181-%03d %04d"),(counter*8)%1000,((counter+11)*22)%10000);
+	   			SetNameL(*item,KUidContactFieldPhoneNumber,number);
+				number.Format(_L("01734-%06d"),(counter*123456)%1000000);
+	   			SetNameL(*item,KUidContactFieldPhoneNumber,number);
+				}
+			}
+		TBuf<32> address;
+		address.Format(KTestAddress,counter);
+		SetNameL(*item,KUidContactFieldAddress,address);
+        //
+		TBuf<32> familyName;
+		familyName.Format(KTestFamilyName,counter);
+		SetNameL(*item,KUidContactFieldFamilyName,familyName);
+        //
+		TBuf<32> email;
+		email.Format(KTestEmail,counter);
+		SetNameL(*item,KUidContactFieldEMail,email);
+        //
+		TBuf<32> country;
+		country.Format(KTestCountry,counter);
+		SetNameL(*item,KUidContactFieldCountry,country);
+        //	
+		TBuf<32> company;
+		company.Format(KTestCompany,counter);
+		SetNameL(*item,KUidContactFieldCompanyName,company);
+        //	
+		CContactItemFieldSet& itemFields = item->CardFields();
+		for (TInt counter2=0;counter2<itemFields.Count();counter2++)
+			{
+			if (!itemFields[counter2].Storage()->IsFull() && itemFields[counter2].StorageType()==KStorageTypeText)
+				itemFields[counter2].TextStorage()->SetTextL(KTestData);
+			}
+		CntTest->Db()->AddNewContactL(*item); //templ
+		CleanupStack::PopAndDestroy(); // item
+        //	
+		if (counter%100==0 && aWithTime)
+			test.Printf(_L("."));	// Just to show some life
+
+		}
+	CntTest->Db()->SetDateFormatTextL(_L("%E%D%X%N%Y %1 %2 %3"));
+	CntTest->Db()->CompactL();
+	if (aWithTime)
+		{
+		TTime after;
+		after.UniversalTime();
+		TTimeIntervalSeconds secondsTaken;
+		after.SecondsFrom(before,secondsTaken);
+		test.Printf(_L(" TIME: %d  Secs"),secondsTaken.Int());
+		test.Printf(_L("\n"));	
+		}
+	}
+
+//
+//
+//	TEST MODULES
+//
+//
+
+
+LOCAL_C void CreateCardTemplateL()
+	{
+	test.Next(_L("Create Card Template"));
+
+	//copy 'golden' template
+	CContactItem* tempTemplate = CntTest->Db()->CreateContactCardTemplateL(_L("label1"));
+	CleanupStack::PushL(tempTemplate);
+
+	// create template with more fields than the golden template
+	CContactItemField* field1=CContactItemField::NewLC(KStorageTypeText,TUid::Uid(1));
+   	field1->SetMapping(KUidContactFieldVCardMapUnusedN);
+	tempTemplate->AddFieldL(*field1);
+	CContactItemField* field2=CContactItemField::NewLC(KStorageTypeText,TUid::Uid(2));
+   	field2->SetMapping(KUidContactFieldVCardMapUnusedN);
+	tempTemplate->AddFieldL(*field2);
+	CleanupStack::Pop(2); // field1,2
+	CContactItem* secondTempTemplate = CntTest->Db()->CreateContactCardTemplateL(tempTemplate,_L("TEMPLATE2"));
+	CleanupStack::PushL(secondTempTemplate);
+
+	// create template with less fields than the golden template
+	CContactItemFieldSet& tempFields = tempTemplate->CardFields();
+	TInt fieldCount=tempFields.Count();
+	TInt index = fieldCount-1;
+	TInt counter = 0;
+	
+	while(counter < 12)
+	    {
+	    if(!tempFields[index].IsHidden())
+	        {
+	        //delete visible fields only as the tests only test againest the visible fields. 
+    		tempTemplate->RemoveField(index);
+    		++counter;
+	        }
+	    --index;
+	    }
+		
+	CContactItem* thirdTempTemplate = CntTest->Db()->CreateContactCardTemplateL(tempTemplate,_L("TEMPLATE3"));
+	CleanupStack::PushL(thirdTempTemplate);
+
+	// create template with just the label field
+	tempFields.Reset();
+	CContactItem* fourthTempTemplate = CntTest->Db()->CreateContactCardTemplateL(tempTemplate,_L("TEMPLATE4"));
+	
+	CleanupStack::PopAndDestroy(3); // thirdTempTemplate secondTempTemplate tempTemplate
+	delete fourthTempTemplate;
+	}
+
+
+LOCAL_C void CheckCardTemplateListPersistL()
+	{
+	test.Next(_L("Check Card Template LIST Persistance"));
+
+
+	// get golden template
+	TContactItemId goldenTemplateId = CntTest->Db()->TemplateId();
+	CContactItem* goldenTemplate = CntTest->Db()->ReadContactLC(goldenTemplateId);
+	CContactItemFieldSet& goldenTemplateFields = goldenTemplate->CardFields();
+	TInt originalCount = goldenTemplateFields.Count();
+	CleanupStack::PopAndDestroy(goldenTemplate);
+
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	test(templateCount == 4);
+
+	// Check Template definitions created by CreateCardTemplateL()
+		{
+		CContactItem* goldCopyTemp = CntTest->Db()->ReadContactLC((*tempIdList)[0]);
+		CContactItemFieldSet& goldenCopyFields = goldCopyTemp->CardFields();
+		// original + 1 (+ template label field)
+		test(goldenCopyFields.Count() == originalCount + 1);
+		CleanupStack::PopAndDestroy(goldCopyTemp);
+		}
+
+		{
+		CContactItem* largeCopyTemp = CntTest->Db()->ReadContactLC((*tempIdList)[1]);
+		CContactItemFieldSet& largeCopyFields = largeCopyTemp->CardFields();
+		// original + 3 (+ template label field +2 UIDs)
+		test(largeCopyFields.Count() == originalCount + 3);
+		CleanupStack::PopAndDestroy(largeCopyTemp);
+		}
+
+		{
+		CContactItem* smallCopyTemp = CntTest->Db()->ReadContactLC((*tempIdList)[2]);
+		CContactItemFieldSet& smallCopyFields = smallCopyTemp->CardFields();
+		// (original + template label field + 2 UIDs - 12 fields from end of template) == originalCount - 9
+		test(smallCopyFields.Count() == originalCount - 9);
+		CleanupStack::PopAndDestroy(smallCopyTemp);
+		}
+
+		{
+		CContactItem* singleFieldCopyTemp = CntTest->Db()->ReadContactLC((*tempIdList)[3]);
+		CContactItemFieldSet& singleCopyFields = singleFieldCopyTemp->CardFields();
+		// template just has template label
+		test(singleCopyFields.Count() == 1);
+		CleanupStack::PopAndDestroy(singleFieldCopyTemp);
+		}
+
+	CleanupStack::PopAndDestroy(tempIdList);
+	}	
+
+LOCAL_C void CreateEmptyContactsFromTemplateL()
+//
+// create empty contact cards using all templates
+//
+	{
+	test.Next(_L("Create Empty Contacts using Templates"));
+
+//
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+ 		CContactItem* tempTemplate = CntTest->Db()->OpenContactL(templateId);
+        //
+		CleanupStack::PushL(tempTemplate);
+		for(TInt jj=0; jj<5; jj++)
+			{
+			CContactItem* newContact = CContactCard::NewL(tempTemplate);
+			CleanupStack::PushL(newContact);
+			CntTest->Db()->AddNewContactL(*newContact);
+			CleanupStack::PopAndDestroy(); // newContact
+			}
+		CleanupStack::PopAndDestroy(); // tempTemplate
+		CntTest->Db()->CloseContactL(templateId);
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void CheckEmptyContactsFromTemplatePersistL()
+    //
+    // check empty card template matching persist
+    //
+	{
+	test.Next(_L("Check Empty Contacts Match Templates & Persist"));
+
+    
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	TInt jj=5;
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+		CContactItem* tempTemplate = CntTest->Db()->OpenContactL(templateId);
+		CleanupStack::PushL(tempTemplate);
+    
+		CContactItem* newContact = CntTest->Db()->OpenContactL(jj);
+		CleanupStack::PushL(newContact);
+		CompareFieldSetsL(newContact, tempTemplate);
+		CntTest->Db()->CloseContactL(tempTemplate->Id());
+		CntTest->Db()->CloseContactL(newContact->Id());
+		CleanupStack::PopAndDestroy(2); // newContact tempTemplate
+		jj+=5;
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+LOCAL_C void CreateFullContactsFromTemplateL()
+    //
+    // create FULL contact cards using all templates
+    //
+	{
+	test.Next(_L("Create FULL Contacts using Templates"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+ 		CContactItem* tempTemplate = CntTest->Db()->ReadContactL(templateId);
+    //
+		CleanupStack::PushL(tempTemplate);
+		PopulateDatabaseL(*tempTemplate, 5, ETrue, EFalse);
+		CleanupStack::PopAndDestroy(); // tempTemplate
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void CheckFullContactsFromTemplatePersistL()
+    //
+    // check FULL card template matching persist
+    //
+	{
+	test.Next(_L("Check FULL Contacts Match Templates & Persist"));
+
+    
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	TInt jj=25;
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+		CContactItem* tempTemplate = CntTest->Db()->ReadContactL(templateId);
+		CleanupStack::PushL(tempTemplate);
+		CContactItem* newContact = CntTest->Db()->ReadContactL(jj);
+		CleanupStack::PushL(newContact);
+    
+		CompareFieldSetsWithTextL(newContact, tempTemplate);
+		CleanupStack::PopAndDestroy(2); // newContact tempTemplate
+		jj+=5;
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void ModifyAddTemplateL()
+    //
+    // modify / add fields to templates
+    //
+	{
+	test.Next(_L("Modify / add fields to templates"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+ 		CContactItem* tempTemplate = CntTest->Db()->OpenContactL(templateId);
+		CleanupStack::PushL(tempTemplate);
+        //
+		for(TInt jj=0; jj<3; jj++)
+			{
+			CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPrefixName);
+	   		field->SetMapping(KUidContactFieldVCardMapUnusedN);
+			tempTemplate->AddFieldL(*field);
+			CleanupStack::Pop(); // field
+			}
+		CntTest->Db()->CommitContactL(*tempTemplate);
+		CntTest->Db()->CloseContactL(templateId);
+        //
+		CleanupStack::PopAndDestroy(); // tempTemplate
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void CheckModifyAddContactsFromTemplatePersistL()
+    //
+    // check modified card template match cards persist
+    //
+	{
+	test.Next(_L("Check contacts Match modified Templates & Persist"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	TInt jj=25;
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+		CContactItem* tempTemplate = CntTest->Db()->ReadContactL(templateId);
+		CleanupStack::PushL(tempTemplate);
+
+		CContactItem* newContact = CntTest->Db()->ReadContactL(jj);
+		CleanupStack::PushL(newContact);
+		CompareFieldSetsL(newContact, tempTemplate);
+		CleanupStack::PopAndDestroy(2); // newContact tempTemplate
+		jj+=5;
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void ModifyRemoveTemplateL()
+    //
+    // modify / remove fields to templates
+    //
+	{
+	test.Next(_L("Modify / REMOVE fields to templates"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	for (TInt counter=0; counter<templateCount-1; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+ 		CContactItem* tempTemplate = CntTest->Db()->OpenContactL(templateId);
+		CContactItemFieldSet& tempFieldSet = tempTemplate->CardFields();
+		TInt fieldCount = tempFieldSet.Count();
+		CleanupStack::PushL(tempTemplate);
+        //
+		for(TInt jj=1; jj<15; jj++)
+			{
+			tempTemplate->RemoveField(fieldCount-jj);
+			}
+		CntTest->Db()->CommitContactL(*tempTemplate);
+		CntTest->Db()->CloseContactL(templateId);
+        //
+		CleanupStack::PopAndDestroy(); // tempTemplate
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+LOCAL_C void CheckModifyRemoveContactsFromTemplatePersistL()
+    //
+    // check modified REMOVE card template match cards persist
+    //
+	{
+	test.Next(_L("Check contacts Match modified Templates & Persist"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	TInt jj=5;
+	// CHECK EMPTY CONTACTS FIRST 
+	for (TInt counter=0; counter<templateCount-1; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+		CContactItem* tempTemplate = CntTest->Db()->ReadContactL(templateId);
+		CleanupStack::PushL(tempTemplate);
+
+		CContactItem* newContact = CntTest->Db()->ReadContactL(jj);
+		CleanupStack::PushL(newContact);
+		CompareFieldSetsL(newContact, tempTemplate);
+		CleanupStack::PopAndDestroy(2); // newContact tempTemplate
+		jj+=5;
+		}
+	jj=25;
+	// check full contacts fields persists
+	for (TInt counter2=0; counter2<templateCount-1; counter2++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter2];
+		CContactItem* tempTemplate = CntTest->Db()->ReadContactL(templateId);
+		CleanupStack::PushL(tempTemplate);
+
+		CContactItem* newContact = CntTest->Db()->ReadContactL(jj);
+		CleanupStack::PushL(newContact);
+	    //
+		CContactItemFieldSet& templ = tempTemplate->CardFields();
+		CContactItemFieldSet& item = newContact->CardFields();
+		test(item.Count()>templ.Count());
+		CleanupStack::PopAndDestroy(2); // newContact tempTemplate
+		jj+=5;
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void SetTemplateLabelL()
+    //
+    // Set template fields label
+    //
+	{
+	test.Next(_L("Modify field labels in templates"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+ 		CContactItem* tempTemplate = CntTest->Db()->OpenContactL(templateId);
+		CContactItemFieldSet& tempFieldSet = tempTemplate->CardFields();
+		TInt fieldCount = tempFieldSet.Count();
+		CleanupStack::PushL(tempTemplate);
+        //
+		for(TInt jj=0; jj<fieldCount; jj++)
+			{
+			(tempFieldSet)[jj].SetLabelL(KTestLabel);
+			}
+		CntTest->Db()->CommitContactL(*tempTemplate);
+		CntTest->Db()->CloseContactL(templateId);
+        //
+		CleanupStack::PopAndDestroy(); // tempTemplate
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void CheckFieldLabelsPersistL()
+    //
+    // check modified field labels persist
+    //
+	{
+	test.Next(_L("Check modified field labels Persist"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+		CContactItem* tempTemplate = CntTest->Db()->OpenContactL(templateId);
+		CleanupStack::PushL(tempTemplate);
+		CContactItemFieldSet& tempFieldSet = tempTemplate->CardFields();
+		TInt fieldCount = tempFieldSet.Count();
+        //
+		for(TInt jj=0; jj<fieldCount; jj++)
+			{
+			test((tempFieldSet)[jj].Label() == KTestLabel);
+			}
+		CleanupStack::PopAndDestroy(); // tempTemplate
+		CntTest->Db()->CloseContactL(templateId);
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	// !!!!!!! ADD CHECKING FOR CONTACT AS WELL.
+	}
+
+
+LOCAL_C void DeleteCardTemplateL()
+    //
+    // Delete Card Template
+    //
+	{
+	test.Next(_L("Delete Card Template"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	test(tempIdList->Count() > 0);
+	TContactItemId templateId = (*tempIdList)[1];
+
+	CntTest->Db()->DeleteContactL(templateId);
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void CheckDeleteCardTemplateL()
+    //
+    // Check Delete Card Template
+    //
+	{
+	test.Next(_L("Check Delete Card Template"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	test(templateCount==3);	
+    //
+	CContactItem* tempTemplate = CntTest->Db()->ReadContactL(11);
+	CleanupStack::PushL(tempTemplate);
+    //
+	CleanupStack::PopAndDestroy(2); // tempTemplate tempIdList
+	}
+
+
+LOCAL_C void CheckLargePopulatedTemplate()
+    //
+    // create MANY FULL contact cards using all templates
+    //
+	{
+	test.Next(_L("Create MANY FULL Contacts using Templates"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		TContactItemId templateId = (*tempIdList)[counter];
+ 		CContactItem* tempTemplate = CntTest->Db()->ReadContactL(templateId);
+		CleanupStack::PushL(tempTemplate);
+        //
+		PopulateDatabaseL(*tempTemplate, KTotalNumRecords, ETrue, ETrue);
+		//PopulateDatabaseL(*tempTemplate, 1000, ETrue, ETrue);
+		CleanupStack::PopAndDestroy(); // tempTemplate
+		}
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+LOCAL_C void ModifyCardBasedOnTemplate()
+    //
+    // modify FULL contact cards based on template and check persist
+    //
+	{
+	test.Next(_L("modify Contact Card & check persist"));
+
+
+	CContactItemViewDef* itemDef=CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields,CContactItemViewDef::EIncludeHiddenFields); 
+	itemDef->AddL(KUidContactFieldMatchAll);
+
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TContactItemId templateId = (*tempIdList)[0]; // first in the list
+	CContactItem* tempTemplate = CntTest->Db()->ReadContactLC(templateId,*itemDef);
+
+	CContactItem* newContactItem = CContactCard::NewLC(tempTemplate);
+	CContactItemFieldSet& fieldSet = newContactItem->CardFields();
+    //
+	// fill up the contact
+	TInt counter=0;
+	for (;counter<fieldSet.Count();counter++)
+		{
+		if (!fieldSet[counter].Storage()->IsFull() && fieldSet[counter].StorageType()==KStorageTypeText)
+			fieldSet[counter].TextStorage()->SetTextL(KTestData);
+		}
+		
+	// add the new contact to the db
+	TContactItemId newItemID = CntTest->Db()->AddNewContactL(*newContactItem);  
+    //
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+    //
+	CContactItem* newContactItem2 = CntTest->Db()->OpenContactLX(newItemID,*itemDef);  // gets the new contact from the db
+	CleanupStack::PushL(newContactItem2);
+	CContactItemFieldSet& fieldSet2 = newContactItem2->CardFields();
+    //
+	// check the same
+	for (counter=0;counter<fieldSet2.Count();counter++)
+		{
+		if (fieldSet2[counter].StorageType()==KStorageTypeText)
+			{
+			TPtrC fieldText = fieldSet[counter].TextStorage()->Text();
+			TPtrC fieldText2 = fieldSet2[counter].TextStorage()->Text();
+			test.Printf(_L("\n Field %d = %S  ... %S "),counter,&fieldText,&fieldText2);	// Show what text is in field 3
+			User::After(20000);
+			//test.Getch();
+			}
+		}
+			
+	test.Printf(_L("\n"));
+	test.Next(_L("Remove Field Data and Check Persist"));
+
+	
+	fieldSet2[4].TextStorage()->SetStandardTextL(_L(""));
+	CntTest->Db()->CommitContactL(*newContactItem2);  // commit the changes
+
+	CContactItem* newContactItem3 = CntTest->Db()->OpenContactLX(newItemID,*itemDef);  // gets the new contact from the db
+	CleanupStack::PushL(newContactItem3);
+	CContactItemFieldSet& fieldSet3 = newContactItem3->CardFields();
+    //
+	// check the same
+	for (counter=0;counter<fieldSet3.Count();counter++)
+		{
+		if (fieldSet3[counter].StorageType()==KStorageTypeText)
+			{
+			TPtrC fieldText = fieldSet[counter].TextStorage()->Text();
+			TPtrC fieldText2 = fieldSet2[counter].TextStorage()->Text();
+			TPtrC fieldText3 = fieldSet3[counter].TextStorage()->Text();
+			test.Printf(_L("\n Field %d = %S  ... %S  ... %S "),counter,&fieldText,&fieldText2,&fieldText3);	// Show what text is in field 3
+			User::After(20000);
+			//test.Getch();
+			}
+		}
+	fieldSet3[5].TextStorage()->SetStandardTextL(_L(""));
+	CntTest->Db()->CommitContactL(*newContactItem3);  // commit the changes
+
+	CContactItem* newContactItem4 = CntTest->Db()->OpenContactLX(newItemID,*itemDef);  // gets the new contact from the db
+	CleanupStack::PushL(newContactItem4);
+	CContactItemFieldSet& fieldSet4 = newContactItem4->CardFields();
+    //
+	// check the same
+	for (counter=0;counter<fieldSet4.Count();counter++)
+		{
+		if (fieldSet4[counter].StorageType()==KStorageTypeText)
+			{
+			TPtrC fieldText = fieldSet[counter].TextStorage()->Text();
+			TPtrC fieldText2 = fieldSet2[counter].TextStorage()->Text();
+			TPtrC fieldText3 = fieldSet3[counter].TextStorage()->Text();
+			TPtrC fieldText4 = fieldSet4[counter].TextStorage()->Text();
+			test.Printf(_L("\n Field %d = %S  ... %S  ... %S ... %S "),counter,&fieldText,&fieldText2,&fieldText3,&fieldText4);	// Show what text is in field 3
+			User::After(20000);
+			//st.Getch();
+			}
+		}
+    //
+	CntTest->Db()->CloseContactL(newContactItem4->Id());  // commit the changes
+	CleanupStack::PopAndDestroy(10); // tempIdList tempTemplate openlx newContactItem2, itemDef
+	}
+
+
+LOCAL_C void DeleteTemplateCheckPersist()
+	{
+	test.Next(_L("Delete Template Check Persist"));
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	for (TInt counter=0; counter<templateCount; counter++)
+		{
+		CntTest->Db()->DeleteContactL((*tempIdList)[counter]);
+		}
+    //
+	for (TInt counter2=KTotalNumRecords-10; counter2<(KTotalNumRecords*templateCount); counter2+=KTotalNumRecords)
+		{
+		CContactItem* contact = CntTest->Db()->ReadContactL(counter2);
+		delete contact;
+		}
+
+	CContactIdArray* tempIdList2 = CntTest->Db()->GetCardTemplateIdListL();
+	TInt templateCount2 = tempIdList2->Count();
+	test(templateCount2==0);
+	delete tempIdList2;
+	CleanupStack::PopAndDestroy(); // tempIdList
+	}
+
+
+LOCAL_C void CheckManyTemplates()
+    //
+    // create MANY templates
+    //
+	{
+	test.Next(_L("Create MANY Templates"));
+
+    //
+	CntTest->CloseDatabase();
+	CntTest->DeleteDatabaseL();
+	CntTest->CreateDatabaseL();
+
+	TTime before;
+	before.UniversalTime();
+	for (TInt counter=0; counter<KTotalNumRecords; counter++)
+		{
+ 		CContactItem* tempTemplate = CntTest->Db()->CreateContactCardTemplateL(_L("TEMPLATE"));
+		delete tempTemplate;
+		if (counter%100==0)
+			test.Printf(_L("."));	// Just to show some life
+		}
+	test(CntTest->Db()->TemplateCount()==KTotalNumRecords);
+	TTime after;
+	after.UniversalTime();
+	TTimeIntervalSeconds secondsTaken;
+	after.SecondsFrom(before,secondsTaken);
+	test.Printf(_L(" TIME: %d  Secs"),secondsTaken.Int());
+	test.Printf(_L("\n"));	
+	}
+
+
+LOCAL_C void TestModifyCardAttribs()
+    //
+    // set attribs and check persist
+    //
+	{
+	test.Next(_L("set attribs check persist"));
+    //
+    // multiple template created card
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	TContactItemId templateId = (*tempIdList)[0]; // first in the list
+	delete tempIdList;
+	CContactItem* tempTemplate = CntTest->Db()->OpenContactLX(templateId);	
+    //
+    // golden template created card 
+
+    //	CContactItem* tempTemplate = CntTest->Db()->OpenContactLX(0);
+    //
+	CleanupStack::PushL(tempTemplate);
+	CContactItem* newContactItem = CContactCard::NewLC(tempTemplate);
+	CntTest->Db()->CloseContactL(tempTemplate->Id());
+	CContactItemFieldSet& fieldSet = newContactItem->CardFields();
+    //
+	// fill up the contact
+	TInt counter=0;
+	for (;counter<fieldSet.Count();counter++)
+		{
+		if (!fieldSet[counter].Storage()->IsFull() && fieldSet[counter].StorageType()==KStorageTypeText)
+			fieldSet[counter].TextStorage()->SetTextL(KTestData);
+		}		
+	// add the new contact to the db
+	TContactItemId newItemID = CntTest->Db()->AddNewContactL(*newContactItem);  
+    //
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+
+	CContactItem* newContactItem2 = CntTest->Db()->OpenContactLX(newItemID);
+	CleanupStack::PushL(newContactItem2);
+	CContactItemFieldSet& fieldSet2 = newContactItem2->CardFields();
+    //
+	for (counter=0;counter<fieldSet2.Count();counter++)
+		{
+		fieldSet2[counter].SetPrivate(ETrue);
+		if (counter%2)
+			{
+			fieldSet2[counter].SetHidden(ETrue);
+			test.Printf(_L("\n Field %d is SetHidden"),counter);
+			User::After(20000);
+			}
+		else
+			{
+			fieldSet2[counter].SetReadOnly(ETrue);
+			test.Printf(_L("\n Field %d is ReadOnly"),counter);
+			User::After(20000);
+			}
+		}
+	CntTest->Db()->CommitContactL(*newContactItem2);  // commit the changes		
+	CleanupStack::PopAndDestroy(2); // newContactItem2 openlx
+
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+
+	test.Printf(_L("\n"));
+    //	
+	test.Next(_L("Check hidden Persists"));
+
+	CContactItem* newContactItem3 = CntTest->Db()->OpenContactL(newItemID);  
+	CleanupStack::PushL(newContactItem3);
+	CContactItemFieldSet& fieldSet3 = newContactItem3->CardFields();
+	// check the same
+	for (counter=0;counter<fieldSet3.Count();counter++)
+		{
+		if (fieldSet3[counter].IsHidden())
+			{
+			if (fieldSet3[counter].IsPrivate())
+				{
+				test.Printf(_L("\n Field %d is Hidden & PRIVATE"),counter);
+				User::After(20000);
+				}
+			else
+				{
+				test.Printf(_L("\n Field %d is Hidden"),counter);
+				User::After(20000);
+				}
+			}
+		if (fieldSet3[counter].IsReadOnly())
+			{
+			if (fieldSet3[counter].IsPrivate())
+				{
+				test.Printf(_L("\n Field %d is READ ONLY & PRIVATE"),counter);
+				User::After(20000);
+				}
+			else
+				{
+				test.Printf(_L("\n Field %d is READ ONLY "),counter);
+				User::After(20000);
+				}
+			}
+		}
+	CntTest->Db()->CloseContactL(newContactItem3->Id());  
+	CleanupStack::PopAndDestroy(4); // newContactItem2 openlx
+	}
+
+
+LOCAL_C void PopulateUsingManyTemplates()
+    //
+    // create MANY templates
+    //
+	{
+	test.Next(_L("Create Contacts from MANY Templates"));
+
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+	test(templateCount == KTotalNumRecords);
+    //
+	TTime before;
+	before.UniversalTime();
+	for (TInt counter=0; counter<KTotalNumRecords; counter++)
+		{
+ 		CContactItem* tempTemplate = CntTest->Db()->ReadContactL((*tempIdList)[counter]);
+		CleanupStack::PushL(tempTemplate);
+		PopulateDatabaseL(*tempTemplate, 1, ETrue, EFalse);
+		if (counter%100==0)
+			test.Printf(_L("."));	// Just to show some life
+		CleanupStack::PopAndDestroy(); // tempTemplate
+		}
+	TTime after;
+	after.UniversalTime();
+	TTimeIntervalSeconds secondsTaken;
+	after.SecondsFrom(before,secondsTaken);
+	test.Printf(_L(" TIME: %d  Secs"),secondsTaken.Int());
+	test.Printf(_L("\n"));	
+	CleanupStack::PopAndDestroy();  // tempIdList
+	}
+
+
+LOCAL_C void DeleteManyTemplates()
+    //
+    // Delete MANY templates
+    //
+	{
+	test.Next(_L("Delete MANY Templates"));
+
+    //
+	CContactIdArray* tempIdList = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(tempIdList);
+	TInt templateCount = tempIdList->Count();
+
+	// -1 because of DeletePreferredTemplate()
+	test(templateCount == KTotalNumRecords - 1);
+    //
+	TTime before;
+	before.UniversalTime();
+
+	// -1 because of DeletePreferredTemplate()
+	for (TInt counter=0; counter<KTotalNumRecords-1; counter++)
+		{
+ 		CntTest->Db()->DeleteContactL((*tempIdList)[counter]);
+		if (counter%100==0)
+			test.Printf(_L("."));	// Just to show some life
+		}
+	TTime after;
+	after.UniversalTime();
+	TTimeIntervalSeconds secondsTaken;
+	after.SecondsFrom(before,secondsTaken);
+	test.Printf(_L(" TIME: %d  Secs"),secondsTaken.Int());
+	test.Printf(_L("\n"));	
+	CContactIdArray* tempIdList2 = CntTest->Db()->GetCardTemplateIdListL();
+	test(tempIdList2->Count()==0);
+	delete tempIdList2;
+	CleanupStack::PopAndDestroy();  // tempIdList
+	}
+
+LOCAL_C void SetTemplateName()
+	{
+//
+	test.Next(_L("Set Template Label"));
+
+	CContactIdArray* templateIds = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(templateIds);
+	CContactItem* tempTemplate = CntTest->Db()->OpenContactL((*templateIds)[1]);	
+	TContactItemId id = tempTemplate->Id();
+	CleanupStack::PushL(tempTemplate);
+	TBuf<32> label;
+	label.Format(KTestLabel,99);
+	STATIC_CAST(CContactCardTemplate*,tempTemplate)->SetTemplateLabelL(label);
+
+	CntTest->Db()->CommitContactL(*tempTemplate);
+	CntTest->Db()->CloseContactL(id);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+
+	CContactItem* tempTemplate2 = CntTest->Db()->OpenContactL(id);
+	TPtrC tempLabel = STATIC_CAST(CContactCardTemplate*,tempTemplate2)->GetTemplateLabelL();
+	CntTest->Db()->CloseContactL(id);
+	test(tempLabel==label);
+	delete tempTemplate2;
+	CleanupStack::PopAndDestroy(2);  // tempTemplate templateIds
+	}
+
+
+LOCAL_C void SetPreferredTemplate()
+	{
+	test.Next(_L("Set & Test Preferred Template"));
+
+	CContactIdArray* templateIds = CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(templateIds);
+    //
+	TInt templateCount = templateIds->Count();
+	test(templateCount == KTotalNumRecords);
+    //
+	TContactItemId prefTemplateId = CntTest->Db()->PrefTemplateId();
+	test(prefTemplateId == KNullContactId);
+
+    // set the preferred template 
+	CContactItem* firstTemplate = CntTest->Db()->ReadContactLC((*templateIds)[0]);
+	CntTest->Db()->SetPrefTemplateL(*firstTemplate);
+
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	
+	prefTemplateId = CntTest->Db()->PrefTemplateId();
+	test(prefTemplateId == firstTemplate->Id());
+    //
+	CleanupStack::PopAndDestroy(2, templateIds); // firstTemplate;
+	}
+
+
+LOCAL_C void SetBadPreferredTemplate()
+	{
+	// this function is TRAPD
+	test.Next(_L("Set BAD pref Template"));
+	CContactItem* item=CContactCard::NewLC();
+	TBuf<16> name;
+	name.Format(KTestName,1);
+   	SetNameL(*item,KUidContactFieldGivenName,name);
+	CntTest->Db()->AddNewContactL(*item);
+	CntTest->Db()->SetPrefTemplateL(*item);
+	// should leave with KErrNotSupported
+	}
+
+LOCAL_C void DeletePreferredTemplate()
+	{
+	// this function is TRAPD
+	test.Next(_L("Delete pref Template"));
+
+
+	// get the template id
+	TContactItemId prefTemplateId = CntTest->Db()->PrefTemplateId();
+	test(prefTemplateId != KNullContactId);
+
+	// delete the preferred template
+	CntTest->Db()->DeleteContactL(prefTemplateId);
+	
+
+	// retest the preftempId
+	prefTemplateId = CntTest->Db()->PrefTemplateId();
+	// and ensure it has been reset to null.
+	test(prefTemplateId == KNullContactId);
+
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+
+	prefTemplateId = CntTest->Db()->PrefTemplateId();
+	test(prefTemplateId == KNullContactId);
+	}
+
+
+LOCAL_C void DeleteAll()
+	{
+	// creates a new database - adds loads of contacts based on the golden template
+	// then deletes everything, then creates loads of contacts based on a cardtemplate
+	// then deletes everything.
+
+	CntTest->CloseDatabase();
+	CntTest->DeleteDatabaseL();
+	CntTest->CreateDatabaseL();
+	test.Next(_L("Delete All based on Golden"));
+
+    // get the golden template
+	CContactItem* goldenTemplate = CntTest->Db()->OpenContactLX(0);
+	CleanupStack::PushL(goldenTemplate); // 2 things on the stack
+
+	TInt i=0;
+	for (; i<KTotalNumRecords; i++)
+		{
+		CContactItem* newItem = CContactCard::NewLC(goldenTemplate);
+		CntTest->Db()->AddNewContactL(*newItem);
+		CleanupStack::PopAndDestroy(); //newItem
+		}
+	CntTest->Db()->CloseContactL(0);
+	const CContactIdArray* sortedItems = CntTest->Db()->SortedItemsL();
+
+	// delete the all entries in the db.
+	TInt dbCount = sortedItems->Count();
+
+	for (i=dbCount-1; i > -1; i--)
+		{
+		CntTest->Db()->DeleteContactL((*sortedItems)[i]);
+		}
+	
+	dbCount = CntTest->Db()->CountL();
+
+	// now wit multi template
+	CContactItem* tempTemplate = CntTest->Db()->CreateContactCardTemplateL(_L("label1"));
+	CleanupStack::PushL(tempTemplate);
+
+	for (i=0; i<KTotalNumRecords; i++)
+		{
+		CContactItem* newItem = CContactCard::NewLC(tempTemplate);
+		CntTest->Db()->AddNewContactL(*newItem);
+		CleanupStack::PopAndDestroy(); //newItem
+		}
+	CntTest->Db()->CloseContactL(0);
+	const CContactIdArray* sortedItems2 = CntTest->Db()->SortedItemsL();
+
+	// delete the all entries in the db.
+	dbCount = sortedItems2->Count();
+
+	for (i=dbCount-1; i > -1; i--)
+		{
+		CntTest->Db()->DeleteContactL((*sortedItems2)[i]);
+		}
+	
+	dbCount = CntTest->Db()->CountL();
+
+	CleanupStack::PopAndDestroy(3); // goldenTemplate close() tempTemplate
+	}
+
+
+LOCAL_C void TestTemplateCachingL()
+//
+// create MANY templates
+//
+	{
+    const TInt KNumTestTemplates=32;
+	test.Next(_L("Template caching"));
+    //
+	CntTest->CloseDatabase();
+	CntTest->DeleteDatabaseL();
+	CntTest->CreateDatabaseL();
+
+	CContactIdArray* cntIdArray=CContactIdArray::NewLC();
+	for (TInt loop=0; loop<KNumTestTemplates; loop++)
+		{
+		TBuf<32> buf;
+		buf.Format(_L("Template Cache %2d"),loop);
+ 		CContactItem* tempTemplate = CntTest->Db()->CreateContactCardTemplateLC(buf);
+		TContactItemId templateId=tempTemplate->Id();
+		CleanupStack::PopAndDestroy();	// tempTemplate
+        //
+		tempTemplate=(CContactCardTemplate*)CntTest->Db()->OpenContactLX(templateId);
+		CleanupStack::PushL(tempTemplate);	// 
+		for(TInt delLoop=tempTemplate->CardFields().Count()-1;delLoop>=0;delLoop--)
+			tempTemplate->RemoveField(delLoop);
+		CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,KUidContactFieldGivenName);
+		buf.Format(_L("Label %2d"),loop);
+		field->SetLabelL(buf);
+		tempTemplate->AddFieldL(*field);
+		CleanupStack::Pop();	// field
+		CntTest->Db()->CommitContactL(*tempTemplate);
+		CleanupStack::PopAndDestroy(2);	// tempTemplate, close template
+        //
+		tempTemplate=(CContactCardTemplate*)CntTest->Db()->ReadContactLC(templateId);
+ 		CContactCard *card=CContactCard::NewLC(tempTemplate);
+		cntIdArray->AddL(CntTest->Db()->AddNewContactL(*card));
+		CleanupStack::PopAndDestroy(2);	// tempTemplate,card
+		}
+	test(CntTest->Db()->TemplateCount()==KNumTestTemplates);
+	CContactIdArray *ids=CntTest->Db()->GetCardTemplateIdListL();
+	CleanupStack::PushL(ids);
+	test(ids->Count()==KNumTestTemplates);
+	for (TInt loop2=0; loop2<KNumTestTemplates; loop2++)
+		{
+		TBuf<32> name;
+		name.Format(_L("Template Cache %2d"),loop2);
+		TBuf<32> label;
+		label.Format(_L("Label %2d"),loop2);
+		for (TInt mode=0; mode<3; mode++)
+			{
+			if (mode==1)
+				{
+				CContactCardTemplate* editTemplate=(CContactCardTemplate*)CntTest->Db()->OpenContactLX((*ids)[loop2]);
+				CleanupStack::PushL(editTemplate);
+				name.Format(_L("Template Cache B%2d"),loop2);
+				label.Format(_L("Label B%2d"),loop2);
+				editTemplate->SetTemplateLabelL(name);
+				editTemplate->CardFields()[1].SetLabelL(label);
+				CntTest->Db()->CommitContactL(*editTemplate);
+				CleanupStack::PopAndDestroy(2);	// tempTemplate2,close template
+				}
+			else
+				{
+				CContactItem* card=CntTest->Db()->ReadContactLC((*cntIdArray)[loop2]);
+				CContactCardTemplate* tempTemplate2=(CContactCardTemplate*)CntTest->Db()->ReadContactLC((*ids)[loop2]);
+				test(tempTemplate2->GetTemplateLabelL()==name);
+				TBuf<32> tl1(card->CardFields()[0].Label());
+				TBuf<32> tl2(tempTemplate2->CardFields()[1].Label());
+				test(tl1==label);
+				test(tl2==label);
+				CleanupStack::PopAndDestroy(2);	// card,tempTemplate2
+				}
+			}
+		}
+	CleanupStack::PopAndDestroy(2);	// ids,cntIdArray
+	}
+
+//
+//
+//	Main dispatching module
+//
+//
+/**
+
+@SYMTestCaseID     PIM-T-CARDTM-0001
+
+*/
+
+void DoTestsL()
+    {
+    //	UserHal::SetAutoSwitchOffBehavior(ESwitchOffDisabled);
+	test.Start(_L("@SYMTESTCaseID:PIM-T-CARDTM-0001 Create new database"));
+	
+	TRAPD(err,CntTest->CreateDatabaseL());
+	test(err==KErrNone);
+
+	TRAP(err,CreateCardTemplateL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,CheckCardTemplateListPersistL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,CreateEmptyContactsFromTemplateL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,CheckEmptyContactsFromTemplatePersistL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,CreateFullContactsFromTemplateL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,CheckFullContactsFromTemplatePersistL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,ModifyAddTemplateL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,CheckModifyAddContactsFromTemplatePersistL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,ModifyRemoveTemplateL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,CheckModifyRemoveContactsFromTemplatePersistL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,SetTemplateLabelL());
+	test(err==KErrNone);
+	CntTest->CloseDatabase();
+	CntTest->OpenDatabaseL();
+	TRAP(err,CheckFieldLabelsPersistL());
+	test(err==KErrNone);
+	TRAP(err,DeleteCardTemplateL());
+	test(err==KErrNone);
+	TRAP(err,CheckDeleteCardTemplateL());
+	test(err==KErrNone);
+	TRAP(err,CheckLargePopulatedTemplate());
+	test(err==KErrNone);
+	TRAP(err,ModifyCardBasedOnTemplate());
+	test(err==KErrNone);
+	TRAP(err,DeleteTemplateCheckPersist());
+	test(err==KErrNone);
+	TRAP(err,CheckManyTemplates());
+	test(err==KErrNone);
+	TRAP(err,TestModifyCardAttribs());
+	test(err==KErrNone);
+	TRAP(err,PopulateUsingManyTemplates());
+	test(err==KErrNone);
+	TRAP(err,SetTemplateName());
+	test(err==KErrNone);
+	TRAP(err,SetPreferredTemplate());
+	test(err==KErrNone);
+	TRAP(err,SetBadPreferredTemplate());
+	test(err==KErrNotSupported);
+	TRAP(err,DeletePreferredTemplate());
+	test(err==KErrNone);
+	TRAP(err,DeleteManyTemplates());
+	test(err==KErrNone);
+	TRAP(err,TestTemplateCachingL());
+	test(err==KErrNone);
+	TRAP(err,DeleteAll());
+	test(err==KErrNone);
+    //	TestCardTemplateCreationL(*(CntTest->Db()));
+	CntTest->CloseDatabase();
+	
+	test.Next(_L("Delete database"));
+
+	TRAP(err,CntTest->DeleteDatabaseL());
+	test(err==KErrNone);
+	}
+
+GLDEF_C TInt E32Main()
+	{
+	__UHEAP_MARK;
+    CntTest=new(ELeave) CCntTest;
+	CntTest->ConstructL(test,KDatabaseFileName);
+    TRAPD(err,DoTestsL());
+	CntTest->EndTestLib(err);
+	__UHEAP_MARKEND;
+	return KErrNone;
+    }