/*

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

// System includes

#include <e32std.h>

#include <e32twin.h>

#include <e32test.h>

#include <cntdbobs.h>

#include "coreappstest/testserver.h" 

// User includes

#include "t_utils.h"

// Globals

static RTest					TheTest(_L("T_CURRENTDB - Test CntModel current DB support"));

static CTrapCleanup*			TheCleanup;

// Constants (literal)

_LIT(KThreadTestFormat,			"\nThread %d running test %d\n");

_LIT(KThreadTestOkFormat,		"\nThread %d completed test %d OK\n");

// Configure database location

_LIT(KTestDatabaseFile,			"C:Contacts.cdb");

_LIT(KTestDatabaseFile2,		"C:LotsOfContacts.cdb");

// Configure .ini file location

_LIT(KContactsModelIniFile,		"c:\\private\\10003A73\\CntModel.ini");

_LIT(KTestSemaphoreOne,		"T_CURRENTDB_SEMAPHORE_ONE");

_LIT(KTestSemaphoreTwo,		"T_CURRENTDB_SEMAPHORE_TWO");

_LIT(KSpeedDialPhoneNumber, "020 11111111");

_LIT(KSpeedDialPhoneNumber2, "020 22222222");

const TInt KSpeedDialPositionOne = 1;

const TInt KSpeedDialPositionTwo = 2;

const TInt KTestSteps = 100;

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

// -------> CTestActiveScheduler (header)

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

class CTestActiveScheduler : public CActiveScheduler

	{

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

public:

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

	void Error (TInt aError) const;

	};

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

// -------> CTestActiveScheduler (source)

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

void CTestActiveScheduler::Error(TInt aError) const

	{

	User::Panic(_L("AScheduler"),aError);

	}

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

// -------> CTestBase (source)

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

CTestBase::CTestBase(CTestManager& aTester, TInt aClientNumber, TThreadPriority aThreadPriority, TInt aPriority)

:	CActive(aPriority), iTestCoordinator(aTester), iClientNumber(aClientNumber), iThreadPriority(aThreadPriority)

	{

	}

CTestBase::~CTestBase()

	{

	Cancel();

	iThread.Close();

	}

void CTestBase::ConstructL(const TDesC& aName)

	{

	User::LeaveIfError(iThread.Create(aName, ThreadFunction, KDefaultStackSize, 0x2000, 0x20000, this, EOwnerThread));

	iThread.Resume();

	iThread.SetPriority(iThreadPriority);

	}

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

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

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

void CTestBase::Complete(TInt aReason)

	{

	// Complete the request with the specified reason.

	__ASSERT_ALWAYS(IsActive() && iStatus.Int() == KRequestPending, User::Invariant());

	TRequestStatus* status = &iStatus;

	iThread.RequestComplete(status, aReason);

	}

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

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

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

void CTestBase::RunL()

	{

	_LIT(KThreadTestCompleteFormat,		"Thread %d finished tests");

	if	(iWaiting || iWaitingForAnyEvent)

		{

		CActiveScheduler::Stop(); // stop nested scheduler

		iWaiting = iWaitingForAnyEvent = EFalse;

		return;

		}

	// Increment test number

	++iCurrentTest;

	if	(iStatus.Int() < KErrNone) // Can this happen?

		{

		User::Invariant();

		}

	switch(iStatus.Int())

		{

	case EEndTests:

		{

		TBuf<50> buf;

		buf.Format(KThreadTestCompleteFormat, iClientNumber);

		iTest->Next(buf);

		CActiveScheduler::Stop();

		break;

		}

	default:

		{

		// Call the framework to handle the specific test number

		DoTestL(iStatus.Int());

		TBuf<200> buf;

		buf.Format(KThreadTestOkFormat, iClientNumber, iStatus.Int());

		iTest->Printf(buf);

		// Re issue another asynch request

		ReadyForNextTest();

		break;

		}

		}

	}

void CTestBase::DoCancel()

	{

	iWaitTimer.Cancel();

	// Cancel any outstanding request

	if	(!(iWaiting || iWaitingForAnyEvent))

		{

		Complete(KErrCancel);

		}

	}

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

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

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

TInt CTestBase::ThreadFunction(TAny* aParam)

	{

	CTestBase* self = STATIC_CAST(CTestBase*, aParam);

	// Prepare the stuff required before we start the

	// active scheduler.

    CTrapCleanup* cleanup = CTrapCleanup::New();

	if	(!cleanup)

		{

		return KErrNoMemory;

		}

	// Call virtual handler which does anything that needs doing as

	// a result of the thread function from being created.

	TRAPD(err, self->RunTestsL());

    delete cleanup;

	return err;

	}

void CTestBase::RunTestsL()

	{

	User::LeaveIfError(iWaitTimer.CreateLocal());

	OpenSemaphoreL();

	HandleThreadCreationL();

	ReadyForNextTest();

	CActiveScheduler::Start();

	HandleThreadDeletionL();

	CloseSemaphore();

	iWaitTimer.Cancel();

	iWaitTimer.Close();

	}

TInt CTestBase::HandleThreadCreationL()

	{

	// Create and name an RTest

	TBuf<100> threadName;

	threadName.Format(_L("Test thread %d"), iClientNumber);

	iTest = new(ELeave) RTest(threadName);

	iTest->Start(_L("Starting test"));

	// Position our console window

	TSize size = iTest->Console()->ScreenSize();

	size.iWidth = size.iWidth - 4;

	size.iHeight = (size.iHeight / 2) - 3;

	iConsole = Console::NewL(threadName, size);

	delete (CONST_CAST(RTest*, iTest)->Console());

	iTest->SetConsole(iConsole);

	iConsole->ClearScreen();

	// Create contacts db session

	iTest->Next(_L("Creating contacts test utility"));

	iContactsTest = new(ELeave) CCntTest();

	OpenDatabaseL();

	// Add the CTestBase object

	// to it. Has to be done in this function, otherwise the AO can

	// end up being added to the wrong active scheduler

	CActiveScheduler::Add(this);

	return KErrNone;

	}

void CTestBase::HandleThreadDeletionL()

	{

	iContactsTest->EndTestLib(KErrNone);

	}

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

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

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

void CTestBase::ReadyForNextTest()

//

//	Requests another test be executed

//

	{

	__ASSERT_ALWAYS(!iWaiting && !iWaitingForAnyEvent, User::Invariant());

	SetActive();

	iStatus = KRequestPending;

	}

void CTestBase::WaitForContactsEvent(TContactDbObserverEventType aEvent, TInt aTimeInSecondsToWaitFor)

	{

	iWaiting = ETrue;

	iEvent = aEvent;

	TTimeIntervalMicroSeconds32 time(aTimeInSecondsToWaitFor * 1000000);

	iWaitTimer.After(iStatus, time);

	SetActive();

	CActiveScheduler::Start();

	}

void CTestBase::WaitForAnyContactsEvent(TInt aTimeInSecondsToWaitFor)

	{

	iWaitingForAnyEvent = ETrue;

	TTimeIntervalMicroSeconds32 time(aTimeInSecondsToWaitFor * 1000000);

	iWaitTimer.After(iStatus, time);

	SetActive();

	CActiveScheduler::Start();

	}

void CTestBase::HandleDatabaseEventL(TContactDbObserverEvent aEvent)

	{

	__ASSERT_ALWAYS(iWaiting || iWaitingForAnyEvent, User::Invariant());

	iLastEvent=aEvent;

	switch(aEvent.iType)

		{

	case EContactDbObserverEventNull:

		iTest->Printf(_L("Event: EContactDbObserverEventNull\n"));

		break;

	case EContactDbObserverEventUnused:

		iTest->Printf(_L("Event: EContactDbObserverEventUnused\n"));

		break;

	case EContactDbObserverEventContactChanged:

		iTest->Printf(_L("Event: EContactDbObserverEventContactChanged\n"));

		break;

	case EContactDbObserverEventContactDeleted:

		iTest->Printf(_L("Event: EContactDbObserverEventContactDeleted\n"));

		break;

	case EContactDbObserverEventContactAdded:

		iTest->Printf(_L("Event: EContactDbObserverEventContactAdded\n"));

		break;

	case EContactDbObserverEventUnknownChanges:

		iTest->Printf(_L("Event: EContactDbObserverEventUnknownChanges\n"));

		break;

	case EContactDbObserverEventRecover:

		iTest->Printf(_L("Event: EContactDbObserverEventRecover\n"));

		break;

	case EContactDbObserverEventRollback:

		iTest->Printf(_L("Event: EContactDbObserverEventRollback\n"));

		break;

	case EContactDbObserverEventTablesClosed:

		iTest->Printf(_L("Event: EContactDbObserverEventTablesClosed\n"));

		break;

	case EContactDbObserverEventTablesOpened:

		iTest->Printf(_L("Event: EContactDbObserverEventTablesOpened\n"));

		break;

	case EContactDbObserverEventTemplateChanged:

		iTest->Printf(_L("Event: EContactDbObserverEventTemplateChanged\n"));

		break;

	case EContactDbObserverEventTemplateDeleted:

		iTest->Printf(_L("Event: EContactDbObserverEventTemplateDeleted\n"));

		break;

	case EContactDbObserverEventTemplateAdded:

		iTest->Printf(_L("Event: EContactDbObserverEventTemplateAdded\n"));

		break;

	case EContactDbObserverEventCurrentItemDeleted:

		iTest->Printf(_L("Event: EContactDbObserverEventCurrentItemDeleted\n"));

		break;

	case EContactDbObserverEventCurrentItemChanged:

		(*iTest)(aEvent.iContactId != KNullContactId);

		iTest->Printf(_L("Event: EContactDbObserverEventCurrentItemChanged\n"));

		break;

	case EContactDbObserverEventOwnCardChanged:

		iTest->Printf(_L("Event: EContactDbObserverEventOwnCardChanged\n"));

		break;

	case EContactDbObserverEventPreferredTemplateChanged:

		iTest->Printf(_L("Event: EContactDbObserverEventPreferredTemplateChanged\n"));

		break;

	case EContactDbObserverEventOwnCardDeleted:

		iTest->Printf(_L("Event: EContactDbObserverEventOwnCardDeleted\n"));

		break;

	case EContactDbObserverEventGroupAdded:

		iTest->Printf(_L("Event: EContactDbObserverEventGroupAdded\n"));

		break;

	case EContactDbObserverEventGroupChanged:

		iTest->Printf(_L("Event: EContactDbObserverEventGroupChanged\n"));

		break;

	case EContactDbObserverEventGroupDeleted:

		iTest->Printf(_L("Event: EContactDbObserverEventGroupDeleted\n"));

		break;

	case EContactDbObserverEventCurrentDatabaseChanged:

		iTest->Printf(_L("Event: EContactDbObserverEventCurrentDatabaseChanged\n"));

		break;

	case EContactDbObserverEventSpeedDialsChanged:

		iTest->Printf(_L("Event: EContactDbObserverEventSpeedDialsChanged\n"));

		break;

	default:

		iTest->Printf(_L("Unhandled Event\n"));

		User::Invariant();

		}

	if	((aEvent.iType == iEvent) || iWaitingForAnyEvent)

		{

		Cancel();

		iWaiting = iWaitingForAnyEvent = EFalse;

		CActiveScheduler::Stop();

		return;

		}

	else if (aEvent.iType != iEvent)

		{

			iTest->Printf(_L("Got an Unexpected Event.\n"));

		}

	}

void CTestBase::OpenSemaphoreL()

	{

	TInt error = iSemaphoreOne.CreateGlobal(KTestSemaphoreOne(), 0);

	if (error == KErrAlreadyExists || error == KErrNone)

		{

		iSemaphoreOne.OpenGlobal(KTestSemaphoreOne());

		}

	else

		{

		User::Leave(error);

		}

	error = iSemaphoreTwo.CreateGlobal(KTestSemaphoreTwo(), 0);

	if (error == KErrAlreadyExists || error == KErrNone)

		{

		iSemaphoreTwo.OpenGlobal(KTestSemaphoreTwo());

		}

	else

		{

		User::Leave(error);

		}		

	}

void CTestBase::CloseSemaphore()

	{

	iSemaphoreOne.Close();

	iSemaphoreTwo.Close();

	}

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

// -------> CTestThreadOne (source)

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

CTestThreadOne::CTestThreadOne(CTestManager& aTester, TInt aClientNumber, TThreadPriority aThreadPriority, TInt aPriority)

:	CTestBase(aTester, aClientNumber, aThreadPriority, aPriority)

	{

	}

CTestThreadOne*	CTestThreadOne::NewL(TInt aClientNumber, const TDesC& aName, CTestManager& aTester, TThreadPriority aThreadPriority, TInt aPriority)

	{

	CTestThreadOne* self = new(ELeave) CTestThreadOne(aTester, aClientNumber, aThreadPriority, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL(aName);

	CleanupStack::Pop(); // self

	return self;

	}

void CTestThreadOne::OpenDatabaseL()

	{

	TBuf<200> buf;

	buf.Format(_L("Constructing test utilities with database set as %S"), &KTestDatabaseFile);

	iTest->Next(buf);

	iContactsTest->ConstructL(*iTest, KTestDatabaseFile);

	}

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

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

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

void CTestThreadOne::DoTestL(TInt aTestNumber)

	{

	TBuf<50> buf;

	buf.Format(KThreadTestFormat, iClientNumber, aTestNumber);

	iTest->Next(buf);

	switch(aTestNumber)

		{

	case ETest1:

		DoTest1L();

		break;

	case ETest2:

		DoTest2L();

		break;

	case ETest3:

		DoTest3L();

		break;

	case ETest4:

		DoTest4L();

		break;

	case ETest5:

		DoTest5L();

		break;

	case ETest6:

		DoTest6L();

		break;

	case ETest7:

		DoTest7L();

		break;

	case ETest8:

		DoTest8L();

		break;

	case ETest9:

 		DoTest9L();

 		break; 

	default:

		User::Invariant();

		}

	}

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

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

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

void CTestThreadOne::DoTest1L()

	{

	// This thread has a higher priority than thread 2 so it should run first,

	// hence this test should work.

	iSemaphoreOne.Wait();

	iTest->Next(_L("Opening the database and check the current db is null\n"));

	iContactsTest->OpenDatabaseL();

	iTest->Printf(_L("Fetching the current database...\n"));

	TFileName currentDb;

	User::LeaveIfError(iContactsTest->Db()->GetCurrentDatabase(currentDb));

	iTest->Printf(_L("Current database reported as %S\n"), &currentDb);

	(*iTest)(currentDb.CompareF(KNullDesC) == 0);

	// Because there was no ini file found, we now set this database to be the

	// current.

	iTest->Printf(_L("\tSetting thread one's database as the current db\n"));

	User::LeaveIfError(iContactsTest->Db()->SetCurrentDatabase(KTestDatabaseFile));

	// Check that it is the current db now

	User::LeaveIfError(iContactsTest->Db()->GetCurrentDatabase(currentDb));

	iTest->Printf(_L("Current database reported as %S\n"), &currentDb);

	(*iTest)(currentDb.CompareF(KTestDatabaseFile) == 0);

	iSemaphoreTwo.Signal();

	// Pause this thread

	iSemaphoreTwo.Signal();

	iSemaphoreOne.Wait();

	}

void CTestThreadOne::DoTest2L()

	{

	iSemaphoreOne.Wait();

	iSemaphoreTwo.Signal();

	iTest->Next(_L("\tWaiting for thread 2 to change current db\n"));

	// Thread two is going to change the current database to 'it's' db.

	// Wait for notification...

	// !! Why on Earth do we need one of these? Talk about bad design.

	CContactChangeNotifier* changeNotifier = CContactChangeNotifier::NewL(*iContactsTest->Db(), this);

	CleanupStack::PushL(changeNotifier);

	WaitForContactsEvent(EContactDbObserverEventCurrentDatabaseChanged);

	CleanupStack::PopAndDestroy(); // changeNotifier