/*

* 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 "t_utils.h"

#include "t_utils2.h"

RFs fs;

CCntTest* CntTest=NULL;

#define xtest(x) TestErr(x,__LINE__)

_LIT(KDataBaseName, "c:T_MultReq.cdb");

const TInt KDeleteGranularity=16;	// Must be kept in step with KDeleteTransactionGranularity in CNTDB.CPP

struct TUpdatingResults

	{

public:

	TUpdatingResults();

	void ProcessErrorL(TInt aError);

	void ProcessErrorL(TInt aError, TUpdatingResults &aMoreResults);

	void PrintResults(const TDesC &aTitle) const;

	void AppendResults(TDes &aBuf) const;

public:

	TInt iTotalCount;

	TInt iLockedCount;

	TInt iNotFoundCount;

	TInt iModifiedErr;

	};

struct SDbmsErrParams

	{

	inline SDbmsErrParams(TBool *aRemoteThreadFinished,TUpdatingResults *aResults) : iRemoteThreadFinished(aRemoteThreadFinished),iResults(aResults) {};

	TBool *iRemoteThreadFinished;

	TUpdatingResults *iResults;

	};

LOCAL_D RTest test(_L("T_MULTS"));

LOCAL_D CContactDatabase* TheDb1;

LOCAL_D CContactDatabase* TheDb2;

LOCAL_D CArrayFix<TContactItemId>* TheIds;

void DoDEF022709TestL();

const TPtrC KDatabaseFileName=_L("C:T_MULTS");

// Note long names needed to push record size of 255 bytes to trigger problems with DBMS locking

const TPtrC KTestName1=_L("Test Name No%d, plus some padding to make the data over 255 bytes, 0123456789, 0123456789, 0123456789, 0123456789");

const TPtrC KTestName2=_L("Test Name 2 No%d, plus some padding to make the data over 255 bytes, 0123456789, 0123456789, 0123456789, 0123456789");

const TPtrC KTestName3=_L("Test Name 3 No%d, plus some padding to make the data over 255 bytes, 0123456789, 0123456789, 0123456789, 0123456789");

const TInt KTotalNumRecords=20;

struct TOpenBaseParams

	{

	TFileName iDbName;

	TInt iParam1;

	TInt iParam2;

	};

enum TTestFuncs

	{

	EThreadFuncHoldOpenForAWhile,

	EThreadFuncHoldOpenForever,

	EThreadFuncHoldOpenRangeForAWhile,

	EThreadFuncHoldOpenRangeForever,

	EThreadFuncKeepUpdatingContacts,

	};

enum TThreadFuncs

	{

	EFuncOpenContact,

	EFuncDeleteContact,

	EFuncKeepReadingContacts,

	};

class CFred2 : public CBase

	{

public:

	~CFred2();

	void ConstructL(TInt aFunc, const TDesC8 &aParams);

	inline TInt Func() {return(iFunc);};

	inline const HBufC8 *Params() {return(iParams);};

	void WaitForLogon();

	void Kill();

// Other thread funcs

	void DoTestL();

protected:

	void OpenDbEtcL();

	void RunTestL();

	void CloseDbEtcL();

	void KeepUpdatingContactsL(TInt aNumTimesToLoop,SDbmsErrParams *aResults);

protected:

	CContactDatabase* iDb;

	TInt iFunc;

	HBufC8* iParams;

	RThread iThread;

	TRequestStatus iLogonStatus;

	};

class CNotificationRec : public CBase, public MContactDbObserver

	{

public:

	static CNotificationRec* NewLC();

	~CNotificationRec();

	void Wait(TContactItemId aTestId, TContactDbObserverEventType aEventType, const CContactDatabase* aDatabase);

	static TInt TimerCallBackL(TAny* aSelf);

	void Purge();

public: // from MContactDbObserver

	void HandleDatabaseEventL(TContactDbObserverEvent aEvent);

private:

	void ConstructL();

private:

	CPeriodic* iTimer;

	TBool iWaiting;

	TContactItemId iTestId;

	TUint iConnectionId;

	TContactDbObserverEventType iEventType;

	};

//

// TUpdatingResults

//

TUpdatingResults::TUpdatingResults()

	{

	iTotalCount=0;

	iLockedCount=0;

	iNotFoundCount=0;

	iModifiedErr=0;

	}

void TUpdatingResults::ProcessErrorL(TInt aError)

	{

	if (aError==KErrLocked)

		iLockedCount++;

	else if (aError==KErrNotFound)

		iNotFoundCount++;

	else if (aError==KErrCommsLineFail)

		iModifiedErr++;

	else

		User::LeaveIfError(aError);

	iTotalCount++;

	}

void TUpdatingResults::ProcessErrorL(TInt aError, TUpdatingResults &aMoreResults)

	{

	ProcessErrorL(aError);

	aMoreResults.ProcessErrorL(aError);

	}

void TUpdatingResults::PrintResults(const TDesC &aTitle) const

	{

	test.Printf(aTitle);

	test.Printf(_L("-Locked/Not Found/Debug/Total[1] %d/%d/%d/%d\n"),iLockedCount,iNotFoundCount,iModifiedErr,iTotalCount);

	}

void TUpdatingResults::AppendResults(TDes &aBuf) const

	{

	aBuf.AppendFormat(_L("%d/%d/%d/%d"),iLockedCount,iNotFoundCount,iModifiedErr,iTotalCount);

	}

//////////////////

LOCAL_C CFred2 *LaunchFred2L(TInt aFunc, const TDesC8 &aParams)

	{

	CFred2 *fred2=new(ELeave) CFred2;

	fred2->ConstructL(aFunc, aParams);

	return(fred2);

	}

CNotificationRec* CNotificationRec::NewLC()

	{ // static

	CNotificationRec* self=new(ELeave) CNotificationRec;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CNotificationRec::~CNotificationRec()

	{

	delete iTimer;

	}

void CNotificationRec::ConstructL()

	{

	iTimer=CPeriodic::NewL(0);

	}

void CNotificationRec::Wait(TContactItemId aTestId, TContactDbObserverEventType aEventType, const CContactDatabase* aDatabase)

	{

	iWaiting=ETrue;

	iTestId=aTestId;

	iEventType=aEventType;

	iConnectionId=aDatabase->ConnectionId();

	iTimer->Start(5000000,5000000,TCallBack(TimerCallBackL,NULL)); // wait for 5 seconds for notification

	CActiveScheduler::Start();

	}

void CNotificationRec::Purge()

	{

	iWaiting=EFalse;

	iTimer->Start(2000000,2000000,TCallBack(TimerCallBackL,this)); // wait for 2 seconds for notification

	CActiveScheduler::Start();

	}

TInt CNotificationRec::TimerCallBackL(TAny* aSelf)

	{ // static

	// if this gets called, notification hasn't happened

	if (((CNotificationRec*)aSelf)->iWaiting)

		User::Leave(KErrGeneral);

	else

		{

		((CNotificationRec*)aSelf)->iTimer->Cancel();

		CActiveScheduler::Stop();

		}

	return 0;

	}

void CNotificationRec::HandleDatabaseEventL(TContactDbObserverEvent aEvent)

	{

	if (!iWaiting || aEvent.iType==EContactDbObserverEventRollback)

		return;

	if (iEventType!=EContactDbObserverEventUnknownChanges)

		test(aEvent.iContactId==iTestId);

	test(iEventType==aEvent.iType);

	switch(iEventType)

		{

		case EContactDbObserverEventRecover:

		case EContactDbObserverEventTablesClosed:

		case EContactDbObserverEventTablesOpened:

			test(aEvent.iConnectionId==0);

			break;

		default:

			test(iConnectionId==aEvent.iConnectionId);

			break;

		}

	iWaiting=EFalse;

	iTimer->Cancel();

	CActiveScheduler::Stop();

	}

LOCAL_C void PopulateDatabaseL()

//

// Create and populate the database

//

	{

	TheIds=new(ELeave) CArrayFixFlat<TContactItemId>(5);

	CContactDatabase* db=CntTest->CreateDatabaseL();

	CntTest->DeleteAllTemplateFieldsL();

	TContactItemId id;

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

		{

		CContactItem* item=CContactCard::NewLC();

		TBuf<256> name;

		name.Format(KTestName1,ii);

		SetNameL(*item,KUidContactFieldCompanyName,KUidContactFieldVCardMapUnusedN,name,ETrue);

		name.Format(KTestName2,ii);

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

		name.Format(KTestName3,ii);

		SetNameL(*item,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,name,ETrue);

		id=db->AddNewContactL(*item);

		TheIds->AppendL(id);

		CleanupStack::PopAndDestroy(); // item

		}

	CntTest->CloseDatabase();

	}

LOCAL_C TPtrC Name(CContactItem& aItem,TUid aType)

	{

	CContactItemFieldSet& fieldSet=aItem.CardFields();

	const TInt pos=fieldSet.Find(aType);

	if (pos==KErrNotFound)

		return _L("");

	return fieldSet[pos].TextStorage()->Text();

	}

LOCAL_C void ReadL()

//

// Access the database with two clients running in the same thread

//

	{

	CContactItem* item1=NULL;

	CContactItem* item2=NULL;

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

		{

		TContactItemId id=(*TheIds)[ii];

		item1=TheDb1->ReadContactLC(id);

		item2=TheDb2->ReadContactLC(id);

		test(Name(*item1,KUidContactFieldCompanyName)==Name(*item2,KUidContactFieldCompanyName));

		TBuf<256> testName;

		testName.Format(KTestName1,ii);

		test(Name(*item1,KUidContactFieldCompanyName)==testName);

		CleanupStack::PopAndDestroy(2); // item2, item1

		}

	}

LOCAL_C void EditL()

	{

	CContactItem* item1=NULL;

	CContactItem* item2=NULL;

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

		{

		TContactItemId id=(*TheIds)[ii];

		// edit items in db1

		item1=TheDb1->OpenContactL(id);

		CleanupStack::PushL(item1);

		SetNameL(*item1,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("Family"),EFalse);

		TheDb1->CommitContactL(*item1);

		CleanupStack::PopAndDestroy(); // item1

		// test db2 picks up changes and re-edit items

		item2=TheDb2->OpenContactL(id);

		CleanupStack::PushL(item2);

		test(Name(*item2,KUidContactFieldFamilyName)==_L("Family"));

		SetNameL(*item2,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,_L(""),EFalse);

		TheDb2->CommitContactL(*item2);

		CleanupStack::PopAndDestroy(); // item2

		// check db1 notices changes

		item1=TheDb1->ReadContactL(id);

		test(Name(*item1,KUidContactFieldGivenName)==_L(""));

		delete item1;

		}

	// test each one can lock records

	TContactItemId id=(*TheIds)[0];

	item1=TheDb1->OpenContactL(id);

	CleanupStack::PushL(item1);

	TRAPD(err,TheDb2->OpenContactL(id));

	test(err==KErrInUse);

	TheDb1->CloseContactL(id);

	CleanupStack::PopAndDestroy(); // item1

	item2=TheDb2->OpenContactL(id);

	CleanupStack::PushL(item2);

	TRAP(err,TheDb1->OpenContactL(id));

	test(err==KErrInUse);

	TheDb2->CloseContactL(id);

	CleanupStack::PopAndDestroy(); // item2

	}

LOCAL_C void AddL()

	{

	CContactItem* item=CContactCard::NewLC();

	TContactItemId id1=TheDb1->AddNewContactL(*item);

	TContactItemId id2=TheDb2->AddNewContactL(*item);

	CleanupStack::PopAndDestroy(); // item

	delete TheDb1->ReadContactL(id2);

	delete TheDb2->ReadContactL(id1);

	TheDb1->DeleteContactL(id2);

	TheDb2->DeleteContactL(id1);

	}

LOCAL_C void TouchContactL(CContactDatabase* aDb, TContactItemId aId)

	{

	CContactItem* item=aDb->OpenContactL(aId);

	SetNameL(*item,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,_L(""),EFalse);

	aDb->CommitContactL(*item);

	delete item;

	}

LOCAL_C void AdjustContactAccessCountL(CContactDatabase* aDb, TContactItemId aItemId, TInt aCount)

	{

	CContactItem *incItem=aDb->OpenContactLX(aItemId);

	CleanupStack::PushL(incItem);

	while(aCount>0)

		{

		incItem->IncAccessCount();

		aCount--;

		}

	while(aCount<0)

		{

		incItem->DecAccessCount();

		aCount++;

		}

	aDb->CommitContactL(*incItem);

	CleanupStack::PopAndDestroy(2);	// incItem, Close(incItem)

	}

LOCAL_C void WaitAndCheckEvent(CNotificationRec* aRec1,CNotificationRec* aRec2,TContactItemId aTestId, TContactDbObserverEventType aEventType, const CContactDatabase* aDatabase)

	{

	aRec1->Wait(aTestId,aEventType,aDatabase);

	if (aRec2)

		aRec2->Wait(aTestId,aEventType,aDatabase);

	}

LOCAL_C void SetSortOrderL(CContactDatabase* aDb, TFieldType aFieldType)

	{

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

	CleanupStack::PushL(sortOrder);

	sortOrder->AppendL(CContactDatabase::TSortPref(aFieldType,CContactDatabase::TSortPref::EAsc));

	aDb->SortL(sortOrder);

	CleanupStack::Pop();	// sortOrder

	}

LOCAL_C void TestDeleteContactsErrorL(CContactDatabase* aDb, CContactDatabase* aDb2, CNotificationRec* aRec, CNotificationRec* aRec2, TInt aErrorPos, TBool aChangedMessage)

	{

	aRec2->Purge();

	SetSortOrderL(aDb,KUidContactFieldGivenName);

	CContactIdArray *deleteIds=CContactIdArray::NewLC();

	CContactItem *openItem=NULL;

	TInt startCount=aDb->SortedItemsL()->Count();

	TInt startCount2=aDb2->SortedItemsL()->Count();

	for(TInt loop=0;loop<(aErrorPos+10);loop++)

		{

		TContactItemId add=AddContactL(aDb,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("Add1"));

		deleteIds->AddL(add);

		aRec->Wait(add,EContactDbObserverEventContactAdded,aDb);

		aRec2->Wait(add,EContactDbObserverEventContactAdded,aDb);

		if (loop==aErrorPos)

			{

			openItem=aDb2->OpenContactLX(add);

			CleanupStack::PushL(openItem);

			}

		TInt db2Count=aDb2->SortedItemsL()->Count();

		test(db2Count==(startCount2+loop+1));

		}

	test(openItem!=NULL);

	TRAPD(delErr,aDb->DeleteContactsL(*deleteIds));

	test(delErr==KErrInUse);

	User::After(500000);	// Let rollback event arrive

	if (aChangedMessage)

		aRec->Wait(0,EContactDbObserverEventUnknownChanges,aDb);

//

	CleanupStack::PopAndDestroy(3); // deleteIds, openItem, openItem->Close()

//

	aDb2->RecoverL();

//

	if (aChangedMessage)

		{

		aRec->Wait(0,EContactDbObserverEventTablesClosed,aDb);

//		aRec->Wait(0,EContactDbObserverEventUnknownChanges,aDb);

		}

//

	aDb->OpenTablesL();

	aRec->Purge();

	aRec2->Purge();

	SetSortOrderL(aDb,KUidContactFieldFamilyName);

	TInt db1Count=aDb->SortedItemsL()->Count();

	TInt db2Count=aDb2->SortedItemsL()->Count();

	test(db1Count==db2Count);

	if (aChangedMessage)

		test(db1Count==(startCount+10+aErrorPos-KDeleteGranularity));

	else

		test(db1Count==(startCount+10+aErrorPos));

//

	deleteIds=CContactIdArray::NewLC(aDb->SortedItemsL());

	aDb->DeleteContactsL(*deleteIds);

	aRec->Wait(0,EContactDbObserverEventUnknownChanges,aDb);

	CleanupStack::PopAndDestroy(); // deleteIds

	}

LOCAL_C void WaitForNotificationL()

	{

	CNotificationRec* rec1=CNotificationRec::NewLC();

	CNotificationRec* rec2=CNotificationRec::NewLC();

	CContactDatabase* db1=CContactDatabase::OpenL(CntTest->DatabaseName());

	CleanupStack::PushL(db1);

	CContactChangeNotifier *notify1=CContactChangeNotifier::NewL(*db1,rec1);

	CleanupStack::PushL(notify1);

	CContactDatabase* db2=CContactDatabase::OpenL(CntTest->DatabaseName());

	CleanupStack::PushL(db2);

	CContactChangeNotifier *notify2=CContactChangeNotifier::NewL(*db2,rec2);

	CleanupStack::PushL(notify2);

	TContactItemId touchId=(*TheIds)[0];

	TouchContactL(db1,touchId);

	WaitAndCheckEvent(rec1,rec2,touchId,EContactDbObserverEventContactChanged,db1); // shouldn't return until the change is notified

//

	touchId=(*TheIds)[1];

	TouchContactL(db2,touchId);

	WaitAndCheckEvent(rec1,rec2,touchId,EContactDbObserverEventContactChanged,db2);

//

	TouchContactL(db2,(*TheIds)[0]);

	TouchContactL(db2,(*TheIds)[1]);

	TouchContactL(db2,(*TheIds)[2]);

	db2->DeleteContactL((*TheIds)[1]);

	TouchContactL(db2,(*TheIds)[3]);

	TouchContactL(db2,(*TheIds)[0]);

// zzz Beef up test code to have a queue of expected events and read rec & rec2 in parallel

	WaitAndCheckEvent(rec1,NULL,(*TheIds)[0],EContactDbObserverEventContactChanged,db2);

	WaitAndCheckEvent(rec1,NULL,(*TheIds)[1],EContactDbObserverEventContactChanged,db2);

	WaitAndCheckEvent(rec1,NULL,(*TheIds)[2],EContactDbObserverEventContactChanged,db2);

	WaitAndCheckEvent(rec1,NULL,(*TheIds)[1],EContactDbObserverEventContactDeleted,db2);

	WaitAndCheckEvent(rec1,NULL,(*TheIds)[3],EContactDbObserverEventContactChanged,db2);

	WaitAndCheckEvent(rec1,NULL,(*TheIds)[0],EContactDbObserverEventContactChanged,db2);

//

	AdjustContactAccessCountL(db2,(*TheIds)[2],1);

	rec1->Wait((*TheIds)[2],EContactDbObserverEventContactChanged,db2);

	db2->DeleteContactL((*TheIds)[2]);

	rec1->Wait((*TheIds)[2],EContactDbObserverEventContactDeleted,db2);

	AdjustContactAccessCountL(db2,(*TheIds)[2],-1);

	TouchContactL(db2,(*TheIds)[0]);

	rec1->Wait((*TheIds)[0],EContactDbObserverEventContactChanged,db2);

//

	TContactItemId add1=AddContactL(db1,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("Add1"));

	TContactItemId add2=AddContactL(db2,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("Add2"));

	TContactItemId add3=AddContactL(db1,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,_L("Add3"));

	rec1->Wait(add1,EContactDbObserverEventContactAdded,db1);

	rec1->Wait(add2,EContactDbObserverEventContactAdded,db2);

	rec1->Wait(add3,EContactDbObserverEventContactAdded,db1);

//

	CContactIdArray* deleteIds=CContactIdArray::NewLC();

	deleteIds->AddL(add2);

	deleteIds->AddL(add1);

	deleteIds->AddL(add3);

	db1->DeleteContactsL(*deleteIds);

	rec1->Wait(0,EContactDbObserverEventUnknownChanges,db1);

	CleanupStack::PopAndDestroy(); // deleteIds

//