// Copyright (c) 2010 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 <bautils.h>

 #include <sqldb.h>

 #include <e32math.h>

 #include "SqlBur.h"

 //CSqlSrvTestBurInterface - test implementation of the MSqlSrvBurInterface, implemented in the production code by the SQL server.

 class CSqlSrvTestBurInterface : public CBase, public MSqlSrvBurInterface

 	{

 	public:

 		static CSqlSrvTestBurInterface* New();

 		virtual ~CSqlSrvTestBurInterface();

 		virtual RFs& Fs();

 		virtual void GetBackUpListL(TSecureId aUid, TDriveNumber aDrive, RArray<HBufC*>& aFileList);

 	private:

 		void Construct();

 	private:

 		RFs iFs;

 	};

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

 RTest TheTest(_L("t_sqlbur2"));

 #ifdef _DEBUG

 static const TInt KBurstRate = 100;

 #endif

 TDriveNumber KTestDrive = EDriveC;

 _LIT(KTestDir, "c:\\test\\");

 CActiveScheduler* TheScheduler = NULL;

 CSqlSrvTestBurInterface* TheSqlSrvTestBurInterface = NULL;

 TInt TestModeSqlBurError = KErrNone;//The CSqlBurEventMonitor code will set the error here

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

 void DestroyTestEnv()

 	{

 	delete TheSqlSrvTestBurInterface;

 	TheSqlSrvTestBurInterface = NULL;		

 	delete TheScheduler;

 	TheScheduler = NULL;

 	(void)RProperty::Delete(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey);  

 	}

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

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

 //Test macros and functions

 void Check(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		DestroyTestEnv();

 		RDebug::Print(_L("*** Boolean expression evaluated to false.\r\n"));

 		TheTest(EFalse, aLine);

 		}

 	}

 void Check(TInt aValue, TInt aExpected, TInt aLine)

 	{

 	if(aValue != aExpected)

 		{

 		DestroyTestEnv();

 		RDebug::Print(_L("*** Expected error: %d, got: %d.\r\n"), aExpected, aValue);

 		TheTest(EFalse, aLine);

 		}

 	}

 #define TEST(arg) ::Check((arg), __LINE__)

 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

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

 CSqlSrvTestBurInterface* CSqlSrvTestBurInterface::New()

 	{

 	CSqlSrvTestBurInterface* self = new CSqlSrvTestBurInterface;

 	TEST(self != NULL);

 	self->Construct();

 	return self;

 	}

 void CSqlSrvTestBurInterface::Construct()

 	{

 	TInt err = iFs.Connect();

 	TEST2(err, KErrNone);

 	err = iFs.MkDir(KTestDir);

 	TEST(err == KErrNone || err == KErrAlreadyExists);

 	err = iFs.CreatePrivatePath(KTestDrive);

 	TEST(err == KErrNone || err == KErrAlreadyExists);

 	}

 CSqlSrvTestBurInterface::~CSqlSrvTestBurInterface()

 	{

 	iFs.Close();

 	}

 RFs& CSqlSrvTestBurInterface::Fs()

 	{

 	return iFs;

 	}

 //No-op. Not needed in this test app.

 void CSqlSrvTestBurInterface::GetBackUpListL(TSecureId, TDriveNumber, RArray<HBufC*>&)

 	{

 	TEST(EFalse);

 	}

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

 void CreateTestEnv()

     {

 	TheScheduler = new CActiveScheduler;

 	TEST(TheScheduler != NULL);

 	CActiveScheduler::Install(TheScheduler);

 	TheSqlSrvTestBurInterface = CSqlSrvTestBurInterface::New();

 	TEST(TheSqlSrvTestBurInterface != NULL);

 	TInt err = RProperty::Define(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, 0);  

 	TEST(err == KErrNone || err == KErrAlreadyExists);

 	}

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

 /**

 @SYMTestCaseID			PDS-SQL-UT-4233

 @SYMTestCaseDesc		CSqlBurEventMonitor object creation - OOM test

 						The test runs CSqlBurEventMonitor::NewL() in an OOM loop.

 @SYMTestActions			CSqlBurEventMonitor object creation - OOM test

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 */

 void SqlBurEventMonitorOomTest()

 	{

 	TInt err = KErrNoMemory;

 	TInt failingAllocationNo = 0;

 	TheTest.Printf(_L("Iteration:\r\n"));

 	while(err == KErrNoMemory)

 		{

 		TheTest.Printf(_L(" %d"), ++failingAllocationNo);

 		TInt startProcessHandleCount;

 		TInt startThreadHandleCount;

 		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 		__UHEAP_MARK;

 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);

 		CSqlBurEventMonitor* monitor = NULL;

 		TRAP(err, monitor = CSqlBurEventMonitor::NewL(*TheSqlSrvTestBurInterface));

 		delete monitor;

 		__UHEAP_RESET;

 		__UHEAP_MARKEND;

 		TInt endProcessHandleCount;

 		TInt endThreadHandleCount;

 		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 		TEST2(startProcessHandleCount, endProcessHandleCount);

 		TEST2(startThreadHandleCount, endThreadHandleCount);

 		}

 	TEST2(err, KErrNone);

 	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

 	}

 /**

 @SYMTestCaseID			PDS-SQL-UT-4234

 @SYMTestCaseDesc		CSqlBurEventMonitor functional test

 						The test sets the backup & restore property status and then checks

 						how the backup & restore property monitor (CSqlBurEventMonitor) reacts to the event.

 @SYMTestActions			CSqlBurEventMonitor functional test

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 */

 void SqlBurEventMonitorFunctionalTest()

 	{

 	CSqlBurEventMonitor* monitor = NULL;

 	TRAPD(err, monitor = CSqlBurEventMonitor::NewL(*TheSqlSrvTestBurInterface));

 	TEST2(err, KErrNone);

 	TEST(!monitor->ActiveBackupClient());

 	TEST(!monitor->SqlBurCallback());

 	//Set the property to conn::EBURBackupFull, conn::EBURBackupPartial, conn::EBURRestoreFull, conn::EBURRestorePartial, 

 	//then start the scheduler. CSqlBurEventMonitor::RunL() gets called and 

 	//CSqlBurCallback and CActiveBackupClient interfaces get created (if the interfaces do exist, they are destroyed first).

 	TInt burPropertyStatus[] = {conn::EBURBackupFull, conn::EBURBackupPartial, conn::EBURRestoreFull, conn::EBURRestorePartial};

 	for(TInt i=0;i<(sizeof(burPropertyStatus)/sizeof(burPropertyStatus[0]));++i)

 		{

 		err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, burPropertyStatus[i]);

 		TEST2(err, KErrNone);

 		TestModeSqlBurError = KErrNone;

 		if(i > 0)

 			{

 			__UHEAP_MARK;

 			}

 		CActiveScheduler::Start();

 		if(i > 0)

 			{

 			__UHEAP_MARKEND;

 			}

 		TEST2(TestModeSqlBurError, KErrNone);

 		TEST(monitor->ActiveBackupClient() != NULL);

 		TEST(monitor->SqlBurCallback() != NULL);

 		}

 	//Set the property to conn::EBURUnset, start the scheduler. CSqlBurEventMonitor::RunL() gets called 

 	//and CSqlBurCallback interface gets destroyed.

 	err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, conn::EBURUnset);

 	TEST2(err, KErrNone);

 	TestModeSqlBurError = KErrNone;

 	CActiveScheduler::Start();

 	TEST2(TestModeSqlBurError, KErrNone);

 	TEST(!monitor->ActiveBackupClient());

 	TEST(!monitor->SqlBurCallback());

 	//Set the property to conn::EBURNormal, start the scheduler. CSqlBurEventMonitor::RunL() gets called. 

 	//CSqlBurCallback interface has been destroyed alread. No memory deallocations should be made during this call.

 	err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, conn::EBURNormal);

 	TEST2(err, KErrNone);

 	__UHEAP_MARK;

 	TestModeSqlBurError = KErrNone;

 	CActiveScheduler::Start();

 	TEST2(TestModeSqlBurError, KErrNone);

 	TEST(!monitor->ActiveBackupClient());

 	TEST(!monitor->SqlBurCallback());

 	__UHEAP_MARKEND;

 	//Set the property, then delete it. CSqlBurEventMonitor::RunL() should get called, but the call should

 	//fail because the property does not exist.

 	err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, conn::EBURBackupFull);

 	TEST2(err, KErrNone);

 	err = RProperty::Delete(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey);  

 	TEST2(err, KErrNone);

 	__UHEAP_MARK;

 	TestModeSqlBurError = KErrNone;

 	CActiveScheduler::Start();

 	TEST2(TestModeSqlBurError, KErrNotFound);

 	TEST(!monitor->ActiveBackupClient());

 	TEST(!monitor->SqlBurCallback());

 	__UHEAP_MARKEND;

 	//Restore the property

 	err = RProperty::Define(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, 0);  

 	TEST2(err, KErrNone);

 	//

 	delete monitor;

 	}

 /**

 @SYMTestCaseID			PDS-SQL-UT-4235

 @SYMTestCaseDesc		CSqlBurEventMonitor::RunL() - OOM test

 						The test sets the backup & restore property status and then checks

 						how the backup & restore property monitor (CSqlBurEventMonitor) reacts to the event.

 						The test is performed in an OOM loop.

 @SYMTestActions			CSqlBurEventMonitor::RunL() - OOM test

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 */

 void SqlBurEventMonitorRunOomTest()

 	{

 	CSqlBurEventMonitor* monitor = NULL;

 	TRAPD(err, monitor = CSqlBurEventMonitor::NewL(*TheSqlSrvTestBurInterface));

 	err = KErrNoMemory;

 	TInt failingAllocationNo = 0;

 	TheTest.Printf(_L("Iteration:\r\n"));

 	while(err == KErrNoMemory)

 		{

 		TheTest.Printf(_L(" %d"), ++failingAllocationNo);

 		TInt startProcessHandleCount;

 		TInt startThreadHandleCount;

 		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 		__UHEAP_MARK;

 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);

 		TEST(!monitor->ActiveBackupClient());

 		TEST(!monitor->SqlBurCallback());

 		//Set the property, start the scheduler. CSqlBurEventMonitor::RunL() gets called and CSqlBurCallback

 		//interface gets created.

 		err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, conn::EBURBackupFull);

 		if(err == KErrNone)

 			{

 			TestModeSqlBurError = KErrNone;

 			CActiveScheduler::Start();

 			err = TestModeSqlBurError;

 			if(err == KErrNone)

 				{

 				TEST(monitor->ActiveBackupClient() != NULL);

 				TEST(monitor->SqlBurCallback() != NULL);

 				//Destroy the SQL backup & restore callback

 				err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, conn::EBURNormal);

 				TestModeSqlBurError = KErrNone;

 				CActiveScheduler::Start();

 				err = TestModeSqlBurError;

 				if(err == KErrNone)

 					{

 					TEST(!monitor->ActiveBackupClient());

 					TEST(!monitor->SqlBurCallback());

 					}

 				}

 			}

 		__UHEAP_RESET;

 		__UHEAP_MARKEND;

 		TInt endProcessHandleCount;

 		TInt endThreadHandleCount;

 		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 		TEST2(startProcessHandleCount, endProcessHandleCount);

 		TEST2(startThreadHandleCount, endThreadHandleCount);

 		}

 	TEST2(err, KErrNone);

 	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

 	delete monitor;

 	}

 void DoTestsL()

 	{

 	TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-UT-4233 CSqlBurEventMonitor object creation - OOM test"));

 	SqlBurEventMonitorOomTest();

 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4234 CSqlBurEventMonitor functional test"));

 	SqlBurEventMonitorFunctionalTest();

 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4235 CSqlBurEventMonitor::RunL() - OOM test"));

 	SqlBurEventMonitorRunOomTest();

 	}

 TInt E32Main()

 	{

 	TheTest.Title();

 	CTrapCleanup* tc = CTrapCleanup::New();

 	TheTest(tc != NULL);

 	__UHEAP_MARK;

 	CreateTestEnv();

 	TRAPD(err, DoTestsL());

 	DestroyTestEnv();

 	TEST2(err, KErrNone);

 	__UHEAP_MARKEND;

 	TheTest.End();

 	TheTest.Close();

 	delete tc;

 	User::Heap().Check();

 	return KErrNone;

 	}