#include <e32test.h>

GLDEF_D CCntTest* CntTest=NULL;

GLDEF_D RTest test(_L("T_DBASE2"));

_LIT(KDatabaseFileName,"C:T_DBASE2");

#ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__

_LIT(KPhysicalPathToDatabase, "c:\\private\\10003A73\\T_DBASE2");

#else

_LIT(KPhysicalPathToDatabase, "c:\\private\\10003A73\\SQLite__T_DBASE2");

#endif

const TPtrC KTestEmailAddress=_L("testEmail@symbian.com");

class CAsyncFinder : public CBase, public MIdleFindObserver

	{

public:

	~CAsyncFinder();

	void ConstructL(CContactDatabase *aContactDatabase, const TDesC& aText,const CContactItemFieldDef *aFieldDef);

	void ConstructL(CContactDatabase *aContactDatabase, const CDesCArray& aFindWords,const CContactTextDef *aTextDef,const TCallBack &aCallBack);

	inline CContactIdArray *TakeContactIds() {return(iFinder->TakeContactIds());};

	inline TInt Error() const {return(iFinder->Error());};

protected:

// from MIdleFindObserver

	void IdleFindCallback();

private:

	CIdleFinder *iFinder;

	};

GLDEF_C void Panic(TInt aPanic)

//

// Panic the thread with CNTMODEL as the category

//

	{

	User::Panic(_L("T_DBASE2"),aPanic);

	}

LOCAL_C void CreateExistingDatabaseTestL()

	{

	TRAPD(err,CContactDatabase::CreateL(KDatabaseFileName));

	test(err==KErrAlreadyExists);

	CContactDatabase *db=NULL;

	TRAP(err,db=CContactDatabase::OpenL(KDatabaseFileName));

	test(err==KErrNone);

	delete db;

	}

LOCAL_C void SetNameL(CContactItem& aItem,TUid aType,const TDesC& aName, TBool aAddField = EFalse)

//

// Set the contents of a text field, creating the field if required

//

	{

	CContactItemFieldSet& fieldSet=aItem.CardFields();

	const TInt pos=fieldSet.Find(aType);

	if (!aAddField && pos!=KErrNotFound)

		fieldSet[pos].TextStorage()->SetTextL(aName);

	else

		{

		CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,aType);

   		field->SetMapping(KUidContactFieldVCardMapUnusedN);

		field->TextStorage()->SetTextL(aName);

		aItem.AddFieldL(*field);

		CleanupStack::Pop(); // field

		}

	}

LOCAL_C TContactItemId AddPhoneContact(const TDesC& aName, const TDesC& aNumber)

	{

	CContactItem* item = CContactCard::NewLC();

	SetNameL(*item, KUidContactFieldGivenName, aName, ETrue);

	SetNameL(*item, KUidContactFieldPhoneNumber, aNumber, ETrue);

	TContactItemId newId = CntTest->Db()->AddNewContactL(*item);

	CleanupStack::PopAndDestroy();	// item

	return(newId);

	}

LOCAL_C TInt PopulateDatabaseForAsyncFindByEmailAddrTest(const TDesC& aEmailAddress)

	{

	//This function generates a database upon which CContactDatabase::AsyncFindL(...) will fail

	//as described in DEF036083, thereby validating the provided fix.

	//The database comprises 23 entries distributed across two groups.

	//Only one entry contains the email address that will match the search criteria used by

	//the AsyncFundByEmailTest(...) function.

	//It returns the number of items that have aEmailAddress (which is 1).

	CContactIdArray* array = NULL;

	for(TInt i = 0; i < 2; i++) 

	{

		TBuf<16> groupName(_L("group"));

		groupName.AppendNum(i+1);

		CContactItem* group = CntTest->Db()->CreateContactGroupLC(groupName);

		CleanupStack::PopAndDestroy(group);

	}

	array = CntTest->Db()->GetGroupIdListL();

	CleanupStack::PushL(array);

	// Get two groups

	CContactGroup* group = STATIC_CAST(CContactGroup*, CntTest->Db()->ReadContactLC((*array)[0]));

	const TContactItemId groupId1 = group->Id();

	CleanupStack::PopAndDestroy(group);

	group = NULL;

	group = STATIC_CAST(CContactGroup*, CntTest->Db()->ReadContactLC((*array)[1]));

	const TContactItemId groupId2 = group->Id();

	CleanupStack::PopAndDestroy(group);

	CleanupStack::PopAndDestroy(array);

	TBuf<128> buffer;

	TTime now;

	now.UniversalTime();

	TInt64 seed=now.Int64();

	for(TInt ii = 1; ii <= 23; ii++) 

		{

		CContactCard* newContact = CContactCard::NewLC();

		// Create random first and last names

		TBuf<16> firstName;

		TBuf<16> lastName;

		TInt c = (Math::Rand(seed)%26)+'A';

		firstName.Append(c);

		c = (Math::Rand(seed)%26)+'A';

		lastName.Append(c);

		TInt jj;

		for(jj=1;jj<16;jj++)

			{

			c=(Math::Rand(seed)%26)+'a';

			firstName.Append(c);

			if(jj>4 && (Math::Rand(seed)&4)==0)

				break;

			}

		for(jj=1;jj<16;jj++)

			{

			c=(Math::Rand(seed)%26)+'a';

			lastName.Append(c);

			if(jj>4 && (Math::Rand(seed)&4)==0)

				break;

			}

		SetNameL(*newContact,KUidContactFieldGivenName,firstName);

		SetNameL(*newContact,KUidContactFieldFamilyName,lastName);

		if(Math::Rand(seed)%4)

			{

			buffer=firstName;

			buffer.Append('.');

			buffer.Append(lastName);

			buffer.Append(_L("@email-address.com"));

			SetNameL(*newContact,KUidContactFieldEMail,buffer);

			}

		if(Math::Rand(seed)%4)

			SetNameL(*newContact,KUidContactFieldUrl,_L("http://www.some-web-address.co.uk"));

		if(Math::Rand(seed)%4)

		if(Math::Rand(seed)%4)

		if(Math::Rand(seed)%4)

		if(Math::Rand(seed)%4)

		if(Math::Rand(seed)%4)

			SetNameL(*newContact,KUidContactFieldNote,_L("The quick brown fox jumps over the smelly dog The quick brown dog jumps over the smelly cat"));

		if(Math::Rand(seed)%4)

		const TContactItemId id = CntTest->Db()->AddNewContactL(*newContact);

		CleanupStack::PopAndDestroy(newContact);

		if(Math::Rand(seed)%2)

			CntTest->Db()->AddContactToGroupL(id, groupId1);

		else

			CntTest->Db()->AddContactToGroupL(id, groupId2);

		}

		//Modify the 23rd entry so that it has a specific email address that will

		//be the search criteria used in AsyncFindByEmailTest(...).

		CContactItem* itemToModify = NULL;

		TContactIter iter(*CntTest->Db());

		TInt theid;

		theid=iter.FirstL();

		while(theid!=KNullContactId )

		{

			if(theid == 23)

			{

				itemToModify=CntTest->Db()->OpenContactL(theid);

				CleanupStack::PushL(itemToModify);

				buffer.Zero();

				buffer.Append(aEmailAddress);

				SetNameL(*itemToModify,KUidContactFieldEMail,buffer);

				CntTest->Db()->CommitContactL(*itemToModify);

				CleanupStack::PopAndDestroy(itemToModify);

			}

			theid=iter.NextL();

		}

		return 1;

	}

LOCAL_C void PopulateDatabaseL(TBool aPhoneNumbers)

//

// Create and populate the database

//

	{

	for (TInt ii=0;ii<KTotalNumRecords;ii++)

		{

		CContactItem* item=CContactCard::NewLC();

		TBuf<16> name;

		name.Format(KTestName,ii);

   		SetNameL(*item,KUidContactFieldFamilyName,name,ETrue);

		if (aPhoneNumbers)

			{

			TBuf<20> number;

			switch(ii%3)

				{

				case 0:

					number.Format(_L("0171-%03d %04d"),(ii*9)%1000,((ii+11)*23)%10000);

					break;

				case 1:

					number.Format(_L("%04d:%04d:%04d:%04d"),(ii*123)%10000,(ii*666)%10000,(ii*234)%10000);

					break;

				case 2:

					number.Format(_L("+00%d-%03d %04d"),(ii*123)%100,(ii*13)%1000,((ii+13)*17)%10000);

					break;

				}

   			SetNameL(*item,KUidContactFieldPhoneNumber,number,ETrue);

			if (!(ii%2))

				{

				number.Format(_L("0181-%03d %04d"),(ii*8)%1000,((ii+11)*22)%10000);

	   			SetNameL(*item,KUidContactFieldPhoneNumber,number,ETrue);

				number.Format(_L("01734-%06d"),(ii*123456)%1000000);

	   			SetNameL(*item,KUidContactFieldPhoneNumber,number,ETrue);

				}

			}

		if (ii%2)

			{

			TBuf<16> address;

			address.Format(KTestAddress,ii);

			CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,KUidContactFieldAddress);

			field->SetMapping(KUidContactFieldVCardMapADR);

			field->TextStorage()->SetText(address.AllocL());

			item->AddFieldL(*field);

			CleanupStack::Pop(); // field

			}

		if (ii%3)

			{

			CContactItemField* field=CContactItemField::NewLC(KStorageTypeDateTime,KUidContactFieldBirthday);

			field->DateTimeStorage()->SetTime(TDateTime(1990+ii,(TMonth)(ii%12),(ii*3)%28,1,2,3,4));

			item->AddFieldL(*field);

			CleanupStack::Pop(); // field

			}

		if (ii%4)

			{

			CContactItemField* field=CContactItemField::NewLC(KStorageTypeStore);

    		field->SetMapping(KUidContactFieldVCardMapAGENT);

			item->AddFieldL(*field);

			CleanupStack::Pop(); // field

			}

		if (ii%6)

			{

			CContactItemField* field=CContactItemField::NewLC(KStorageTypeContactItemId);

			field->SetMapping(KUidContactFieldVCardMapAGENT);

			item->AddFieldL(*field);

			CleanupStack::Pop(); // field

			}

		CntTest->Db()->AddNewContactL(*item);

		CleanupStack::PopAndDestroy(); // item

		}

	CntTest->Db()->SetDateFormatTextL(_L("%E%D%X%N%Y %1 %2 %3"));

	}

LOCAL_C void CreateBasicContactGroupsL()

	{

	test.Next(_L("Create Basic Groups"));

	__ASSERT_ALWAYS(CntTest->Db()->GroupCount()==0,Panic(KErrGeneral));

	CntTest->Db()->CreateContactGroupLC(_L("New Group 1"));

	CntTest->Db()->CreateContactGroupLC(_L("New Group 2"));

	CntTest->CloseDatabase();

	CntTest->OpenDatabaseL();

	test(CntTest->Db()->GroupCount()==2);

	CleanupStack::PopAndDestroy(2); // newGroup newGroup2

	}

LOCAL_C void CreateBasicOwnCardL()

	{

	test.Next(_L("Create Basic Own Card"));

	CContactItem* newOwn = CntTest->Db()->CreateOwnCardL();

	delete newOwn;

	CntTest->CloseDatabase();

	CntTest->OpenDatabaseL();

	CContactItem* newOwnCard = CntTest->Db()->OpenContactLX(CntTest->Db()->OwnCardId());

	CleanupStack::PushL(newOwnCard);

	CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,KUidContactFieldFamilyName);

	field->SetMapping(KUidContactFieldVCardMapUnusedN);

	field->TextStorage()->SetTextL(_L("Dale"));

	newOwnCard->AddFieldL(*field);

	CntTest->Db()->CommitContactL(*newOwnCard);

	CleanupStack::Pop(); // field

	CleanupStack::PopAndDestroy(2); // newOwnCard close

	}

LOCAL_C void NavigateL()

	{

	test.Next(_L("Navigate from start to end"));

	TContactIter iter(*CntTest->Db());

	TContactItemId id=iter.FirstL();

	TInt count=1;

	FOREVER

		{

		TContactItemId newId=iter.NextL();

		if (newId==id || newId==KNullContactId)

			break;

		++count;

		}

	test(count==KTotalNumRecords); // +1 for own card

	test.Next(_L("Navigate from end to start"));

	id=iter.LastL();

	count=1;

	FOREVER

		{

		TContactItemId newId=iter.PreviousL();

		if (newId==id || newId==KNullContactId)

			break;

		++count;

		}

	test(count==KTotalNumRecords); // +1 for own card

	}

LOCAL_C void CrystalSortRegressionTestL()

	{

	test.Next(_L("Sort regression test"));

	CContactDatabase& db = *CntTest->CreateDatabaseL();

	_LIT(KFirstNameCarl,"Carl");

	_LIT(KFirstNameChris,"Chris");

	TContactItemId one=AddContactL(&db,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,KFirstNameCarl);

	TContactItemId two=AddContactL(&db,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,KFirstNameChris);

	CContactIdArray* unsortedArray = CContactIdArray::NewLC();

	unsortedArray->AddL(one);

	unsortedArray->AddL(two);

	CArrayFix<CContactDatabase::TSortPref>* sortOrder = new(ELeave) CArrayFixFlat<CContactDatabase::TSortPref>(1);

	CleanupStack::PushL(sortOrder);

	CContactDatabase::TSortPref sortPref(KUidContactFieldDefinedText,CContactDatabase::TSortPref::EAsc);

	sortOrder->AppendL(sortPref);

	CContactIdArray* sorted = db.SortArrayLC(unsortedArray, sortOrder);

	test((*sorted)[0]==one);

	test((*sorted)[1]==two);

	CleanupStack::PopAndDestroy(3, unsortedArray);

	CntTest->CloseDatabase();

	}

LOCAL_C void CheckTemplateRefId()

	{

	test.Next(_L("Checking TemplateRefId after Commit"));

	CContactDatabase *db=CntTest->CreateDatabaseL();

	TContactItemId id=AddContactL(db,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("5432"));;

	__ASSERT_ALWAYS(id!=KNullContactId,Panic(KErrGeneral));

	CContactItem* item = db->OpenContactL(id);

	CleanupStack::PushL(item);	

	item->SetTemplateRefId(KNullContactId);

	db->CommitContactL(*item);

	CContactItem* retItem = db->ReadContactL(id);

	CleanupStack::PushL(retItem);	

	test(retItem->TemplateRefId()==KNullContactId);

	db->CloseContactL(id);

	CleanupStack::PopAndDestroy(2);

	CntTest->CloseDatabase();

	}

LOCAL_C void TestDeletingRecords()

	{

	test.Next(_L("Deleting records"));

//

	CContactDatabase *db=CntTest->CreateDatabaseL();

//	CntTest->DeleteAllTemplateFieldsL();

//

	TContactItemId id1=AddContactL(db,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("3333"));

	TContactItemId id2=AddContactL(db,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("2222"));

	TContactItemId id3=AddContactL(db,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("1111"));

	test(db->CountL()==3);  // +1 own card

	CntTest->AdjustContactAccessCountL(id2,1);

	db->DeleteContactL(id2);

	test(db->CountL()==2); // +1 own card

	CntTest->CheckDeletedContact(id2);

	CntTest->AdjustContactAccessCountL(id2,-1);

	CntTest->CheckContactDoesNotExist(id2);

	test(db->CountL()==2); // +1 own card

	db->DeleteContactL(id3);

	test(db->CountL()==1); // +1 own card

	CntTest->AdjustContactAccessCountL(id1,5);

	db->DeleteContactL(id1);

	test(db->CountL()==0); // +1 own card 

	CntTest->CheckDeletedContact(id1);

	CntTest->AdjustContactAccessCountL(id1,-4);

	CntTest->CheckDeletedContact(id1);

	CntTest->AdjustContactAccessCountL(id1,-1);

	CntTest->CheckContactDoesNotExist(id1);

//

	CntTest->CloseDatabase();

//

	db=CntTest->CreateDatabaseL();

	for(TInt loop=0;loop<200;loop++)

		{

		TBuf<128> text;

		text.Format(_L("Delete me %d"),loop);

		AddContactL(db,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,text);

		}

	db->DeleteContactsL(*CContactIdArray::NewLC(db->SortedItemsL()));

	CleanupStack::PopAndDestroy();	// Id Array

	test(db->SortedItemsL()->Count()==0);

	// Test full deletion of Phone Fields after Contact deletion INC047110

	_LIT(KShortNumber, "555");

	_LIT(KNameOne, "First");

	_LIT(KNameTwo, "Second");

	const TInt KNumMatchDigit = 3;

	// Add two Contacts with the same short (<7 digit) number

	TContactItemId ident1 = AddPhoneContact(KNameOne, KShortNumber);

	TContactItemId ident2 = AddPhoneContact(KNameTwo, KShortNumber);

	// delete one of them

	CntTest->Db()->DeleteContactL(ident1);

	CContactIdArray* array = CntTest->Db()->MatchPhoneNumberL(KShortNumber, KNumMatchDigit);

	CleanupStack::PushL(array);

	// the phone number related to ident1 should also be deleted

	test(array->Count() == 1);

	// tidy up

	CleanupStack::PopAndDestroy(array);

	CntTest->Db()->DeleteContactL(ident2);

	CntTest->CloseDatabase();

	}

LOCAL_C void TestLabelValidate(const TDesC &aLabel, TBool aValid, TInt aBadPos)

	{

	TInt badPos;

	TBool isValid=CContactItemField::IsValidLabel(aLabel,badPos);

	if (aValid)

		test(isValid);

	else

		{

		test(!isValid);

		test(aBadPos==badPos);

		}

	}

LOCAL_C void LabelValidating()

	{

	test.Next(_L("Label validating"));

	TestLabelValidate(_L("Good"),ETrue,0);

	TestLabelValidate(_L(""),ETrue,0);

	TestLabelValidate(_L("Bad.Label"),EFalse,3);

	TestLabelValidate(_L("."),EFalse,0);

	TestLabelValidate(_L("Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad Bad #Bad Bad Bad Bad Bad Bad Bad Bad "),ETrue,0);

	}

class CLetChangeNotiferRun : public CTimer

	{

public:

	inline CLetChangeNotiferRun() : CTimer(EPriorityStandard) {};

	void ConstructL();

	void RunL();

	};

void CLetChangeNotiferRun::RunL()

	{

	CActiveScheduler::Stop();

	}

void CLetChangeNotiferRun::ConstructL()

	{

	CTimer::ConstructL();

	CActiveScheduler::Add(this);

	}

LOCAL_C void CountL(TBool aCheckAll)

	{