// Copyright (c) 2002-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 <e32property.h> 

#include "te_cntsyncbase.h"

#include "te_cntsyncstress.h"

#ifdef SYMBIAN_CNTMODEL_V2

_LIT(KContactsDBFile, "C:\\Private\\10003A73\\CONTACTS.CDB");

_LIT(KContactsDBFileBackup, "C:\\Private\\10003A73\\CONTACTS.BAK");

_LIT(KContactsSqliteDBFile, "C:\\Private\\10003A73\\SQLite__CONTACTS.CDB");

_LIT(KContactsSqliteDBFileBackup, "C:\\Private\\10003A73\\SQLite__CONTACTS.BAK");

#else

_LIT(KContactsDBFile, "C:\\Private\\100012A5\\DBS_100065FF_CONTACTS.CDB");

_LIT(KContactsDBFileBackup, "C:\\Private\\100012A5\\DBS_100065FF_CONTACTS.BAK");

#endif // SYMBIAN_CNTMODEL_V2

_LIT(KContactsModelIniFile, "C:\\Private\\10003A73\\CntModel.ini");

_LIT(KPhbkSyncIniFile,"C:\\Private\\102030A1\\Phbksync.ini");

_LIT(KPhbkSyncIniFileBackup, "C:\\Private\\102030A1\\Phbksync.bak");

/** 

 * Factory construction method.

 * @return Pointer to CPhbkRequestDoSyncSimultaneouslyTest object

 */

CPhbkRequestDoSyncSimultaneouslyTest* CPhbkRequestDoSyncSimultaneouslyTest::NewL()

	{

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

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkRequestDoSyncSimultaneouslyTest::CPhbkRequestDoSyncSimultaneouslyTest()

	{

	SetTestStepName(_L("RequestDoSyncSimultaneouslyTest"));

	}

/**

 * Request two simultaneous synchronisations. 

 * Two threads try to do a Synchronisation at once. 

 */

enum TVerdict CPhbkRequestDoSyncSimultaneouslyTest::doTestStepL()

	{

	const TInt KStackSize=0x8000;

	const TInt KHeapSize=0x8000;

	const TInt KMaxHeapSize=0x80000;

	_LIT(KThreadName1,"Thread1");

	_LIT(KThreadName2,"Thread2");

	RThread t1;

	RThread t2; 

	// Create the thread

	User::LeaveIfError(t1.Create(KThreadName1,DoSyncThread,KStackSize,KHeapSize,KMaxHeapSize,NULL));

	User::LeaveIfError(t2.Create(KThreadName2,DoSyncThread,KStackSize,KHeapSize,KMaxHeapSize,NULL));

	TRequestStatus reqStatus1;

	TRequestStatus reqStatus2;

	TBool req1Complete(EFalse);

	TBool req2Complete(EFalse);

	t1.Logon(reqStatus1); // Notify when the thread dies

	t2.Logon(reqStatus2);

	t1.Resume(); // Start the threads

	t2.Resume();

	User::WaitForRequest(reqStatus1); // Avoid using User::WaitForAnyRequest()

	User::WaitForRequest(reqStatus2); 

	while(req1Complete==EFalse || req2Complete==EFalse)

		{

		if (reqStatus1 != KRequestPending && req1Complete==EFalse) // Thread1 request completed

			{

			TESTCHECK(reqStatus1.Int(), KErrNone);

			req1Complete=ETrue;

			}

		if (reqStatus2 != KRequestPending && req2Complete==EFalse) // Thread2 request rejected

			{

			TESTCHECK(reqStatus2.Int(), KErrNone);

			req2Complete=ETrue;

			}

		}

	t1.Close();

	t2.Close();

	return TestStepResult();

	}

/**

 * Control passes to this function when the thread is first resumed, 

 * i.e. when the thread is initially scheduled to run.

 */

TInt CPhbkIntegrationStressTestBase::DoSyncThread(TAny* /*aPtr*/)

	{

	CActiveScheduler* scheduler = new CActiveScheduler;

	if(!scheduler)

		return KErrNoMemory;

	CActiveScheduler::Install(scheduler);

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TRAP_IGNORE(DoSyncThreadL());

	delete cleanup;	

	delete CActiveScheduler::Current();

	return KErrNone;

	}

/**

 * 

 */

void CPhbkIntegrationStressTestBase::DoSyncThreadL()

	{

	RPhoneBookSession session;

	User::LeaveIfError(session.Connect()); // Connect to the Phonebook Server

	TRequestStatus status;

	// Attempt synchronisation for each phonebook

	// Global ADN

	session.DoSynchronisation(status);

	User::WaitForRequest(status);

	__ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant());

	// Global SDN

	session.DoSynchronisation(status, KUidIccGlobalSdnPhonebook);

	User::WaitForRequest(status);

	__ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant());

	// Global LND

	session.DoSynchronisation(status, KUidIccGlobalLndPhonebook);

	User::WaitForRequest(status);

	__ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant());

	// USIM App

	session.DoSynchronisation(status, KUidUsimAppAdnPhonebook);

	User::WaitForRequest(status);

	__ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant());

	// Global FDN

	session.DoSynchronisation(status, KUidIccGlobalFdnPhonebook);

	User::WaitForRequest(status);

	__ASSERT_ALWAYS((status.Int()==KErrNone) || (status.Int()==KErrInUse), User::Invariant());	

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkLaunchServerSimultaneouslyTest object

 */

CPhbkLaunchServerSimultaneouslyTest* CPhbkLaunchServerSimultaneouslyTest::NewL()

	{

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

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkLaunchServerSimultaneouslyTest::CPhbkLaunchServerSimultaneouslyTest()

	{

	SetTestStepName(_L("LaunchServerSimultaneouslyTest"));

	}

/** 

 * Create two threads which simultaneously attempt to connect to the Phonebook Server.

 */

enum TVerdict CPhbkLaunchServerSimultaneouslyTest::doTestStepL()

	{

	SetSimTsyTestNumberL(9);

	RThread thread1;

	RThread thread2;

	// Create the threads

	User::LeaveIfError(thread1.Create(_L("Thread1"), ServerLaunchThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	User::LeaveIfError(thread2.Create(_L("Thread2"), ServerLaunchThread, KDefaultStackSize, 0x2000, 0x20000, NULL));	

	thread1.Resume(); // Start the threads

	thread2.Resume();

	User::After(5000000);

	thread1.Close();

	thread2.Close();

	return TestStepResult();

	}

/** 

 * Phonebook Server Launch thread function. 

 */

TInt CPhbkIntegrationStressTestBase::ServerLaunchThread(TAny* /*aAny*/)

	{

	CActiveScheduler* scheduler = new CActiveScheduler;

	if(!scheduler)

		return KErrNoMemory;

	CActiveScheduler::Install(scheduler);

	CTrapCleanup* cleanup=CTrapCleanup::New();

	CContactDatabase* db =NULL;

	TRAPD(err, db = CContactDatabase::OpenL());

	__ASSERT_DEBUG(err==KErrNone,User::Invariant());

	TRAP(err, CheckServerThreadCountL(1));

	__ASSERT_DEBUG(err==KErrNone,User::Invariant());

	delete db;

	delete cleanup;	

	delete CActiveScheduler::Current();

	return KErrNone;

	}

/**

 * Checks the server thread count.

 */

void CPhbkIntegrationStressTestBase::CheckServerThreadCountL(TInt aExpectedCount)

	{

	TFullName name;

	TInt count=0;

	_LIT(KThreadToFind,"*PhBkSyncServer*"); // PHBKSYNC_SVR_NAME

	TFindThread find(KThreadToFind);

	RThread candidate;

	while(find.Next(name)==KErrNone)

		{

		// If the thread still lives, increase count.

		if(candidate.Open(name)==KErrNone)

			{

			const TExitCategoryName& category = candidate.ExitCategory();

			RDebug::Print(_L("[%x] CheckServerThreadCount thread: %x -----"), (TUint)RThread().Id(), (TUint)candidate.Id());

			RDebug::Print(_L("[%x] Thread %x ExitCategory %S"), (TUint)RThread().Id(), (TUint)candidate.Id(), &category);

			RDebug::Print(_L("[%x] Thread %x ExitReason   %d"), (TUint)RThread().Id(), (TUint)candidate.Id(), candidate.ExitReason());

			RDebug::Print(_L("[%x] Thread %x ExitType     %d"), (TUint)RThread().Id(), (TUint)candidate.Id(), candidate.ExitType());

			// If the thread has an ExitCategory, it is dead and not worthy of counting

			if(category.Length()==0)

			    {

				count++;

                }

			candidate.Close();

			}

		}

	__ASSERT_ALWAYS(count==aExpectedCount, User::Invariant()); 

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkRequestReadSimultaneouslyTest object

 */

CPhbkRequestReadSimultaneouslyTest* CPhbkRequestReadSimultaneouslyTest::NewL()

	{

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

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkRequestReadSimultaneouslyTest::CPhbkRequestReadSimultaneouslyTest()

	{

	SetTestStepName(_L("RequestReadSimultaneouslyTest"));

	}

/** 

 * Create three threads which simultaneously attempt to request Read from

 * the Phonebook Server.

 */

enum TVerdict CPhbkRequestReadSimultaneouslyTest::doTestStepL()

	{

	RThread thread1;

	RThread thread2;

	RThread thread3;

	// Create the threads

	User::LeaveIfError(thread1.Create(_L("ThreadA"), MultipleReadThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	User::LeaveIfError(thread2.Create(_L("ThreadB"), MultipleReadThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	User::LeaveIfError(thread3.Create(_L("ThreadC"), MultipleReadThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	TRequestStatus reqStatus1;

	TRequestStatus reqStatus2;

	TRequestStatus reqStatus3;

	thread1.Logon(reqStatus1); // Notify when the thread dies

	thread2.Logon(reqStatus2);

	thread3.Logon(reqStatus3);

	thread1.Resume(); // Start the thread

	thread2.Resume();

	thread3.Resume();

	User::WaitForRequest(reqStatus1); // Avoid using User::WaitForAnyRequest()

	User::WaitForRequest(reqStatus2); 

	User::WaitForRequest(reqStatus3);

	TBool req1Complete(EFalse);

	TBool req2Complete(EFalse);

	TBool req3Complete(EFalse);

	while(req1Complete==EFalse || req2Complete==EFalse || req3Complete==EFalse)

		{

		if (reqStatus1 != KRequestPending && req1Complete==EFalse) // Thread1 request completed

			{

			TESTCHECK(reqStatus1.Int(), KErrNone);

			req1Complete=ETrue;

			}

		if (reqStatus2 != KRequestPending && req2Complete==EFalse) // Thread2 request rejected

			{

			TESTCHECK(reqStatus2.Int(), KErrNone);

			req2Complete=ETrue;

			}

		if (reqStatus3 != KRequestPending && req3Complete==EFalse) // Thread3 request rejected

			{

			TESTCHECK(reqStatus3.Int(), KErrNone);

			req3Complete=ETrue;

			}

		}

//	User::After(5000000);

	thread1.Close();

	thread2.Close();

	thread3.Close();

	return TestStepResult();

	}

/** 

 * Send Read request to the Phonebook server.

 */

TInt CPhbkIntegrationStressTestBase::MultipleReadThread(TAny* /*aAny*/)

	{

	CActiveScheduler* scheduler = new CActiveScheduler;

	if(!scheduler)

		return KErrNoMemory;

	CActiveScheduler::Install(scheduler);

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TRAP_IGNORE(MultipleReadThreadL()); 

	delete cleanup;	

	delete CActiveScheduler::Current();

	return KErrNone;

	}

/** 

 * 

 */

void CPhbkIntegrationStressTestBase::MultipleReadThreadL()

	{

	CPhbkIntegrationTestUtility* access = CPhbkIntegrationTestUtility::NewL();

	CleanupStack::PushL(access);

	access->ReadContactL(KUidIccGlobalAdnPhonebook, KTest9ICCSlotsADN);

	access->ReadContactL(KUidIccGlobalSdnPhonebook, KTest9ICCSlotsSDN);

	access->ReadContactL(KUidIccGlobalLndPhonebook, KTest9ICCSlotsLND);

	access->ReadContactL(KUidUsimAppAdnPhonebook, KTest9ICCSlotsUsim);

	CleanupStack::PopAndDestroy(access);

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkRequestWriteSimultaneouslyTest object

 */

CPhbkRequestWriteSimultaneouslyTest* CPhbkRequestWriteSimultaneouslyTest::NewL()

	{

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

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkRequestWriteSimultaneouslyTest::CPhbkRequestWriteSimultaneouslyTest()

	{

	SetTestStepName(_L("RequestWriteSimultaneouslyTest"));

	}

/** 

 * Create three threads which simultaneously attempt to request Write from

 * the Phonebook Server.

 */

enum TVerdict CPhbkRequestWriteSimultaneouslyTest::doTestStepL()

	{

	SetSimTsyTestNumberL(1);

	DoSyncL();

	RThread thread1;

	RThread thread2;

	RThread thread3;

	// Create the threads

	User::LeaveIfError(thread1.Create(_L("ThreadX"), MultipleWriteThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	User::LeaveIfError(thread2.Create(_L("ThreadY"), MultipleWriteThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	User::LeaveIfError(thread3.Create(_L("ThreadZ"), MultipleWriteThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	TRequestStatus reqStatus1;

	TRequestStatus reqStatus2;

	TRequestStatus reqStatus3;

	thread1.Logon(reqStatus1); // Notify when the thread dies 

	thread2.Logon(reqStatus2);

	thread3.Logon(reqStatus3);

	thread1.Resume(); // Start the threads

	thread2.Resume();

	thread3.Resume();

	User::WaitForRequest(reqStatus1); // Avoid using User::WaitForAnyRequest()

	User::WaitForRequest(reqStatus2); 

	User::WaitForRequest(reqStatus3); 

	TBool req1Complete(EFalse);

	TBool req2Complete(EFalse);

	TBool req3Complete(EFalse);

	while(req1Complete==EFalse || req2Complete==EFalse || req3Complete==EFalse)

		{

		if (reqStatus1 != KRequestPending && req1Complete==EFalse) // Thread1 request completed

			{

			TESTCHECK(reqStatus1.Int(), KErrNone);

			req1Complete=ETrue;

			}

		if (reqStatus2 != KRequestPending && req2Complete==EFalse) // Thread2 request rejected

			{

			TESTCHECK(reqStatus2.Int(), KErrNone);

			req2Complete=ETrue;

			}

		if (reqStatus3 != KRequestPending && req3Complete==EFalse) // Thread3 request rejected

			{

			TESTCHECK(reqStatus3.Int(), KErrNone);

			req3Complete=ETrue;

			}

		}

	thread1.Close();

	thread2.Close();

	thread3.Close();

	return TestStepResult();

	}

/** 

 * Send Write request to the Phonebook server.

 */

TInt CPhbkIntegrationStressTestBase::MultipleWriteThread(TAny* /*aAny*/)

	{

	CActiveScheduler* scheduler = new CActiveScheduler;

	if(!scheduler)

		return KErrNoMemory;

	CActiveScheduler::Install(scheduler);

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TRAP_IGNORE(MultipleWriteThreadL());

	delete cleanup;	

	delete CActiveScheduler::Current();

	return KErrNone;

	}

/** 

 *

 */

void CPhbkIntegrationStressTestBase::MultipleWriteThreadL()

	{

	CPhbkIntegrationTestUtility* access = CPhbkIntegrationTestUtility::NewL();

	CleanupStack::PushL(access);

	access->AddContactL(KTestName, KTestNumber, KUidIccGlobalAdnPhonebook);

	access->AddContactL(KTestName, KTestNumber, KUidIccGlobalSdnPhonebook);

	access->AddContactL(KTestName, KTestNumber, KUidIccGlobalLndPhonebook);

	access->AddContactL(KTestName, KTestNumber, KUidUsimAppAdnPhonebook, KTestEMail);

	access->AddContactL(KTestName, KTestNumber, KUidIccGlobalFdnPhonebook);

	CleanupStack::PopAndDestroy(access);

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkRequestDeleteSimultaneouslyTest object

 */

CPhbkRequestDeleteSimultaneouslyTest* CPhbkRequestDeleteSimultaneouslyTest::NewL()

	{

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

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkRequestDeleteSimultaneouslyTest::CPhbkRequestDeleteSimultaneouslyTest()

	{

	SetTestStepName(_L("RequestDeleteSimultaneouslyTest"));

	}

/** 

 * Create three threads which simultaneously attempt to request Delete from

 * the Phonebook Server.

 */

enum TVerdict CPhbkRequestDeleteSimultaneouslyTest::doTestStepL()

	{

	RThread thread1;

	RThread thread2;

	RThread thread3;

	// Create the threads

	User::LeaveIfError(thread1.Create(_L("Thread10"), MultipleDeleteThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	User::LeaveIfError(thread2.Create(_L("Thread11"), MultipleDeleteThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	User::LeaveIfError(thread3.Create(_L("Thread12"), MultipleDeleteThread, KDefaultStackSize, 0x2000, 0x20000, NULL));

	TRequestStatus reqStatus1;

	TRequestStatus reqStatus2;

	TRequestStatus reqStatus3;

	thread1.Logon(reqStatus1); // Notify when the thread dies

	thread2.Logon(reqStatus2);

	thread3.Logon(reqStatus3);

	thread1.Resume(); // Start the thread

	thread2.Resume();

	thread3.Resume();