sl@0: // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "t_sqloom.h"
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////         RSqlDatabase OOM tests         ////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1615, SYSLIB-SQL-CT-1639
sl@0: @SYMTestCaseDesc		RSqlDatabase::Create() OOM test - secure and non-secure databases.
sl@0: 						Precondition: the database does not exist.
sl@0: 						The test calls RSqlDatabase::Create() while simulating OOM failures and checks
sl@0: 						that there are no memory and resource leaks.
sl@0: 						Note: It's possible for a database to be created even after memory allocation
sl@0: 						has failed. This is because SQLITE reuses some pages of the page cache which
sl@0: 						have been allocated but are curently not in use. This means it is necessary
sl@0: 						to delete the database and continue checking for memory and resource leaks
sl@0: 						even after a database has been created successfully.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlDatabase::Create() OOM test
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0:                         REQ10271
sl@0:                         REQ10273
sl@0:                         REQ10274
sl@0: */
sl@0: void DoCreateDatabaseOomTest(const TDesC& aDbFileName, TDbType aDbType, TInt aExpectedError, const TDesC8* aConfigStr = NULL)
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1639 RSqlDatabase::Create() - OOM test"));
sl@0: 	RSqlSecurityPolicy securityPolicy;
sl@0: 	CreateTestSecurityPolicy(securityPolicy);
sl@0: 	enum TMethodType {ENonLeavingMethod, ELeavingMethod};
sl@0: 	const TMethodType KMethodType[] = {ENonLeavingMethod, ELeavingMethod};
sl@0: 	for(TInt j=0;j<sizeof(KMethodType)/sizeof(KMethodType[0]);++j)
sl@0: 		{
sl@0: 		for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 			{
sl@0: 			if(aExpectedError != KErrAlreadyExists)
sl@0: 				{
sl@0: 				(void)RSqlDatabase::Delete(aDbFileName);
sl@0: 				}
sl@0: 			TInt err = KErrNone;
sl@0: 			TInt failingAllocationNo = 0;
sl@0: 			TInt allocationNo = 0;
sl@0: 			TInt maxAllocationNo = TheOomTestType[i] == EServerSideTest ? KDoCreateDatabaseOomTestAllocLimitServer : KDoCreateDatabaseOomTestAllocLimitClient;
sl@0: 			while(allocationNo < maxAllocationNo)
sl@0: 				{
sl@0: 				MarkHandles();
sl@0: 				MarkAllocatedCells();
sl@0: 
sl@0: 				__UHEAP_MARK;
sl@0: 
sl@0: 				RSqlDatabase db;
sl@0: 
sl@0: 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo);
sl@0: 
sl@0: 				if(KMethodType[j] == ENonLeavingMethod)
sl@0: 					{
sl@0: 					err =  aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy, aConfigStr) : db.Create(aDbFileName, aConfigStr);
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					TRAP(err, aDbType == ESecureDb ? db.CreateL(aDbFileName, securityPolicy, aConfigStr) : db.CreateL(aDbFileName, aConfigStr));
sl@0: 					}
sl@0: 
sl@0: 				db.Close();
sl@0: 				if(err != KErrNoMemory)
sl@0: 					{
sl@0: 					TEST2(err, aExpectedError);
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					failingAllocationNo = allocationNo;
sl@0: 					}
sl@0: 
sl@0: 				ResetDbHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 				if(err == KErrNone && aExpectedError != KErrAlreadyExists)
sl@0: 					{
sl@0: 					err = db.Delete(aDbFileName);
sl@0: 					TEST2(err, KErrNone);
sl@0: 					}
sl@0: 
sl@0: 				__UHEAP_MARKEND;
sl@0: 
sl@0: 				CheckAllocatedCells();
sl@0: 				CheckHandles();
sl@0: 				
sl@0: 				if(err == KErrNoMemory && allocationNo == maxAllocationNo)
sl@0: 					{
sl@0: 					maxAllocationNo += 10;
sl@0: 					}
sl@0: 				}
sl@0: 			TEST2(err, aExpectedError);
sl@0: 			PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo + 1);
sl@0: 			}
sl@0: 		}
sl@0: 	RSqlDatabase::Delete(aDbFileName);
sl@0: 	securityPolicy.Close();
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Open()" OOM test
sl@0: void OpenDatabaseL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
sl@0: 	{
sl@0: 	TInt err = aDb.Open(aDbFileName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::OpenL()" OOM test
sl@0: void OpenDatabase2L(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
sl@0: 	{
sl@0: 	aDb.OpenL(aDbFileName);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Open()" + config string OOM test
sl@0: void OpenDatabase3L(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
sl@0: 	{
sl@0: 	_LIT8(KConfig, "cache_size=128;compaction=auto");
sl@0: 	TInt err = aDb.Open(aDbFileName, &KConfig);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Open() - from handle" OOM test
sl@0: void OpenDatabaseFromHandleL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
sl@0: 	{
sl@0: 	TInt err = aDb.Open(aDbFileName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Open() - from handle + config string" OOM test
sl@0: void OpenDatabaseFromHandle2L(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
sl@0: 	{
sl@0: 	_LIT8(KConfig, "cache_size=128;compaction=background");
sl@0: 	TInt err = aDb.Open(aDbFileName, &KConfig);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Exec()" OOM test (8-bit SQL statements)
sl@0: void ExecStatement8L(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	_LIT8(KSqlString, "BEGIN;\
sl@0: 					   CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT);\
sl@0: 	                   INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(4562, 123456789012345, 78612.0091, 'text data');\
sl@0: 	                   COMMIT;");
sl@0: 	TInt err = aDb.Exec(KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Exec()" OOM test (16-bit SQL statements)
sl@0: void ExecStatement16L(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	_LIT(KSqlString, "BEGIN;\
sl@0: 					  CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT);\
sl@0: 	                  INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(4562, 123456789012345, 78612.0091, 'text data');\
sl@0: 	                  COMMIT;");
sl@0: 	TInt err = aDb.Exec(KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::SetIsolationLevel()" OOM test
sl@0: void SetIsolationLevelL(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	TInt err = aDb.SetIsolationLevel(RSqlDatabase::EReadUncommitted);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Size()" OOM test
sl@0: void DbSizeL(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	TInt rc = aDb.Size();
sl@0: 	User::LeaveIfError(rc);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Size(TSize&)" OOM test
sl@0: void DbSize2L(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	RSqlDatabase::TSize size;
sl@0: 	TInt err = aDb.Size(size);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Size(TSize&)" OOM test - attached database
sl@0: void DbAttachSize2L(RSqlDatabase& aDb, const TDesC& aDbName, TDbType)
sl@0: 	{
sl@0: 	_LIT(KAttachDbName, "HHH");
sl@0: 	TInt err = aDb.Attach(aDbName, KAttachDbName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	RSqlDatabase::TSize size;
sl@0: 	err = aDb.Size(size, KAttachDbName);
sl@0: 	(void)aDb.Detach(KAttachDbName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Delete()" OOM test
sl@0: void DeleteDbL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
sl@0: 	{
sl@0: 	aDb.Close();
sl@0: 	TInt err = RSqlDatabase::Delete(aDbFileName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Attach()" OOM test
sl@0: void AttachDatabaseL(RSqlDatabase& aDb, const TDesC&, TDbType aDbType)
sl@0: 	{
sl@0: 	_LIT(KDbName, "Db2");
sl@0: 	TInt err = KErrNone;
sl@0: 	if(aDbType == ESecureDb)
sl@0: 		{
sl@0: 		err = aDb.Attach(KSecureTestDb, KDbName);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		err = aDb.Attach(KAttachDb, KDbName);
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	err = aDb.Detach(KDbName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Attach() - from handle" OOM test
sl@0: void AttachDatabase2L(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	_LIT(KDbName, "Db2");
sl@0: 	TInt err = aDb.Attach(KPrivateTestDb, KDbName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	err = aDb.Detach(KDbName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::Copy()" OOM test
sl@0: void CopyDatabaseL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)
sl@0: 	{
sl@0: 	aDb.Close();
sl@0: 	TInt err = RSqlDatabase::Copy(aDbFileName,aDbFileName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::GetSecurityPolicy()" OOM test
sl@0: void GetSecurityPolicyL(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	RSqlSecurityPolicy policy;
sl@0: 	TInt err = aDb.GetSecurityPolicy(policy);
sl@0: 	policy.Close();
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::GetSecurityPolicyL()" OOM test
sl@0: void GetSecurityPolicy2L(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	RSqlSecurityPolicy policy;
sl@0: 	CleanupClosePushL(policy);
sl@0: 	aDb.GetSecurityPolicyL(policy);
sl@0: 	CleanupStack::PopAndDestroy(&policy);
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::ReserveDriveSpace()" OOM test
sl@0: void ReserveDriveSpaceL(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	TInt err = aDb.ReserveDriveSpace(0);
sl@0: 	User::LeaveIfError(err);
sl@0: 	aDb.FreeReservedSpace();
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::GetReserveAccess()" OOM test
sl@0: void GetReserveAccessL(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	TInt err = aDb.ReserveDriveSpace(0);
sl@0: 	User::LeaveIfError(err);
sl@0: 	err = aDb.GetReserveAccess();
sl@0: 	User::LeaveIfError(err);
sl@0: 	aDb.ReleaseReserveAccess();
sl@0: 	aDb.FreeReservedSpace();
sl@0: 	}
sl@0: 
sl@0: //"RSqlDatabase::LastInsertedRowId()" OOM test
sl@0: void DbLastInsertedRowIdL(RSqlDatabase& aDb, const TDesC&, TDbType)
sl@0: 	{
sl@0: 	TInt64 rowid = aDb.LastInsertedRowId();
sl@0: 	User::LeaveIfError(rowid);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1616
sl@0: @SYMTestCaseDesc		RSqlDatabase methods OOM test
sl@0: 						Precondition: the database exists.
sl@0: 						The test calls the given as an argument function while simulating OOM failures
sl@0: 						and checks that there are no memory and resource leaks.
sl@0: 						Note: It's possible for database operations to be performed even after memory
sl@0: 						allocation has failed. This is because SQLITE reuses some pages of the page
sl@0: 						cache which have been allocated but are curently not in use. This means it is
sl@0: 						necessary to undo any operations on the database and continue checking for
sl@0: 						memory and resource leaks even after an operation has been completed successfully.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlDatabase methods OOM tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF105444
sl@0: */
sl@0: void DoDbOomTest(TDbFuncPtrL aTestFunctionPtrL, const TDesC& aDbFileName, TDbAction aDbAction, TDbType aDbType)
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1616 RSqlDatabase - OOM test"));
sl@0: 	RSqlSecurityPolicy securityPolicy;
sl@0: 	CreateTestSecurityPolicy(securityPolicy);
sl@0: 	for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 		{
sl@0: 		//Recreate the database file
sl@0: 		RSqlDatabase::Delete(aDbFileName);
sl@0: 		RSqlDatabase db;
sl@0: 		TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
sl@0: 		db.Close();
sl@0: 		TEST2(err, KErrNone);
sl@0: 
sl@0: 		TInt failingAllocationNo = 0;
sl@0: 		TInt allocationNo = 0;
sl@0: 		TInt maxAllocationNo = TheOomTestType[i] == EServerSideTest ? KDoDbOomTestAllocLimitServer : KDoDbOomTestAllocLimitClient;
sl@0: 		while(allocationNo < maxAllocationNo)
sl@0: 			{
sl@0: 			MarkHandles();
sl@0: 			MarkAllocatedCells();
sl@0: 
sl@0: 			__UHEAP_MARK;
sl@0: 
sl@0: 			if(TheOomTestType[i] == EServerSideTest)
sl@0: 				{//If aDbAction is EOpenDb, then we will delay the heap failure simulation, until the database is opened
sl@0: 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo, aDbAction == EOpenDb);
sl@0: 				}
sl@0: 
sl@0: 			//if aDbAction is EOpenDb then this is a OOM test different than a test for RSqlDatabase::Open
sl@0: 			if(aDbAction == EOpenDb)
sl@0: 				{
sl@0: 				err = db.Open(aDbFileName);
sl@0: 				TEST2(err, KErrNone);
sl@0: 				}
sl@0: 
sl@0: 			if(TheOomTestType[i] == EClientSideTest)
sl@0: 				{
sl@0: 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo);
sl@0: 				}
sl@0: 
sl@0: 			TRAP(err, (*aTestFunctionPtrL)(db, aDbFileName, aDbType));
sl@0: 			if(err != KErrNoMemory)
sl@0: 				{
sl@0: 				TEST2(err, KErrNone);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				failingAllocationNo = allocationNo;
sl@0: 				}
sl@0: 
sl@0: 			ResetDbHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 			if(aTestFunctionPtrL == &ExecStatement8L || aTestFunctionPtrL == &ExecStatement16L)
sl@0: 				{
sl@0: 				_LIT(KSqlDropString, "DROP TABLE IF EXISTS BBB;");
sl@0: 				err = db.Exec(KSqlDropString);
sl@0: 				TEST(err >= 0);
sl@0: 				err = KErrNone;
sl@0: 				}
sl@0: 			else if(aTestFunctionPtrL == &DeleteDbL && err == KErrNone)
sl@0: 				{
sl@0: 				err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
sl@0: 				TEST2(err, KErrNone);
sl@0: 				}
sl@0: 			db.Close();
sl@0: 
sl@0: 			__UHEAP_MARKEND;
sl@0: 
sl@0: 			CheckAllocatedCells();
sl@0: 			CheckHandles();
sl@0: 			
sl@0: 			if(err == KErrNoMemory && allocationNo == maxAllocationNo)
sl@0: 				{
sl@0: 				maxAllocationNo += 10;
sl@0: 				}
sl@0: 			}
sl@0: 		TEST2(err, KErrNone);
sl@0: 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo + 1);
sl@0: 		}
sl@0: 	//Delete the database file
sl@0: 	RSqlDatabase::Delete(aDbFileName);
sl@0: 	securityPolicy.Close();
sl@0: 	}
sl@0: 
sl@0: //An attempt to open a non-secure database somehow happened to be in the server's private data cage.
sl@0: void DoDbOomTest2()
sl@0: 	{
sl@0: 	for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 		{
sl@0: 		TInt err = KErrNone;
sl@0: 		TInt failingAllocationNo = 0;
sl@0: 		TInt allocationNo = 0;
sl@0: 		TInt maxAllocationNo = TheOomTestType[i] == EServerSideTest ? KDoDbOomTest2AllocLimitServer : KDoDbOomTest2AllocLimitClient;
sl@0: 		while(allocationNo < maxAllocationNo)
sl@0: 			{
sl@0: 			MarkHandles();
sl@0: 			MarkAllocatedCells();
sl@0: 
sl@0: 			__UHEAP_MARK;
sl@0: 
sl@0: 			SetDbHeapFailure(TheOomTestType[i], ++allocationNo);
sl@0: 
sl@0: 			RSqlDatabase db;
sl@0: 			err = db.Open(KSecureAttachDb2);
sl@0: 			db.Close();
sl@0: 			if(err != KErrNoMemory)
sl@0: 				{
sl@0: 				TEST2(err, KSqlErrGeneral);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				failingAllocationNo = allocationNo;
sl@0: 				}
sl@0: 
sl@0: 			ResetDbHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 			__UHEAP_MARKEND;
sl@0: 
sl@0: 			CheckAllocatedCells();
sl@0: 			CheckHandles();
sl@0: 			
sl@0: 			if(err == KErrNoMemory && allocationNo == maxAllocationNo)
sl@0: 				{
sl@0: 				maxAllocationNo += 10;
sl@0: 				}
sl@0: 			}
sl@0: 		TEST2(err, KSqlErrGeneral);
sl@0: 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo + 1);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //RSqlDatabase OOM tests
sl@0: void DbOomTestsL(TDbType aDbType)
sl@0: 	{
sl@0: 	TPtrC dbFileName(KTestDb);
sl@0: 	if(aDbType == ESecureDb)
sl@0: 		{
sl@0: 		dbFileName.Set(KSecureTestDb());
sl@0: 		}
sl@0: 
sl@0: 	CreateAttachDb();
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Create()\r\n"));
sl@0: 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Create() + config string\r\n"));
sl@0: 	_LIT8(KConfigStr, "page_size=2048");
sl@0: 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone, &KConfigStr);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Create() + config string + manual compaction\r\n"));
sl@0: 	_LIT8(KConfigStr2, "compaction=manual");
sl@0: 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone, &KConfigStr2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Create() + config string + background compaction\r\n"));
sl@0: 	_LIT8(KConfigStr3, "compaction=background");
sl@0: 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone, &KConfigStr3);
sl@0: 	
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Create() + config string + auto compaction\r\n"));
sl@0: 	_LIT8(KConfigStr4, "compaction=auto");
sl@0: 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone, &KConfigStr4);
sl@0: 
sl@0: 	if(aDbType == ENonSecureDb)
sl@0: 		{//Private database is not a database taht will be created in the SQL server private data cage.
sl@0: 		(void)RSqlDatabase::Delete(KPrivateTestDb);
sl@0: 		TheTest.Printf(_L("===RSqlDatabase::Create() private database + config string + manual compaction\r\n"));
sl@0: 		DoCreateDatabaseOomTest(KPrivateTestDb, ENonSecureDb, KErrNone, &KConfigStr2);
sl@0: 		
sl@0: 		(void)RSqlDatabase::Delete(KPrivateTestDb);
sl@0: 		TheTest.Printf(_L("===RSqlDatabase::Create() private database + config string + background compaction\r\n"));
sl@0: 		DoCreateDatabaseOomTest(KPrivateTestDb, ENonSecureDb, KErrNone, &KConfigStr3);
sl@0: 		
sl@0: 		(void)RSqlDatabase::Delete(KPrivateTestDb);
sl@0: 		TheTest.Printf(_L("===RSqlDatabase::Create() private database + config string + auto compaction\r\n"));
sl@0: 		DoCreateDatabaseOomTest(KPrivateTestDb, ENonSecureDb, KErrNone, &KConfigStr4);
sl@0: 		}
sl@0: 	
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Open()\r\n"));
sl@0: 	DoDbOomTest(&OpenDatabaseL, dbFileName, ENotOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::OpenL()\r\n"));
sl@0: 	DoDbOomTest(&OpenDatabase2L, dbFileName, ENotOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Open() + config string\r\n"));
sl@0: 	DoDbOomTest(&OpenDatabase3L, dbFileName, ENotOpenDb, aDbType);
sl@0: 	
sl@0: 	if(aDbType == ENonSecureDb)
sl@0: 		{//Private database cannot be opened as a secure database
sl@0: 		TheTest.Printf(_L("===RSqlDatabase::Open() - from handle\r\n"));
sl@0: 		DoDbOomTest(&OpenDatabaseFromHandleL, KPrivateTestDb, ENotOpenDb, aDbType);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlDatabase::Open() - from handle + config string\r\n"));
sl@0: 		DoDbOomTest(&OpenDatabaseFromHandle2L, KPrivateTestDb, ENotOpenDb, aDbType);
sl@0: 		}
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Exec(), 8-bit SQL\r\n"));
sl@0: 	DoDbOomTest(&ExecStatement8L, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Exec(), 16-bit SQL\r\n"));
sl@0: 	DoDbOomTest(&ExecStatement16L, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::SetIsolationLevel()\r\n"));
sl@0: 	DoDbOomTest(&SetIsolationLevelL, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Size()\r\n"));
sl@0: 	DoDbOomTest(&DbSizeL, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Size(TSize&)\r\n"));
sl@0: 	DoDbOomTest(&DbSize2L, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Size(TSize&) - attached database\r\n"));
sl@0: 	DoDbOomTest(&DbAttachSize2L, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Delete()\r\n"));
sl@0: 	DoDbOomTest(&DeleteDbL, dbFileName, ENotOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Attach()\r\n"));
sl@0: 	DoDbOomTest(&AttachDatabaseL, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	//Ensure that the private database to be attached exists
sl@0: 	PrepareAttachFromHandle();
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Attach() - from handle\r\n"));
sl@0: 	DoDbOomTest(&AttachDatabase2L, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Copy()\r\n"));
sl@0: 	DoDbOomTest(&CopyDatabaseL, dbFileName, ENotOpenDb, aDbType);
sl@0: 
sl@0: 	if(aDbType == ESecureDb)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===RSqlDatabase::GetSecurityPolicy()\r\n"));
sl@0: 		DoDbOomTest(&GetSecurityPolicyL, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlDatabase::GetSecurityPolicyL()\r\n"));
sl@0: 		DoDbOomTest(&GetSecurityPolicy2L, dbFileName, EOpenDb, aDbType);
sl@0: 		}
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::ReserveDriveSpace()\r\n"));
sl@0: 	DoDbOomTest(&ReserveDriveSpaceL, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::GetReserveAccess()\r\n"));
sl@0: 	DoDbOomTest(&GetReserveAccessL, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::LastInsertedRowId()\r\n"));
sl@0: 	DoDbOomTest(&DbLastInsertedRowIdL, dbFileName, EOpenDb, aDbType);
sl@0: 
sl@0: 	TheTest.Printf(_L("===RSqlDatabase::Open(), non-secure database in server data cage\r\n"));
sl@0: 	DoDbOomTest2();
sl@0: 	}