// Copyright (c) 2000-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 <e32std.h>

#include <e32test.h>

#include <collate.h>

#include <cntdb.h>

#include <cntitem.h>

#include <cntfldst.h>

#include "t_utils2.h"

#include "T_UTILS.H"

#include "t_viewsoom.h"

#include <badesca.h>

#include "CContactDbEventQueue.h"

_LIT(KTestName,"T_ViewsOOM");

LOCAL_D RFs TheFs;

//

// Constants.

//

_LIT8(KSortPlugin, "application.vnd.symbian.com/contacts-reverse-sort"); //SimpleSortPlugin DLL Unique name

_LIT(KLogFileName,"t_viewsoom.log");

_LIT(KDbFileName,"c:t_view2.cdb");

_LIT(KTextDefSeparator,"");

_LIT8(KUnicodeLineEnd,"\x0D\x00\x0a\x00");

_LIT(KContactsFile, "z:\\t_view2\\t_view2_initial_contacts_small.txt");

const TInt KMaxNumRequests(1000);

//

// CTestConductor.

//

CTestConductor* CTestConductor::NewL()

	{

	CTestConductor* self=new(ELeave) CTestConductor();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CTestConductor::~CTestConductor()

	{

	delete iGroupOne;

	iLocalView->Close(*this);

	iRemoteView_1->Close(*this);

	iSortOrder_1.Close();

	iSortOrder_2.Close();

	delete iSortChecker;

	delete iViewCreator;

	delete iContactAdder;

	delete iContactRemover;

	delete iViewExerciser;

	delete iSortOrderChanger;

	delete iLog;

    delete iDb;

	iTest.Close();

    TRAP_IGNORE(CContactDatabase::DeleteDatabaseL(KDbFileName));

	iFs.Close();

	}

CTestConductor::CTestConductor() : CActive(EPriorityIdle),iTest(KTestName),iCurrentTestNumber(-1)

	{

	CActiveScheduler::Add(this);

	}

/**

@SYMTestCaseID     PIM-T-VIEWSOOM-0001

*/

void CTestConductor::ConstructL()

	{

	iGroupId=-1;

	iGnoreNotifications=EFalse;

	iSortOrder_1.AppendL(KUidContactFieldGivenName);

	iSortOrder_1.AppendL(KUidContactFieldFamilyName);

	iSortOrder_1.AppendL(KUidContactFieldCompanyName);

	iSortOrder_2.AppendL(KUidContactFieldFamilyName);

	iSortOrder_2.AppendL(KUidContactFieldGivenName);

	iSortOrder_2.AppendL(KUidContactFieldCompanyName);

	User::LeaveIfError(iFs.Connect());

	iLog=CLog::NewL(iTest,KLogFileName);

	iDb=CContactDatabase::ReplaceL(KDbFileName);

	iSortChecker=CSortChecker::NewL(*this);

	iViewCreator=CViewCreator::NewL(*this);

	iContactAdder=CContactAdder::NewL(*this);

	iContactRemover=CContactRemover::NewL(*this);

	iViewExerciser=CViewExerciser::NewL(*this);

	iSortOrderChanger=CSortOrderChanger::NewL(*this);

	iTestError = KErrNone;

	NextTest();

	iTest.Start(_L("@SYMTESTCaseID:PIM-T-VIEWSOOM-0001 --- Contact Views OOM tests---"));

	CActiveScheduler::Start();

	User::LeaveIfError(iTestError);

	iTest.End();

	}

void CTestConductor::NextTest()

	{

	++iCurrentTestNumber;

	TRequestStatus *pS=&iStatus;

	User::RequestComplete(pS,KErrNone);

	SetActive();

	}

void CTestConductor::RunL()

	{

	switch (iCurrentTestNumber)

		{

		case ECreateLocalView:

			iLog->LogLine(_L("=== Create local view"));

			iCurrentTestObject=iViewCreator;

			iLocalView=iViewCreator->CreateLocalViewL(iSortOrder_1);

			break;

		case EAddInitialContacts:

			{

			iLog->LogLine(_L("=== Add initial contacts"));

			iCurrentTestObject=iContactAdder;

//			iContactAdder->AddContactsL(_L("c:\\t_view2\\t_view2_initial_contacts.txt"),1);

			iContactAdder->AddContactsL(KContactsFile,1);

			}

			break;

		case EAddGroup:

			{

			//Create Test Group

			iGroupOne = STATIC_CAST(CContactGroup*,iDb->CreateContactGroupL(KGroupOneName));

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

				{

				iDb->AddContactToGroupL(ii,iGroupOne->Id());

				}

			iGroupId = iGroupOne->Id();

			NextTest();

			}

			break;

		case ECreateRemoteView:

			iLog->LogLine(_L("=== Create remote view"));

			iCurrentTestObject=iViewCreator;

			iRemoteView_1=iViewCreator->CreateRemoteViewL(iSortOrder_1);

			break;

		case EDoOOMTests:

			{

			iGnoreNotifications=ETrue;

			COomTest *oomTest=new(ELeave) COomTest(iDb,iLocalView,iRemoteView_1,iGroupOne,*this);

			CleanupStack::PushL(oomTest);

			oomTest->TestsL();

			CleanupStack::PopAndDestroy();	// oomTest

			NextTest();

			}

			break;

		case ENumTests:

			{

			RThread thread;

			iTest(thread.RequestCount()==0);

			CActiveScheduler::Stop();

			}

			break;

		default:

			ASSERT(EFalse);

			break;

		}

	}

TInt CTestConductor::RunError(TInt aError)

	{

	// quick code to report the test step and leave error

	// allows test to exit neatly with message about where the failure occurred

	iTestError = aError;

	switch (iCurrentTestNumber)

		{

		case ECreateLocalView: iTest.Printf(_L("RunL left in step CreateLocalView (%i) with error %i"), iCurrentTestNumber, aError); break;

		case EAddInitialContacts: iTest.Printf(_L("RunL left in step AddInitialContacts (%i) with error %i"), iCurrentTestNumber, aError); break;

		case EAddGroup: iTest.Printf(_L("RunL left in step AddGroup (%i) with error %i"), iCurrentTestNumber, aError); break;

		case ECreateRemoteView: iTest.Printf(_L("RunL left in step CreateRemoteView (%i) with error %i"), iCurrentTestNumber, aError); break;

		case EDoOOMTests: iTest.Printf(_L("RunL left in step DoOOMTestL (%i) with error %i"), iCurrentTestNumber, aError); break;

		case ENumTests: iTest.Printf(_L("RunL left in step NumTests (%i) with error %i"), iCurrentTestNumber, aError); break;

		default: iTest.Printf(_L("RunL left in step %i with error %i"), iCurrentTestNumber, aError); break;

		}

	// stop test

	CActiveScheduler::Stop();

	return KErrNone;

	}

void CTestConductor::HandleContactViewEvent(const CContactViewBase& aView, const TContactViewEvent& aEvent)

	{

	if(iGnoreNotifications)

		{

		return;

		}

	if(aEvent.iContactId ==  iGroupId )

		{

		return;//ignore

		}

	TRAPD(err, iCurrentTestObject->HandleNotificationL(aView, aEvent) );

	iTest(err == KErrNone);

	}

void CTestConductor::DoCancel()

	{

	}

//

// CSortChecker.

//

CSortChecker* CSortChecker::NewL(CTestConductor& aConductor)

	{

	CSortChecker* self=new(ELeave) CSortChecker(aConductor);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self.

	return self;

	}

CSortChecker::CSortChecker(CTestConductor& aConductor) : iConductor(aConductor)

	{

	}

void CSortChecker::ConstructL()

	{

	iCollateMethod=new(ELeave) TCollationMethod;

	*iCollateMethod=*Mem::CollationMethodByIndex(0);

	iCollateMethod->iFlags|=TCollationMethod::EIgnoreNone;

	}

CSortChecker::~CSortChecker()

	{

	iSortedFirstLast.ResetAndDestroy();

	iSortedLastFirst.ResetAndDestroy();

	delete iCollateMethod;

	}

void CSortChecker::AddContactL(const TDesC& aFirstName,const TDesC& aLastName)

	{

	HBufC* buf=HBufC::NewLC(aFirstName.Length()+aLastName.Length());

	TPtr bufPtr(buf->Des());

	bufPtr.Append(aFirstName);

	bufPtr.Append(aLastName);

	User::LeaveIfError(iSortedFirstLast.Append(buf));

	CleanupStack::Pop(); // buf.

	buf=HBufC::NewLC(aFirstName.Length()+aLastName.Length());

	TPtr bufPtr2(buf->Des());

	bufPtr2.Append(aLastName);

	bufPtr2.Append(aFirstName);

	User::LeaveIfError(iSortedLastFirst.Append(buf));

	CleanupStack::Pop(); // buf.

	}

void CSortChecker::RemoveContactL(const TDesC& aFirstName,const TDesC& aLastName)

	{

	HBufC* buf=HBufC::NewLC(aFirstName.Length()+aLastName.Length());

	TPtr bufPtr(buf->Des());

	bufPtr.Append(aFirstName);

	bufPtr.Append(aLastName);

	TInt index=iSortedFirstLast.Find(buf,TIdentityRelation<HBufC>(Match));

	ASSERT(index!=KErrNotFound);

	delete iSortedFirstLast[index];

	iSortedFirstLast.Remove(index);

	CleanupStack::PopAndDestroy(); // buf.

	buf=HBufC::NewLC(aFirstName.Length()+aLastName.Length());

	TPtr bufPtr2(buf->Des());

	bufPtr2.Append(aLastName);

	bufPtr2.Append(aFirstName);

	index=iSortedLastFirst.Find(buf,TIdentityRelation<HBufC>(Match));

	ASSERT(index!=KErrNotFound);

	delete iSortedLastFirst[index];

	iSortedLastFirst.Remove(index);

	CleanupStack::PopAndDestroy(); // buf.

	}

TBool CSortChecker::Match(const HBufC& aFirst,const HBufC& aSecond)

	{

	if (aFirst.Compare(aSecond)==0)

		{

		return ETrue;

		}

	return EFalse;

	}

TPtrC CSortChecker::ContactAt(TSortOrder aOrder,TInt aIndex) const

	{

	const RPointerArray<HBufC>& sortedList=(aOrder==ELastNameFirstName) ? iSortedLastFirst : iSortedFirstLast;

	return TPtrC(*sortedList[aIndex]);

	}

TInt CSortChecker::Count() const

	{

	return iSortedFirstLast.Count();

	}

TInt CSortChecker::Count(TSortOrder aOrder,const TDesC& aLowBoundary,const TDesC& aHighBoundary) const

	{

	const TInt low=FindIndex(aOrder,aLowBoundary,CSortChecker::EGreaterThanOrEqualTo);

	const TInt high=FindIndex(aOrder,aHighBoundary,CSortChecker::EGreaterThanOrEqualTo);

	if (low==KErrNotFound)

		{

		iConductor.iTest(high==KErrNotFound);

		return 0;

		}

	return high-low;

	}

TInt CSortChecker::CountLow(TSortOrder aOrder,const TDesC& aHighBoundary) const

	{

	const TInt high=FindIndex(aOrder,aHighBoundary,CSortChecker::EGreaterThanOrEqualTo);

	if (high==KErrNotFound)

		{

		return 0;

		}

	return high;

	}

TInt CSortChecker::CountHigh(TSortOrder aOrder,const TDesC& aLowBoundary) const

	{

	const TInt low=FindIndex(aOrder,aLowBoundary,CSortChecker::EGreaterThanOrEqualTo);

	if (low==KErrNotFound)

		{

		return 0;

		}

	return Count()-low;

	}

void CSortChecker::Sort()

	{

	iSortedFirstLast.Sort(TLinearOrder<HBufC>(Compare));

	iSortedLastFirst.Sort(TLinearOrder<HBufC>(Compare));

	const TInt numContacts=iSortedFirstLast.Count();

	__ASSERT_ALWAYS(numContacts==iSortedLastFirst.Count(),User::Invariant());

	}

void CSortChecker::CheckSort(TSortOrder aOrder,const TDesC& aName,TInt aIndex) const

	{

	const RPointerArray<HBufC>& sortedList=(aOrder==ELastNameFirstName) ? iSortedLastFirst : iSortedFirstLast;

	iConductor.iLog->LogLineNoEcho(_L("Checking - %S against %S"),&aName,sortedList[aIndex]);

	iConductor.iTest(sortedList[aIndex]->Compare(aName)==0);

	}

void CSortChecker::CheckSortLowSubView(TSortOrder aOrder,const TDesC& aName,TInt aIndex,const TDesC& aHighBoundary) const

	{

	const RPointerArray<HBufC>& sortedList=(aOrder==ELastNameFirstName) ? iSortedLastFirst : iSortedFirstLast;

	const HBufC* name=sortedList[aIndex];

	iConductor.iLog->LogLineNoEcho(_L("Checking - %S against %S"),&aName,name);

	iConductor.iTest(name->CompareC(aHighBoundary,3,iCollateMethod)<0);

	iConductor.iTest(name->Compare(aName)==0);

	}

void CSortChecker::CheckSortHighSubView(TSortOrder aOrder,const TDesC& aName,TInt aIndex,const TDesC& aLowBoundary) const

	{

	const RPointerArray<HBufC>& sortedList=(aOrder==ELastNameFirstName) ? iSortedLastFirst : iSortedFirstLast;

	const TInt lowIndex=FindIndex(aOrder,aLowBoundary,CSortChecker::EGreaterThanOrEqualTo);

	if (lowIndex!=KErrNotFound)

		{

		iConductor.iLog->LogLineNoEcho(_L("Checking - %S against %S"),&aName,sortedList[lowIndex+aIndex]);

		iConductor.iTest(sortedList[lowIndex+aIndex]->Compare(aName)==0);

		}

	}

void CSortChecker::CheckSortSubView(TSortOrder aOrder,const TDesC& aName,TInt aIndex,const TDesC& aLowBoundary,const TDesC& aHighBoundary) const

	{

	const RPointerArray<HBufC>& sortedList=(aOrder==ELastNameFirstName) ? iSortedLastFirst : iSortedFirstLast;

	const TInt lowIndex=FindIndex(aOrder,aLowBoundary,CSortChecker::EGreaterThanOrEqualTo);

	if (lowIndex!=KErrNotFound)

		{

		const HBufC* name=sortedList[lowIndex+aIndex];

		iConductor.iLog->LogLineNoEcho(_L("Checking - %S against %S"),&aName,name);

		iConductor.iTest(name->CompareC(aHighBoundary,3,iCollateMethod)<0);

		iConductor.iTest(name->Compare(aName)==0);

		}

	}

TInt CSortChecker::FindIndex(TSortOrder aOrder,const TDesC& aBoundary,TCriteria aCriteria) const

	{

	const RPointerArray<HBufC>& sortedList=(aOrder==ELastNameFirstName) ? iSortedLastFirst : iSortedFirstLast;

	const TInt numContacts=sortedList.Count();

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

		{

		switch (aCriteria)

			{

			case ELessThan:

				if (sortedList[ii]->CompareC(aBoundary,3,iCollateMethod)<0)

					{

					return ii;

					}

				break;

			case ELessThanOrEqualTo:

				if (sortedList[ii]->CompareC(aBoundary,3,iCollateMethod)<=0)

					{

					return ii;

					}

				break;

			case EGreaterThan:

				if (sortedList[ii]->CompareC(aBoundary,3,iCollateMethod)>0)

					{

					return ii;

					}

				break;

			case EGreaterThanOrEqualTo:

				if (sortedList[ii]->CompareC(aBoundary,3,iCollateMethod)>=0)

					{

					return ii;

					}

				break;

			default:

				ASSERT(EFalse);

			}

		}

	return KErrNotFound;

	}

TInt CSortChecker::Compare(const HBufC& aFirst, const HBufC& aSecond)

	{

	TCollationMethod collateMethod;

	collateMethod = *Mem::CollationMethodByIndex(0);

	collateMethod.iFlags|=TCollationMethod::EIgnoreNone;

	return aFirst.CompareC(aSecond,3,&collateMethod);

	}

//

// CTestBase.

//

CTestBase::CTestBase(CTestConductor& aConductor) : iConductor(aConductor)

	{

	}

//

// CViewCreator.

//

CViewCreator* CViewCreator::NewL(CTestConductor& aConductor)

	{

	CViewCreator* self=new(ELeave) CViewCreator(aConductor);

	return self;

	}

CContactLocalView* CViewCreator::CreateLocalViewL(const RContactViewSortOrder& aSortOrder)

	{

	TInt32 viewPrefs=0;

	viewPrefs|=EContactAndGroups;

	iView=CContactLocalView::NewL(iConductor,*iConductor.iDb,aSortOrder,TContactViewPreferences(viewPrefs));

	return STATIC_CAST(CContactLocalView*,iView);

	}

CContactNamedLocalView* CViewCreator::CreateNamedLocalViewL(const TDesC& aName,const RContactViewSortOrder& aSortOrder)

	{

	TInt32 viewPrefs=0;

	viewPrefs|=EContactAndGroups;

	iView=CContactNamedLocalView::NewL(iConductor,aName,*iConductor.iDb,aSortOrder,TContactViewPreferences(viewPrefs));

	return STATIC_CAST(CContactNamedLocalView*,iView);

	}

CContactRemoteView* CViewCreator::CreateRemoteViewL(const RContactViewSortOrder& aSortOrder)

	{

	TInt32 viewPrefs=0;

	viewPrefs|=EContactAndGroups;

	iView=CContactRemoteView::NewL(iConductor,*iConductor.iDb,aSortOrder,TContactViewPreferences(viewPrefs));

	return STATIC_CAST(CContactRemoteView*,iView);

	}

CContactNamedRemoteView* CViewCreator::CreateNamedRemoteViewL(const TDesC& aName,const RContactViewSortOrder& aSortOrder)

	{

	TInt32 viewPrefs=0;

	viewPrefs|=EContactAndGroups;

	iView=CContactNamedRemoteView::NewL(iConductor,aName,*iConductor.iDb,aSortOrder,TContactViewPreferences(viewPrefs));

	return STATIC_CAST(CContactNamedRemoteView*,iView);

	}

CContactSubView* CViewCreator::CreateSubViewL(CContactViewBase& aUnderlyingView,const TDesC& aBoundary)

	{

	iView=CContactSubView::NewL(iConductor,*iConductor.iDb,aUnderlyingView,aBoundary);

	return STATIC_CAST(CContactSubView*,iView);

	}

CContactSubView* CViewCreator::CreateSubViewL(CContactViewBase& aUnderlyingView,const TDesC& aLowBoundary,const TDesC& aHighBoundary)

	{

	iView=CContactSubView::NewL(iConductor,*iConductor.iDb,aUnderlyingView,aLowBoundary,aHighBoundary);

	return STATIC_CAST(CContactSubView*,iView);

	}

CContactConcatenatedView* CViewCreator::CreateConcatenatedViewL(RPointerArray<CContactViewBase>& aComponentViews)

	{

	iView=CContactConcatenatedView::NewL(iConductor,*iConductor.iDb,aComponentViews);

	return STATIC_CAST(CContactConcatenatedView*,iView);

	}

void CViewCreator::HandleNotificationL(const CContactViewBase& aView,const TContactViewEvent& aEvent)

	{