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