/*

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

#include <cntitem.h>

#include <cntfield.h>

#include <cntfldst.h>

#include <phbksync.h>

#include "t_utils.h"

#include "./testsyncplugin/cnttestsynchroniser.h"

// include templates for CleanupResetAndDestroyPushL(T)

#include "cntviewprivate.h"

/** 

 * @file

 * Test harness for CContactICCEntry and MContactSynchroniser interface.

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

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

 *

 */

_LIT(KDatabaseFileName,"C:T_ICCENTRY");

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

_LIT(KGivenName,"Given");

_LIT(KGivenEditName,"EditedName");

_LIT(KTelephoneNum,"020 11111111");

_LIT(KTelephoneNumModified,"020 22222222");

_LIT(KTemplateName,"SIM Card Contacts"); 

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

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

CCntTest* CntTest=NULL;

LOCAL_D RTest test(KTestName);

LOCAL_D CContactTestSynchroniser* synchroniser;

LOCAL_D CContactSyncChecker* syncChecker;

LOCAL_C TInt findWordSplitterL(TAny *aParams)

	{

	SFindInTextDefWordParser *parser=(SFindInTextDefWordParser *)aParams;

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

	return(KErrNone);

	}

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

	{

	CContactIdArray* retval = NULL;

	retval = aDatabase.FindLC(aText, aFieldDef);

	aTest(retval == NULL);

	CleanupStack::Pop( retval );

	return retval;

	}

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

	{

	CContactIdArray* retval = NULL;

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

	aTest(retval==NULL);

	CleanupStack::Pop( retval );

	return retval;

	}

/** 

 * Test Finding ICC Contacts when the ICC is locked.

 * @param aDb Contact database

 */

void TestFindingL(CContactDatabase& aDb)

	{

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

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

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

	CContactItemFieldDef* fieldDef=new(ELeave) CContactItemFieldDef;

	CleanupStack::PushL(fieldDef);

	fieldDef->AppendL(KUidContactFieldFamilyName); 

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

	test(err==KErrLocked);

	CleanupStack::PopAndDestroy(fieldDef);

	CContactItemFieldDef* fieldDef2=new(ELeave) CContactItemFieldDef;

	CleanupStack::PushL(fieldDef2);

	fieldDef2->AppendL(KUidContactFieldPhoneNumber); 

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

	test(err==KErrLocked);

	CleanupStack::PopAndDestroy(fieldDef2);

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

	TCallBack callBack(findWordSplitterL);

	CContactTextDef* textDef=CContactTextDef::NewLC();

	textDef->AppendL(TContactTextDefItem(KUidContactFieldFamilyName));

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

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

	CContactIdArray* arr = NULL;

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

//	test(err==KErrLocked);

	desArray->Delete(0);

	delete desArray;

//FIX

	delete arr;	

	CleanupStack::PopAndDestroy(textDef); 

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

	TCallBack callBack2(findWordSplitterL);

	CContactTextDef* textDef2=CContactTextDef::NewLC();

	textDef2->AppendL(TContactTextDefItem(KUidContactFieldFamilyName));

	textDef2->AppendL(TContactTextDefItem(KUidContactFieldUrl));

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

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

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

//	test(err==KErrLocked);

	desArray2->Delete(0);

	delete desArray2;

//FIX

	delete arr;	

	CleanupStack::PopAndDestroy(textDef2);

	}

/** 

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

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

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

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

 * @param aDb Contact database

 */

void TestPhoneMatchingL(CContactDatabase& aDb)

	{

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

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

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

	delete array;

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

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

	syncChecker->SetValidateWriteResponseL(KErrNone);

	aDb.SetDbViewContactType(KUidContactICCEntry);

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

	CContactItem* item = aDb.OpenContactLX(id);

	CleanupStack::PushL(item);

	CContactItemFieldSet& fieldset = item->CardFields();

	const TInt pos = fieldset.Find(KUidContactFieldPhoneNumber);	

	CContactItemField& field = fieldset[pos];

	CContactTextField* textfield = field.TextStorage();

	textfield->SetTextL(KTelephoneNumModified);

	aDb.CommitContactL(*item);

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

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

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

	delete array2;

	}

/** 

 * Test database iteration using TContactIter.

 * @param aDb Contact database

 */

void TestDatabaseIterationL(CContactDatabase& aDb)

	{

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

	aDb.SetDbViewContactType(KUidContactICCEntry);

	TContactIter iterator(aDb);

	TContactItemId id = iterator.FirstL();

	while (id!=KNullContactId)

		{

		CContactItem* item = aDb.ReadContactLC(id);

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

		CleanupStack::PopAndDestroy(item);

		id = iterator.NextL();

		}

	}

CContactItem* ReadItemL( CContactDatabase& aDatabase, TContactItemId aId )

	{

	CContactItem* retval = NULL;

	retval = aDatabase.ReadMinimalContactLC( aId );

	CleanupStack::Pop( retval );

	return retval;

	}

/** 

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

 * ReadMinimalContactL API is used. 

 * 

 * Tests methods:

 * IMPORT_C CContactItem* ReadMinimalContactL(TContactItemId aContactId);

 * IMPORT_C CContactItem* ReadMinimalContactLC(TContactItemId aContactId);

 * 

 * @param aDb Contact database

 * @param aId Contact item ID to read

 */

void TestReadMinimalContactL(CContactDatabase& aDb, TContactItemId aId)

	{

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

	syncChecker->ResetMethodCallCountsL();

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

	CContactItem* item = aDb.ReadMinimalContactLC(aId);

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

	CleanupStack::PopAndDestroy(item);

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

	syncChecker->ResetMethodCallCountsL();

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

	item=NULL;

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

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

	delete item;

	test(err==KErrAccessDenied);

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

	}

/** 

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

 * ReadContactL API is used. 

 * 

 * Tests code called by methods:

 * IMPORT_C CContactItem* ReadContactL(TContactItemId aContactId);

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

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

 * IMPORT_C CContactItem* ReadContactLC(TContactItemId aContactId);

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

 * 

 * @param aDb Contact database

 * @param aId Contact item ID to read

 */

void TestReadContactL(CContactDatabase& aDb, TContactItemId aId)

	{

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

	syncChecker->ResetMethodCallCountsL();

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

	CContactItem* item = aDb.ReadContactLC(aId);

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

	CleanupStack::PopAndDestroy(item);

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

	syncChecker->ResetMethodCallCountsL();

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

	item=NULL;

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

	delete item;

	test(err==KErrAccessDenied);

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

	}

/** 

 * Verify that read validation is done for ReadContactTextDefL

 * 

 * @param aDb Contact database

 * @param aId Contact item ID to read

 */

void TestReadTextDefinitionL(CContactDatabase& aDb, TContactItemId aId)

	{

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

	syncChecker->ResetMethodCallCountsL();

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

	TBuf<64> textDef;

	aDb.ReadContactTextDefL(aId,textDef);

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

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

	syncChecker->ResetMethodCallCountsL();

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

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

	test(err==KErrAccessDenied);

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

	}

/** 

 * Create example ICC Entry 

 * @param aDb Contact database

 */

TContactItemId CreateTestICCEntryL(CContactDatabase& aDb)

	{

	TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook);

	CContactItem* iccTemplate = aDb.ReadContactLC(templateId);

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

	CleanupStack::PopAndDestroy(iccTemplate);

	CleanupStack::PushL(entry);

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

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

	//Add to database

	syncChecker->SetValidateWriteResponseL(KErrNone);

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

	syncChecker->SetDeleteContactResponseL(KErrNone);

	TContactItemId id = aDb.AddNewContactL(*entry); 

	CleanupStack::PopAndDestroy(entry);	

	test(id!=KNullContactId);

	return id;

	}

/**

 * Verify Read validation is being done for reading items.

 * @param aDb Contact database

 */

void TestReadL(CContactDatabase& aDb)

	{

	TContactItemId id = CreateTestICCEntryL(aDb);

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

	TestReadMinimalContactL(aDb,id);

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

	TestReadContactL(aDb,id);

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

	TestReadTextDefinitionL(aDb,id);

	}

/**

 * Verify that edit validation is being done for ICC entries

 * and write validation is done when Commit is called.

 * @param aDb Contact database

 * @param aId Item Id to edit

 */

void TestSuccessfulEditL(CContactDatabase& aDb, TContactItemId aId)

	{

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

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

	syncChecker->SetValidateWriteResponseL(KErrNone);

	syncChecker->ResetMethodCallCountsL();

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

	CContactItem* item = aDb.OpenContactLX(aId);

	CleanupStack::PushL(item);

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

	CContactItemFieldSet& fieldset = item->CardFields();

	const TInt pos = fieldset.Find(KUidContactFieldFamilyName);	

	CContactItemField& field = fieldset[pos];

	CContactTextField* textfield = field.TextStorage();

	textfield->SetTextL(KGivenEditName);

	aDb.CommitContactL(*item);

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

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

	}

/**

 * Unsuccessful edit. Fail the edit validation request

 * @param aDb Contact database

 * @param aId Item Id to edit

 */

void FailEditValidationL(CContactDatabase& aDb, TContactItemId aId)

	{

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

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

	syncChecker->ResetMethodCallCountsL();

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

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

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

	test(err==KErrAccessDenied);

	}

/**

 * Unsuccessful edit. Fail the write validation request

 * @param aDb Contact database

 * @param aId Item Id to edit

 */

void FailWriteValidationL(CContactDatabase& aDb, TContactItemId aId)

	{

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

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

	syncChecker->SetValidateWriteResponseL(KErrAccessDenied);

	syncChecker->ResetMethodCallCountsL();

	CContactItem* item = aDb.OpenContactLX(aId);

	CleanupStack::PushL(item);

	CContactItemFieldSet& fieldset = item->CardFields();

	const TInt pos = fieldset.Find(KUidContactFieldFamilyName);	

	CContactItemField& field = fieldset[pos];

	CContactTextField* textfield = field.TextStorage();

	textfield->SetTextL(KGivenEditName);

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

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

	test(err==KErrAccessDenied);

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

	}

/**

 * Verify that edit validation is being done for ICC entries

 * and write validation is done when Commit is called.

 * @param aDb Contact database

 */

void TestEditL(CContactDatabase& aDb)

	{

	TContactItemId id = CreateTestICCEntryL(aDb);

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

	TestSuccessfulEditL(aDb,id);

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

	FailEditValidationL(aDb,id);

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

	FailWriteValidationL(aDb,id);

	}

/** 

 * Test an unsuccessful delete

 * @param aDb Contact database

 */

void TestUnsuccessfulDeleteL(CContactDatabase& aDb)

	{

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

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

	TContactItemId id = CreateTestICCEntryL(aDb);

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

	syncChecker->SetDeleteContactResponseL(KErrCorrupt);

	syncChecker->ResetMethodCallCountsL();

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

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

	test(err==KErrCorrupt);

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

	CContactItem* item = NULL;

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

	test(err==KErrNone);

	delete item;

	}

/** 

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

 * @param aDb Contact database

 */

void TestDeleteL(CContactDatabase& aDb)

	{

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

	TContactItemId id = CreateTestICCEntryL(aDb);

	syncChecker->ResetMethodCallCountsL();

	aDb.DeleteContactL(id);

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

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

	TestUnsuccessfulDeleteL(aDb);

	}

/** 

 * Create template card for ICC contact items 

 * @param aDb Contact database

 */

TContactItemId CreateICCTemplateL(CContactDatabase& aDb)

	{

	CContactItem* temp = aDb.CreateContactCardTemplateLC(KTemplateName);

	TContactItemId templateId = temp->Id();

	CleanupStack::PopAndDestroy(temp);

	temp=NULL;

	//Remove all the unnecessary fields

	temp = aDb.OpenContactLX(templateId);

	CleanupStack::PushL(temp);	

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

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

		temp->RemoveField(i);

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

	name->SetMapping(KUidContactFieldVCardMapUnusedN);

	temp->AddFieldL(*name);

	CleanupStack::Pop(name);

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

	number->SetMapping(KUidContactFieldVCardMapTEL);

	temp->AddFieldL(*number);

	CleanupStack::Pop(number);

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

	temp->AddFieldL(*slotnum);

	CleanupStack::Pop(slotnum);

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

	temp->AddFieldL(*phonebook);

	CleanupStack::Pop(phonebook);

	aDb.CommitContactL(*temp);

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

	return templateId;

	}