MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/persistentdata/persistentstorage/sql/TEST/t_sqloom.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "t_sqloom.h"

    17 

    18 ///////////////////////////////////////////////////////////////////////////////////////

    19 ///////////////         RSqlDatabase OOM tests         ////////////////////////////////

    20 ///////////////////////////////////////////////////////////////////////////////////////

    21 

    22 /**

    23 @SYMTestCaseID			SYSLIB-SQL-CT-1615, SYSLIB-SQL-CT-1639

    24 @SYMTestCaseDesc		RSqlDatabase::Create() OOM test - secure and non-secure databases.

    25 						Precondition: the database does not exist.

    26 						The test calls RSqlDatabase::Create() while simulating OOM failures and checks

    27 						that there are no memory and resource leaks.

    28 						Note: It's possible for a database to be created even after memory allocation

    29 						has failed. This is because SQLITE reuses some pages of the page cache which

    30 						have been allocated but are curently not in use. This means it is necessary

    31 						to delete the database and continue checking for memory and resource leaks

    32 						even after a database has been created successfully.

    33 @SYMTestPriority		High

    34 @SYMTestActions			RSqlDatabase::Create() OOM test

    35 @SYMTestExpectedResults Test must not fail

    36 @SYMREQ					REQ5792

    37                         REQ5793

    38                         REQ10271

    39                         REQ10273

    40                         REQ10274

    41 */

    42 void DoCreateDatabaseOomTest(const TDesC& aDbFileName, TDbType aDbType, TInt aExpectedError, const TDesC8* aConfigStr = NULL)

    43 	{

    44 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1639 RSqlDatabase::Create() - OOM test"));

    45 	RSqlSecurityPolicy securityPolicy;

    46 	CreateTestSecurityPolicy(securityPolicy);

    47 	enum TMethodType {ENonLeavingMethod, ELeavingMethod};

    48 	const TMethodType KMethodType[] = {ENonLeavingMethod, ELeavingMethod};

    49 	for(TInt j=0;j<sizeof(KMethodType)/sizeof(KMethodType[0]);++j)

    50 		{

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

    52 			{

    53 			if(aExpectedError != KErrAlreadyExists)

    54 				{

    55 				(void)RSqlDatabase::Delete(aDbFileName);

    56 				}

    57 			TInt err = KErrNone;

    58 			TInt failingAllocationNo = 0;

    59 			TInt allocationNo = 0;

    60 			TInt maxAllocationNo = TheOomTestType[i] == EServerSideTest ? KDoCreateDatabaseOomTestAllocLimitServer : KDoCreateDatabaseOomTestAllocLimitClient;

    61 			while(allocationNo < maxAllocationNo)

    62 				{

    63 				MarkHandles();

    64 				MarkAllocatedCells();

    65 

    66 				__UHEAP_MARK;

    67 

    68 				RSqlDatabase db;

    69 

    70 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo);

    71 

    72 				if(KMethodType[j] == ENonLeavingMethod)

    73 					{

    74 					err =  aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy, aConfigStr) : db.Create(aDbFileName, aConfigStr);

    75 					}

    76 				else

    77 					{

    78 					TRAP(err, aDbType == ESecureDb ? db.CreateL(aDbFileName, securityPolicy, aConfigStr) : db.CreateL(aDbFileName, aConfigStr));

    79 					}

    80 

    81 				db.Close();

    82 				if(err != KErrNoMemory)

    83 					{

    84 					TEST2(err, aExpectedError);

    85 					}

    86 				else

    87 					{

    88 					failingAllocationNo = allocationNo;

    89 					}

    90 

    91 				ResetDbHeapFailure(TheOomTestType[i]);

    92 

    93 				if(err == KErrNone && aExpectedError != KErrAlreadyExists)

    94 					{

    95 					err = db.Delete(aDbFileName);

    96 					TEST2(err, KErrNone);

    97 					}

    98 

    99 				__UHEAP_MARKEND;

   100 

   101 				CheckAllocatedCells();

   102 				CheckHandles();

   103 				

   104 				if(err == KErrNoMemory && allocationNo == maxAllocationNo)

   105 					{

   106 					maxAllocationNo += 10;

   107 					}

   108 				}

   109 			TEST2(err, aExpectedError);

   110 			PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo + 1);

   111 			}

   112 		}

   113 	RSqlDatabase::Delete(aDbFileName);

   114 	securityPolicy.Close();

   115 	}

   116 

   117 //"RSqlDatabase::Open()" OOM test

   118 void OpenDatabaseL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)

   119 	{

   120 	TInt err = aDb.Open(aDbFileName);

   121 	User::LeaveIfError(err);

   122 	}

   123 

   124 //"RSqlDatabase::OpenL()" OOM test

   125 void OpenDatabase2L(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)

   126 	{

   127 	aDb.OpenL(aDbFileName);

   128 	}

   129 

   130 //"RSqlDatabase::Open()" + config string OOM test

   131 void OpenDatabase3L(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)

   132 	{

   133 	_LIT8(KConfig, "cache_size=128;compaction=auto");

   134 	TInt err = aDb.Open(aDbFileName, &KConfig);

   135 	User::LeaveIfError(err);

   136 	}

   137 

   138 //"RSqlDatabase::Open() - from handle" OOM test

   139 void OpenDatabaseFromHandleL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)

   140 	{

   141 	TInt err = aDb.Open(aDbFileName);

   142 	User::LeaveIfError(err);

   143 	}

   144 

   145 //"RSqlDatabase::Open() - from handle + config string" OOM test

   146 void OpenDatabaseFromHandle2L(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)

   147 	{

   148 	_LIT8(KConfig, "cache_size=128;compaction=background");

   149 	TInt err = aDb.Open(aDbFileName, &KConfig);

   150 	User::LeaveIfError(err);

   151 	}

   152 

   153 //"RSqlDatabase::Exec()" OOM test (8-bit SQL statements)

   154 void ExecStatement8L(RSqlDatabase& aDb, const TDesC&, TDbType)

   155 	{

   156 	_LIT8(KSqlString, "BEGIN;\

   157 					   CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT);\

   158 	                   INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(4562, 123456789012345, 78612.0091, 'text data');\

   159 	                   COMMIT;");

   160 	TInt err = aDb.Exec(KSqlString);

   161 	User::LeaveIfError(err);

   162 	}

   163 

   164 //"RSqlDatabase::Exec()" OOM test (16-bit SQL statements)

   165 void ExecStatement16L(RSqlDatabase& aDb, const TDesC&, TDbType)

   166 	{

   167 	_LIT(KSqlString, "BEGIN;\

   168 					  CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT);\

   169 	                  INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(4562, 123456789012345, 78612.0091, 'text data');\

   170 	                  COMMIT;");

   171 	TInt err = aDb.Exec(KSqlString);

   172 	User::LeaveIfError(err);

   173 	}

   174 

   175 //"RSqlDatabase::SetIsolationLevel()" OOM test

   176 void SetIsolationLevelL(RSqlDatabase& aDb, const TDesC&, TDbType)

   177 	{

   178 	TInt err = aDb.SetIsolationLevel(RSqlDatabase::EReadUncommitted);

   179 	User::LeaveIfError(err);

   180 	}

   181 

   182 //"RSqlDatabase::Size()" OOM test

   183 void DbSizeL(RSqlDatabase& aDb, const TDesC&, TDbType)

   184 	{

   185 	TInt rc = aDb.Size();

   186 	User::LeaveIfError(rc);

   187 	}

   188 

   189 //"RSqlDatabase::Size(TSize&)" OOM test

   190 void DbSize2L(RSqlDatabase& aDb, const TDesC&, TDbType)

   191 	{

   192 	RSqlDatabase::TSize size;

   193 	TInt err = aDb.Size(size);

   194 	User::LeaveIfError(err);

   195 	}

   196 

   197 //"RSqlDatabase::Size(TSize&)" OOM test - attached database

   198 void DbAttachSize2L(RSqlDatabase& aDb, const TDesC& aDbName, TDbType)

   199 	{

   200 	_LIT(KAttachDbName, "HHH");

   201 	TInt err = aDb.Attach(aDbName, KAttachDbName);

   202 	User::LeaveIfError(err);

   203 	RSqlDatabase::TSize size;

   204 	err = aDb.Size(size, KAttachDbName);

   205 	(void)aDb.Detach(KAttachDbName);

   206 	User::LeaveIfError(err);

   207 	}

   208 

   209 //"RSqlDatabase::Delete()" OOM test

   210 void DeleteDbL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)

   211 	{

   212 	aDb.Close();

   213 	TInt err = RSqlDatabase::Delete(aDbFileName);

   214 	User::LeaveIfError(err);

   215 	}

   216 

   217 //"RSqlDatabase::Attach()" OOM test

   218 void AttachDatabaseL(RSqlDatabase& aDb, const TDesC&, TDbType aDbType)

   219 	{

   220 	_LIT(KDbName, "Db2");

   221 	TInt err = KErrNone;

   222 	if(aDbType == ESecureDb)

   223 		{

   224 		err = aDb.Attach(KSecureTestDb, KDbName);

   225 		}

   226 	else

   227 		{

   228 		err = aDb.Attach(KAttachDb, KDbName);

   229 		}

   230 	User::LeaveIfError(err);

   231 	err = aDb.Detach(KDbName);

   232 	User::LeaveIfError(err);

   233 	}

   234 

   235 //"RSqlDatabase::Attach() - from handle" OOM test

   236 void AttachDatabase2L(RSqlDatabase& aDb, const TDesC&, TDbType)

   237 	{

   238 	_LIT(KDbName, "Db2");

   239 	TInt err = aDb.Attach(KPrivateTestDb, KDbName);

   240 	User::LeaveIfError(err);

   241 	err = aDb.Detach(KDbName);

   242 	User::LeaveIfError(err);

   243 	}

   244 

   245 //"RSqlDatabase::Copy()" OOM test

   246 void CopyDatabaseL(RSqlDatabase& aDb, const TDesC& aDbFileName, TDbType)

   247 	{

   248 	aDb.Close();

   249 	TInt err = RSqlDatabase::Copy(aDbFileName,aDbFileName);

   250 	User::LeaveIfError(err);

   251 	}

   252 

   253 //"RSqlDatabase::GetSecurityPolicy()" OOM test

   254 void GetSecurityPolicyL(RSqlDatabase& aDb, const TDesC&, TDbType)

   255 	{

   256 	RSqlSecurityPolicy policy;

   257 	TInt err = aDb.GetSecurityPolicy(policy);

   258 	policy.Close();

   259 	User::LeaveIfError(err);

   260 	}

   261 

   262 //"RSqlDatabase::GetSecurityPolicyL()" OOM test

   263 void GetSecurityPolicy2L(RSqlDatabase& aDb, const TDesC&, TDbType)

   264 	{

   265 	RSqlSecurityPolicy policy;

   266 	CleanupClosePushL(policy);

   267 	aDb.GetSecurityPolicyL(policy);

   268 	CleanupStack::PopAndDestroy(&policy);

   269 	}

   270 

   271 //"RSqlDatabase::ReserveDriveSpace()" OOM test

   272 void ReserveDriveSpaceL(RSqlDatabase& aDb, const TDesC&, TDbType)

   273 	{

   274 	TInt err = aDb.ReserveDriveSpace(0);

   275 	User::LeaveIfError(err);

   276 	aDb.FreeReservedSpace();

   277 	}

   278 

   279 //"RSqlDatabase::GetReserveAccess()" OOM test

   280 void GetReserveAccessL(RSqlDatabase& aDb, const TDesC&, TDbType)

   281 	{

   282 	TInt err = aDb.ReserveDriveSpace(0);

   283 	User::LeaveIfError(err);

   284 	err = aDb.GetReserveAccess();

   285 	User::LeaveIfError(err);

   286 	aDb.ReleaseReserveAccess();

   287 	aDb.FreeReservedSpace();

   288 	}

   289 

   290 //"RSqlDatabase::LastInsertedRowId()" OOM test

   291 void DbLastInsertedRowIdL(RSqlDatabase& aDb, const TDesC&, TDbType)

   292 	{

   293 	TInt64 rowid = aDb.LastInsertedRowId();

   294 	User::LeaveIfError(rowid);

   295 	}

   296 

   297 

   298 

   299 /**

   300 @SYMTestCaseID			SYSLIB-SQL-CT-1616

   301 @SYMTestCaseDesc		RSqlDatabase methods OOM test

   302 						Precondition: the database exists.

   303 						The test calls the given as an argument function while simulating OOM failures

   304 						and checks that there are no memory and resource leaks.

   305 						Note: It's possible for database operations to be performed even after memory

   306 						allocation has failed. This is because SQLITE reuses some pages of the page

   307 						cache which have been allocated but are curently not in use. This means it is

   308 						necessary to undo any operations on the database and continue checking for

   309 						memory and resource leaks even after an operation has been completed successfully.

   310 @SYMTestPriority		High

   311 @SYMTestActions			RSqlDatabase methods OOM tests

   312 @SYMTestExpectedResults Test must not fail

   313 @SYMDEF                 DEF105444

   314 */

   315 void DoDbOomTest(TDbFuncPtrL aTestFunctionPtrL, const TDesC& aDbFileName, TDbAction aDbAction, TDbType aDbType)

   316 	{

   317 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1616 RSqlDatabase - OOM test"));

   318 	RSqlSecurityPolicy securityPolicy;

   319 	CreateTestSecurityPolicy(securityPolicy);

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

   321 		{

   322 		//Recreate the database file

   323 		RSqlDatabase::Delete(aDbFileName);

   324 		RSqlDatabase db;

   325 		TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);

   326 		db.Close();

   327 		TEST2(err, KErrNone);

   328 

   329 		TInt failingAllocationNo = 0;

   330 		TInt allocationNo = 0;

   331 		TInt maxAllocationNo = TheOomTestType[i] == EServerSideTest ? KDoDbOomTestAllocLimitServer : KDoDbOomTestAllocLimitClient;

   332 		while(allocationNo < maxAllocationNo)

   333 			{

   334 			MarkHandles();

   335 			MarkAllocatedCells();

   336 

   337 			__UHEAP_MARK;

   338 

   339 			if(TheOomTestType[i] == EServerSideTest)

   340 				{//If aDbAction is EOpenDb, then we will delay the heap failure simulation, until the database is opened

   341 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo, aDbAction == EOpenDb);

   342 				}

   343 

   344 			//if aDbAction is EOpenDb then this is a OOM test different than a test for RSqlDatabase::Open

   345 			if(aDbAction == EOpenDb)

   346 				{

   347 				err = db.Open(aDbFileName);

   348 				TEST2(err, KErrNone);

   349 				}

   350 

   351 			if(TheOomTestType[i] == EClientSideTest)

   352 				{

   353 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo);

   354 				}

   355 

   356 			TRAP(err, (*aTestFunctionPtrL)(db, aDbFileName, aDbType));

   357 			if(err != KErrNoMemory)

   358 				{

   359 				TEST2(err, KErrNone);

   360 				}

   361 			else

   362 				{

   363 				failingAllocationNo = allocationNo;

   364 				}

   365 

   366 			ResetDbHeapFailure(TheOomTestType[i]);

   367 

   368 			if(aTestFunctionPtrL == &ExecStatement8L || aTestFunctionPtrL == &ExecStatement16L)

   369 				{

   370 				_LIT(KSqlDropString, "DROP TABLE IF EXISTS BBB;");

   371 				err = db.Exec(KSqlDropString);

   372 				TEST(err >= 0);

   373 				err = KErrNone;

   374 				}

   375 			else if(aTestFunctionPtrL == &DeleteDbL && err == KErrNone)

   376 				{

   377 				err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);

   378 				TEST2(err, KErrNone);

   379 				}

   380 			db.Close();

   381 

   382 			__UHEAP_MARKEND;

   383 

   384 			CheckAllocatedCells();

   385 			CheckHandles();

   386 			

   387 			if(err == KErrNoMemory && allocationNo == maxAllocationNo)

   388 				{

   389 				maxAllocationNo += 10;

   390 				}

   391 			}

   392 		TEST2(err, KErrNone);

   393 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo + 1);

   394 		}

   395 	//Delete the database file

   396 	RSqlDatabase::Delete(aDbFileName);

   397 	securityPolicy.Close();

   398 	}

   399 

   400 //An attempt to open a non-secure database somehow happened to be in the server's private data cage.

   401 void DoDbOomTest2()

   402 	{

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

   404 		{

   405 		TInt err = KErrNone;

   406 		TInt failingAllocationNo = 0;

   407 		TInt allocationNo = 0;

   408 		TInt maxAllocationNo = TheOomTestType[i] == EServerSideTest ? KDoDbOomTest2AllocLimitServer : KDoDbOomTest2AllocLimitClient;

   409 		while(allocationNo < maxAllocationNo)

   410 			{

   411 			MarkHandles();

   412 			MarkAllocatedCells();

   413 

   414 			__UHEAP_MARK;

   415 

   416 			SetDbHeapFailure(TheOomTestType[i], ++allocationNo);

   417 

   418 			RSqlDatabase db;

   419 			err = db.Open(KSecureAttachDb2);

   420 			db.Close();

   421 			if(err != KErrNoMemory)

   422 				{

   423 				TEST2(err, KSqlErrGeneral);

   424 				}

   425 			else

   426 				{

   427 				failingAllocationNo = allocationNo;

   428 				}

   429 

   430 			ResetDbHeapFailure(TheOomTestType[i]);

   431 

   432 			__UHEAP_MARKEND;

   433 

   434 			CheckAllocatedCells();

   435 			CheckHandles();

   436 			

   437 			if(err == KErrNoMemory && allocationNo == maxAllocationNo)

   438 				{

   439 				maxAllocationNo += 10;

   440 				}

   441 			}

   442 		TEST2(err, KSqlErrGeneral);

   443 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo + 1);

   444 		}

   445 	}

   446 

   447 ///////////////////////////////////////////////////////////////////////////////////////

   448 ///////////////////////////////////////////////////////////////////////////////////////

   449 

   450 //RSqlDatabase OOM tests

   451 void DbOomTestsL(TDbType aDbType)

   452 	{

   453 	TPtrC dbFileName(KTestDb);

   454 	if(aDbType == ESecureDb)

   455 		{

   456 		dbFileName.Set(KSecureTestDb());

   457 		}

   458 

   459 	CreateAttachDb();

   460 

   461 	TheTest.Printf(_L("===RSqlDatabase::Create()\r\n"));

   462 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone);

   463 

   464 	TheTest.Printf(_L("===RSqlDatabase::Create() + config string\r\n"));

   465 	_LIT8(KConfigStr, "page_size=2048");

   466 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone, &KConfigStr);

   467 

   468 	TheTest.Printf(_L("===RSqlDatabase::Create() + config string + manual compaction\r\n"));

   469 	_LIT8(KConfigStr2, "compaction=manual");

   470 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone, &KConfigStr2);

   471 	

   472 	TheTest.Printf(_L("===RSqlDatabase::Create() + config string + background compaction\r\n"));

   473 	_LIT8(KConfigStr3, "compaction=background");

   474 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone, &KConfigStr3);

   475 	

   476 	TheTest.Printf(_L("===RSqlDatabase::Create() + config string + auto compaction\r\n"));

   477 	_LIT8(KConfigStr4, "compaction=auto");

   478 	DoCreateDatabaseOomTest(dbFileName, aDbType, KErrNone, &KConfigStr4);

   479 

   480 	if(aDbType == ENonSecureDb)

   481 		{//Private database is not a database taht will be created in the SQL server private data cage.

   482 		(void)RSqlDatabase::Delete(KPrivateTestDb);

   483 		TheTest.Printf(_L("===RSqlDatabase::Create() private database + config string + manual compaction\r\n"));

   484 		DoCreateDatabaseOomTest(KPrivateTestDb, ENonSecureDb, KErrNone, &KConfigStr2);

   485 		

   486 		(void)RSqlDatabase::Delete(KPrivateTestDb);

   487 		TheTest.Printf(_L("===RSqlDatabase::Create() private database + config string + background compaction\r\n"));

   488 		DoCreateDatabaseOomTest(KPrivateTestDb, ENonSecureDb, KErrNone, &KConfigStr3);

   489 		

   490 		(void)RSqlDatabase::Delete(KPrivateTestDb);

   491 		TheTest.Printf(_L("===RSqlDatabase::Create() private database + config string + auto compaction\r\n"));

   492 		DoCreateDatabaseOomTest(KPrivateTestDb, ENonSecureDb, KErrNone, &KConfigStr4);

   493 		}

   494 	

   495 	TheTest.Printf(_L("===RSqlDatabase::Open()\r\n"));

   496 	DoDbOomTest(&OpenDatabaseL, dbFileName, ENotOpenDb, aDbType);

   497 

   498 	TheTest.Printf(_L("===RSqlDatabase::OpenL()\r\n"));

   499 	DoDbOomTest(&OpenDatabase2L, dbFileName, ENotOpenDb, aDbType);

   500 

   501 	TheTest.Printf(_L("===RSqlDatabase::Open() + config string\r\n"));

   502 	DoDbOomTest(&OpenDatabase3L, dbFileName, ENotOpenDb, aDbType);

   503 	

   504 	if(aDbType == ENonSecureDb)

   505 		{//Private database cannot be opened as a secure database

   506 		TheTest.Printf(_L("===RSqlDatabase::Open() - from handle\r\n"));

   507 		DoDbOomTest(&OpenDatabaseFromHandleL, KPrivateTestDb, ENotOpenDb, aDbType);

   508 

   509 		TheTest.Printf(_L("===RSqlDatabase::Open() - from handle + config string\r\n"));

   510 		DoDbOomTest(&OpenDatabaseFromHandle2L, KPrivateTestDb, ENotOpenDb, aDbType);

   511 		}

   512 

   513 	TheTest.Printf(_L("===RSqlDatabase::Exec(), 8-bit SQL\r\n"));

   514 	DoDbOomTest(&ExecStatement8L, dbFileName, EOpenDb, aDbType);

   515 

   516 	TheTest.Printf(_L("===RSqlDatabase::Exec(), 16-bit SQL\r\n"));

   517 	DoDbOomTest(&ExecStatement16L, dbFileName, EOpenDb, aDbType);

   518 

   519 	TheTest.Printf(_L("===RSqlDatabase::SetIsolationLevel()\r\n"));

   520 	DoDbOomTest(&SetIsolationLevelL, dbFileName, EOpenDb, aDbType);

   521 

   522 	TheTest.Printf(_L("===RSqlDatabase::Size()\r\n"));

   523 	DoDbOomTest(&DbSizeL, dbFileName, EOpenDb, aDbType);

   524 

   525 	TheTest.Printf(_L("===RSqlDatabase::Size(TSize&)\r\n"));

   526 	DoDbOomTest(&DbSize2L, dbFileName, EOpenDb, aDbType);

   527 

   528 	TheTest.Printf(_L("===RSqlDatabase::Size(TSize&) - attached database\r\n"));

   529 	DoDbOomTest(&DbAttachSize2L, dbFileName, EOpenDb, aDbType);

   530 

   531 	TheTest.Printf(_L("===RSqlDatabase::Delete()\r\n"));

   532 	DoDbOomTest(&DeleteDbL, dbFileName, ENotOpenDb, aDbType);

   533 

   534 	TheTest.Printf(_L("===RSqlDatabase::Attach()\r\n"));

   535 	DoDbOomTest(&AttachDatabaseL, dbFileName, EOpenDb, aDbType);

   536 

   537 	//Ensure that the private database to be attached exists

   538 	PrepareAttachFromHandle();

   539 	TheTest.Printf(_L("===RSqlDatabase::Attach() - from handle\r\n"));

   540 	DoDbOomTest(&AttachDatabase2L, dbFileName, EOpenDb, aDbType);

   541 

   542 	TheTest.Printf(_L("===RSqlDatabase::Copy()\r\n"));

   543 	DoDbOomTest(&CopyDatabaseL, dbFileName, ENotOpenDb, aDbType);

   544 

   545 	if(aDbType == ESecureDb)

   546 		{

   547 		TheTest.Printf(_L("===RSqlDatabase::GetSecurityPolicy()\r\n"));

   548 		DoDbOomTest(&GetSecurityPolicyL, dbFileName, EOpenDb, aDbType);

   549 

   550 		TheTest.Printf(_L("===RSqlDatabase::GetSecurityPolicyL()\r\n"));

   551 		DoDbOomTest(&GetSecurityPolicy2L, dbFileName, EOpenDb, aDbType);

   552 		}

   553 

   554 	TheTest.Printf(_L("===RSqlDatabase::ReserveDriveSpace()\r\n"));

   555 	DoDbOomTest(&ReserveDriveSpaceL, dbFileName, EOpenDb, aDbType);

   556 

   557 	TheTest.Printf(_L("===RSqlDatabase::GetReserveAccess()\r\n"));

   558 	DoDbOomTest(&GetReserveAccessL, dbFileName, EOpenDb, aDbType);

   559 

   560 	TheTest.Printf(_L("===RSqlDatabase::LastInsertedRowId()\r\n"));

   561 	DoDbOomTest(&DbLastInsertedRowIdL, dbFileName, EOpenDb, aDbType);

   562 

   563 	TheTest.Printf(_L("===RSqlDatabase::Open(), non-secure database in server data cage\r\n"));

   564 	DoDbOomTest2();

   565 	}
Symaptic