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_sqloom2.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 // Copyright (c) 2005-2010 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 RTest TheTest(_L("t_sqloom2 test"));

    19 

    20 const TInt KSqlBufMaxLen = 16 * 1024;

    21 const TInt KBlobStrLen = KSqlBufMaxLen / 2 - 100;

    22 const TInt KBlobLen = KBlobStrLen;

    23 

    24 TBuf8<KSqlBufMaxLen> TheSqlBuf;

    25 TBuf8<KBlobStrLen> TheSqlBuf2;

    26 

    27 ///////////////////////////////////////////////////////////////////////////////////////

    28 ///////////////         RSqlStatement OOM tests         ///////////////////////////////

    29 ///////////////////////////////////////////////////////////////////////////////////////

    30 

    31 _LIT8(KSqlDbString, "BEGIN;\

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

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

    34                      COMMIT;");

    35 _LIT8(KSqlDbString2,"INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(1, 34, 10.9897, 'data2');");

    36 

    37 const TInt KLongColumnSize = 3013;

    38 const TInt KLongParameterSize = 4501;

    39 

    40 #define MAX(a, b) ((a) > (b) ? (a) : (b))

    41 

    42 static TUint16 TheTextColumnData[MAX(KLongColumnSize, KLongParameterSize)];

    43 static TUint8 TheBinaryColumnData[MAX(KLongColumnSize, KLongParameterSize) * sizeof(TUint16)];

    44 

    45 //"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement)

    46 void PrepareStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

    47 	{

    48 	_LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");

    49 	TInt err = aStmt.Prepare(aDb, KSqlString);

    50 	User::LeaveIfError(err);

    51 	}

    52 

    53 //"RSqlStatement::PrepareL()" OOM test (8-bit SELECT SQL statement)

    54 void PrepareStmt8_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)

    55 	{

    56 	_LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");

    57 	aStmt.PrepareL(aDb, KSqlString);

    58 	}

    59 

    60 //"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement), syntax error

    61 void PrepareBadStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

    62 	{

    63 	_LIT8(KSqlString, "SELECT123 * FROM BBB WHERE Fld1=? AND Fld4<>?");

    64 	TInt err = aStmt.Prepare(aDb, KSqlString);

    65 	User::LeaveIfError(err);

    66 	}

    67 

    68 //"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement, move next)

    69 void PrepareMoveStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

    70 	{

    71 	_LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");

    72 	TInt err = aStmt.Prepare(aDb, KSqlString);

    73     User::LeaveIfError(err);

    74     err = aStmt.BindInt(0, 1);

    75     User::LeaveIfError(err);

    76     err = aStmt.BindText(1, _L("data244weewfn43wr83224iu23ewkjfbrektug4i433b3k45b"));

    77     User::LeaveIfError(err);

    78     err = aStmt.Next();

    79     if(err == KSqlAtRow)

    80         {

    81         err = KErrNone;

    82         }

    83 	User::LeaveIfError(err);

    84 	}

    85 

    86 //"RSqlStatement::Prepare()" OOM test (8-bit INSERT SQL statement)

    87 void PrepareInsertStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

    88 	{

    89 	_LIT8(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(2, 22, 22.2222, '2-2-2-2');");

    90 	TInt err = aStmt.Prepare(aDb, KSqlString);

    91 	User::LeaveIfError(err);

    92 	}

    93 

    94 //"RSqlStatement::Prepare(), RSqlStatement::Exec(), RSqlStatement::Next()" OOM test (8-bit INSERT SQL statement, long column)

    95 void ExecInsertNextStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

    96 	{

    97 	_LIT8(KSqlString1, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, :Prm1, :Prm2);");

    98 	_LIT8(KSqlString2, "SELECT * FROM BBB WHERE fld1 = 10");

    99 	TInt err = aStmt.Prepare(aDb, KSqlString1);

   100 	if(err == KErrNone)

   101 		{

   102 		for(TInt i=0;i<KLongColumnSize;++i)

   103 			{

   104 			TheTextColumnData[i] = (TUint16)i;

   105 			}

   106 		const TPtrC textVal(TheTextColumnData, KLongColumnSize);

   107 		const TPtrC8 binVal((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));

   108 		TInt err = aStmt.BindText(0, textVal);

   109 		if(err == KErrNone)

   110 			{

   111 			err = aStmt.BindBinary(1, binVal);

   112 			}

   113 		if(err == KErrNone)

   114 			{

   115 			err = aStmt.Exec();

   116 			}

   117 		}

   118 	if(err >= 0)

   119 		{

   120 		aStmt.Close();

   121 		err = aStmt.Prepare(aDb, KSqlString2);

   122 		if(err == KErrNone)

   123 			{

   124 			err = aStmt.Next();

   125 			}

   126 		}

   127 	User::LeaveIfError(err);

   128 	}

   129 

   130 //"RSqlStatement::Prepare()" OOM test (8-bit INSERT SQL statement with parameters)

   131 void PrepareInsertPrmStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

   132 	{

   133 	_LIT8(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(:Prm0, :Prm1, :Prm2, :Prm3);");

   134 	TInt err = aStmt.Prepare(aDb, KSqlString);

   135 	User::LeaveIfError(err);

   136 	}

   137 

   138 //"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement)

   139 void PrepareStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

   140 	{

   141 	_LIT(KSqlString, "SELECT * FROM BBB");

   142 	TInt err = aStmt.Prepare(aDb, KSqlString);

   143 	User::LeaveIfError(err);

   144 	}

   145 

   146 //"RSqlStatement::PrepareL()" OOM test (16-bit SELECT SQL statement)

   147 void PrepareStmt16_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)

   148 	{

   149 	_LIT(KSqlString, "SELECT * FROM BBB");

   150 	aStmt.PrepareL(aDb, KSqlString);

   151 	}

   152 

   153 //"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement), syntax error

   154 void PrepareBadStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

   155 	{

   156 	_LIT(KSqlString, "23478SELECT * FROM BBB");

   157 	TInt err = aStmt.Prepare(aDb, KSqlString);

   158 	User::LeaveIfError(err);

   159 	}

   160 

   161 //"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement, move next)

   162 void PrepareMoveStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

   163 	{

   164 	_LIT(KSqlString, "SELECT * FROM BBB");

   165 	TInt err = aStmt.Prepare(aDb, KSqlString);

   166 	if(err == KErrNone)

   167 		{

   168 		err = aStmt.Next();

   169 		if(err == KSqlAtRow)

   170 			{

   171 			err = KErrNone;

   172 			}

   173 		}

   174 	User::LeaveIfError(err);

   175 	}

   176 

   177 //"RSqlStatement::Prepare()" OOM test (16-bit INSERT SQL statement)

   178 void PrepareInsertStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

   179 	{

   180 	_LIT(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(2, 22, 22.2222, '2-2-2-2');");

   181 	TInt err = aStmt.Prepare(aDb, KSqlString);

   182 	User::LeaveIfError(err);

   183 	}

   184 

   185 //"RSqlStatement::Prepare(), RSqlStatement::Exec(), RSqlStatement::Next()" OOM test (16-bit INSERT SQL statement, long column)

   186 void ExecInsertNextStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

   187 	{

   188 	_LIT(KSqlString1, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, :Prm1, :Prm2);");

   189 	_LIT(KSqlString2, "SELECT * FROM BBB WHERE fld1 = 10");

   190 	TInt err = aStmt.Prepare(aDb, KSqlString1);

   191 	if(err == KErrNone)

   192 		{

   193 		for(TInt i=0;i<KLongColumnSize;++i)

   194 			{

   195 			TheTextColumnData[i] = (TUint16)i;

   196 			}

   197 		const TPtrC textVal(TheTextColumnData, KLongColumnSize);

   198 		const TPtrC8 binVal((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));

   199 		TInt err = aStmt.BindText(0, textVal);

   200 		if(err == KErrNone)

   201 			{

   202 			err = aStmt.BindBinary(1, binVal);

   203 			}

   204 		if(err == KErrNone)

   205 			{

   206 			err = aStmt.Exec();

   207 			}

   208 		}

   209 	if(err >= 0)

   210 		{

   211 		aStmt.Close();

   212 		err = aStmt.Prepare(aDb, KSqlString2);

   213 		if(err == KErrNone)

   214 			{

   215 			err = aStmt.Next();

   216 			}

   217 		}

   218 	User::LeaveIfError(err);

   219 	}

   220 

   221 //"RSqlStatement::Prepare()" OOM test (16-bit INSERT SQL statement with parameters)

   222 void PrepareInsertPrmStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

   223 	{

   224 	_LIT(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(:Prm0, :Prm1, :Prm2, :Prm3);");

   225 	TInt err = aStmt.Prepare(aDb, KSqlString);

   226 	User::LeaveIfError(err);

   227 	}

   228 

   229 /**

   230 @SYMTestCaseID			SYSLIB-SQL-CT-1617

   231 @SYMTestCaseDesc		RSqlStatement::Prepare() OOM test

   232 						Precondition: the database exists, opened, some record(s) inserted.

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

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

   235 @SYMTestPriority		High

   236 @SYMTestActions			RSqlStatement::Prepare() OOM test

   237 @SYMTestExpectedResults Test must not fail

   238 @SYMREQ					REQ5792

   239                         REQ5793

   240 */

   241 void DoStmtPrepareOomTestL(TStmtFuncPtrL aStmtFuncPtrL, const TDesC& aDbFileName, TDbType aDbType, TInt aExpectedError = KErrNone)

   242 	{

   243 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1617 RSqlStatement::Prepare() - OOM test"));

   244 	RSqlSecurityPolicy securityPolicy;

   245 	CreateTestSecurityPolicy(securityPolicy);

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

   247 		{

   248 		RSqlDatabase::Delete(aDbFileName);

   249 		RSqlDatabase db;

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

   251 		TEST2(err, KErrNone);

   252 		err = db.Exec(KSqlDbString);

   253 		TEST(err >= 0);

   254 		//The next operation is executed to force the SQL server side session to make one memory allocation

   255 		//for the statement handle in its RDbObjContainer contrainer data member. Otherwise the OOM test will fail,

   256 		//because the server side session will do one additional allocation, which stays alive untill the

   257 		//session gets closed.

   258 		RSqlStatement dummyStmt;

   259 		err = dummyStmt.Prepare(db, _L("SELECT * FROM BBB"));

   260 		TEST2(err, KErrNone);

   261 		dummyStmt.Close();

   262 

   263 		err = KErrNoMemory;

   264 		const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;

   265 		TInt allocationNo = 0;

   266 		TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.

   267 		while(allocationNo < KMaxAllocation)

   268 			{

   269 			MarkHandles();

   270 			MarkAllocatedCells();

   271 

   272 			__UHEAP_MARK;

   273 

   274 			SetHeapFailure(TheOomTestType[i], ++allocationNo);

   275 

   276 	    	RSqlStatement stmt;

   277 			TRAP(err, (*aStmtFuncPtrL)(db, stmt));

   278 			stmt.Close();

   279 			if(err != KErrNoMemory)

   280 				{

   281 				TEST2(err, aExpectedError);

   282 				}

   283 			else

   284 				{

   285 				failingAllocationNo = allocationNo;	

   286 				}

   287 

   288 			ResetHeapFailure(TheOomTestType[i]);

   289 

   290 			__UHEAP_MARKEND;

   291 

   292 			CheckAllocatedCells();

   293 			CheckHandles();

   294 			}

   295 

   296 		db.Close();

   297 		TEST2(err, aExpectedError);

   298 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);

   299 		}

   300 	//Delete the database file

   301 	RSqlDatabase::Delete(aDbFileName);

   302 	securityPolicy.Close();

   303 	}

   304 

   305 //"RSqlStatement::Reset()" OOM test

   306 void ResetStmtL(RSqlStatement& aStmt)

   307 	{

   308 	TInt err = aStmt.Next();

   309 	if(err == KErrNone)

   310 		{

   311 		err = aStmt.Reset();

   312 		}

   313 	User::LeaveIfError(err);

   314 	}

   315 

   316 //"RSqlStatement::Exec()" OOM test

   317 void ExecStmtL(RSqlStatement& aStmt)

   318 	{

   319 	TInt err = aStmt.Exec();

   320 	User::LeaveIfError(err);

   321 	}

   322 

   323 //"RSqlStatement::Next()" OOM test

   324 void NextStmtL(RSqlStatement& aStmt)

   325 	{

   326 	TInt err = aStmt.Next();

   327 	if(err == KErrNone)

   328 		{

   329 		err = aStmt.Next();

   330 		}

   331 	User::LeaveIfError(err);

   332 	}

   333 

   334 //"RSqlStatement::ParameterIndex()" OOM test

   335 void StmtParameterIndexL(RSqlStatement& aStmt)

   336 	{

   337 	TInt err = aStmt.ParameterIndex(_L(":Prm2"));

   338 	if(err == 1) //":Prm2" index is 1

   339 		{

   340 		err = KErrNone;

   341 		}

   342 	User::LeaveIfError(err);

   343 	}

   344 

   345 //"RSqlStatement::ParameterName()" OOM test

   346 void StmtParameterNameL(RSqlStatement& aStmt)

   347 	{

   348 	// _LIT(KExcpected, ":Prm2");

   349 	TPtrC paramName;

   350 	TInt err = aStmt.ParameterName(1, paramName);

   351 	User::LeaveIfError(err);

   352 	}

   353 

   354 //"RSqlStatement::ParamName()" OOM test

   355 void StmtParamNameL(RSqlStatement& aStmt)

   356 	{

   357 	TPtrC paramName;

   358 	TInt err = aStmt.ParamName(1, paramName);

   359 	User::LeaveIfError(err);

   360 	}

   361 

   362 //"RSqlStatement::ColumnIndex()" OOM test

   363 void StmtColumnIndexL(RSqlStatement& aStmt)

   364 	{

   365 	TInt err = aStmt.ColumnIndex(_L("fLd3"));

   366 	if(err == 2) //"fLd3" index is 2

   367 		{

   368 		err = KErrNone;

   369 		}

   370 	User::LeaveIfError(err);

   371 	}

   372 

   373 //"RSqlStatement::ColumnName()" OOM test

   374 void StmtColumnNameL(RSqlStatement& aStmt)

   375 	{

   376 	//_LIT(KExpected, "fLd3");

   377 	TPtrC colName;

   378 	TInt err = aStmt.ColumnName(2, colName);

   379 	User::LeaveIfError(err);

   380 	}

   381 

   382 

   383 //"RSqlStatement::ColumnType()" OOM test

   384 void StmtColumnTypeL(RSqlStatement& aStmt)

   385 	{

   386 	TSqlColumnType coltype = aStmt.ColumnType(2);

   387 	TEST(coltype == ESqlReal);

   388 	}

   389 

   390 //"RSqlStatement::ColumnSize()" OOM test

   391 void StmtColumnSizeL(RSqlStatement& aStmt)

   392 	{

   393 	TInt colsize = aStmt.ColumnSize(2);

   394 	TEST(colsize == sizeof(TReal));

   395 	}

   396 

   397 //"RSqlStatement::BindNull()" OOM test

   398 void StmtBindNullL(RSqlStatement& aStmt)

   399 	{

   400 	TInt err = aStmt.BindNull(1);

   401 	//The bindings will be transferred on the server side right before Next() or Exec() call

   402 	if(err == KErrNone)

   403 		{

   404 		err = aStmt.Exec();

   405 		}

   406 	User::LeaveIfError(err);

   407 	}

   408 

   409 //"RSqlStatement::BindInt()" OOM test

   410 void StmtBindIntL(RSqlStatement& aStmt)

   411 	{

   412 	TInt val = 184;

   413 	TInt err = aStmt.BindInt(0, val);

   414 	//The bindings will be transferred on the server side right before Next() or Exec() call

   415 	if(err == KErrNone)

   416 		{

   417 		err = aStmt.Exec();

   418 		}

   419 	User::LeaveIfError(err);

   420 	}

   421 

   422 //"RSqlStatement::BindInt64()" OOM test

   423 void StmtBindInt64L(RSqlStatement& aStmt)

   424 	{

   425 	TInt64 val = MAKE_TINT64(0x00FF00FF, 0x12345678);

   426 	TInt err = aStmt.BindInt64(1, val);

   427 	//The bindings will be transferred on the server side right before Next() or Exec() call

   428 	if(err == KErrNone)

   429 		{

   430 		err = aStmt.Exec();

   431 		}

   432 	User::LeaveIfError(err);

   433 	}

   434 

   435 //"RSqlStatement::BindReal()" OOM test

   436 void StmtBindRealL(RSqlStatement& aStmt)

   437 	{

   438 	TReal val = 25.2423;

   439 	TInt err = aStmt.BindReal(2, val);

   440 	//The bindings will be transferred on the server side right before Next() or Exec() call

   441 	if(err == KErrNone)

   442 		{

   443 		err = aStmt.Exec();

   444 		}

   445 	User::LeaveIfError(err);

   446 	}

   447 

   448 //"RSqlStatement::BindText()" OOM test

   449 void StmtBindTextL(RSqlStatement& aStmt)

   450 	{

   451 	for(TInt i=0;i<KLongParameterSize;++i)

   452 		{

   453 		TheTextColumnData[i] = (TUint16)i;

   454 		}

   455 	const TPtrC val(TheTextColumnData, KLongParameterSize);

   456 	TInt err = aStmt.BindText(3, val);

   457 	//The bindings will be transferred on the server side right before a Next() or Exec() call

   458 	if(err == KErrNone)

   459 		{

   460 		err = aStmt.Exec();

   461 		}

   462 	User::LeaveIfError(err);

   463 	}

   464 

   465 //"RSqlStatement::BindBinary()" OOM test

   466 void StmtBindBinaryL(RSqlStatement& aStmt)

   467 	{

   468 	for(TInt i=0;i<KLongParameterSize;++i)

   469 		{

   470 		TheBinaryColumnData[i] = (TUint8)i;

   471 		}

   472 	const TPtrC8 val(TheBinaryColumnData, KLongParameterSize);

   473 	TInt err = aStmt.BindBinary(3, val);

   474 	//The bindings will be transferred on the server side right before a Next() or Exec() call

   475 	if(err == KErrNone)

   476 		{

   477 		err = aStmt.Exec();

   478 		}

   479 	User::LeaveIfError(err);

   480 	}

   481 

   482 //"RSqlStatement::BindZeroBlob()" OOM test

   483 void StmtBindZeroBlobL(RSqlStatement& aStmt)

   484 	{

   485 	TInt err = aStmt.BindZeroBlob(3, KLongParameterSize);

   486 	//The bindings will be transferred on the server side right before a Next() or Exec() call

   487 	if(err == KErrNone)

   488 		{

   489 		err = aStmt.Exec();

   490 		}

   491 	User::LeaveIfError(err);

   492 	}

   493 

   494 //"RSqlStatement::IsNull()" OOM test

   495 void StmtIsNullColumnL(RSqlStatement& aStmt)

   496 	{

   497 	TBool rc = aStmt.IsNull(0);

   498 	TEST(!rc);

   499 	}

   500 

   501 //"RSqlStatement::ColumnInt()" OOM test

   502 void StmtColumnIntL(RSqlStatement& aStmt)

   503 	{

   504 	TInt val = aStmt.ColumnInt(0);

   505 	TEST(val == 10);

   506 	}

   507 

   508 //"RSqlStatement::ColumnInt64()" OOM test

   509 void StmtColumnInt64L(RSqlStatement& aStmt)

   510 	{

   511 	TInt64 val = aStmt.ColumnInt64(1);

   512 	TEST(val == 100);

   513 	}

   514 

   515 //"RSqlStatement::ColumnReal()" OOM test

   516 void StmtColumnRealL(RSqlStatement& aStmt)

   517 	{

   518 	TReal val = aStmt.ColumnReal(2);

   519 	TEST(Abs(val - 100.001) < 0.000001);

   520 	}

   521 

   522 //"RSqlStatement::ColumnTextL()" OOM test

   523 void StmtColumnText1L(RSqlStatement& aStmt)

   524 	{

   525 	TPtrC val = aStmt.ColumnTextL(3);

   526 	TEST(val.Length() == KLongColumnSize);

   527 	for(TInt i=0;i<KLongColumnSize;++i)

   528 		{

   529 		TEST(val[i] == (TUint16)i);

   530 		}

   531 	}

   532 

   533 //"RSqlStatement::ColumnText()" OOM test

   534 void StmtColumnText2L(RSqlStatement& aStmt)

   535 	{

   536 	TPtrC val;

   537 	TInt err = aStmt.ColumnText(3, val);

   538 	User::LeaveIfError(err);

   539 	TEST(val.Length() == KLongColumnSize);

   540 	for(TInt i=0;i<KLongColumnSize;++i)

   541 		{

   542 		TEST(val[i] == (TUint16)i);

   543 		}

   544 	}

   545 

   546 //"RSqlStatement::ColumnText()" OOM test

   547 void StmtColumnText3L(RSqlStatement& aStmt)

   548 	{

   549 	TPtr val(TheTextColumnData, KLongColumnSize);

   550 	TInt err = aStmt.ColumnText(3, val);

   551 	User::LeaveIfError(err);

   552 	TEST(val.Length() == KLongColumnSize);

   553 	for(TInt i=0;i<KLongColumnSize;++i)

   554 		{

   555 		TEST(val[i] == (TUint16)i);

   556 		}

   557 	}

   558 

   559 //"RSqlStatement::ColumnBinaryL()" OOM test

   560 void StmtColumnBinary1L(RSqlStatement& aStmt)

   561 	{

   562 	TPtrC8 val = aStmt.ColumnBinaryL(4);

   563 	TEST(val.Length() == KLongColumnSize * sizeof(TUint16));

   564 	for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)

   565 		{

   566 		TUint8 valLow = val[j];

   567 		TUint8 valHigh = val[j + 1];

   568 		TEST(valLow == (TUint8)(i & 0xFF));

   569 		TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));

   570 		}

   571 	}

   572 

   573 //"RSqlStatement::ColumnBinary()" OOM test

   574 void StmtColumnBinary2L(RSqlStatement& aStmt)

   575 	{

   576 	TPtrC8 val;

   577 	TInt err = aStmt.ColumnBinary(4, val);

   578 	User::LeaveIfError(err);

   579 	TEST(val.Length() == KLongColumnSize * sizeof(TUint16));

   580 	for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)

   581 		{

   582 		TUint8 valLow = val[j];

   583 		TUint8 valHigh = val[j + 1];

   584 		TEST(valLow == (TUint8)(i & 0xFF));

   585 		TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));

   586 		}

   587 	}

   588 

   589 //"RSqlStatement::ColumnBinary()" OOM test

   590 void StmtColumnBinary3L(RSqlStatement& aStmt)

   591 	{

   592 	TPtr8 val(TheBinaryColumnData, KLongColumnSize * sizeof(TUint16));

   593 	TInt err = aStmt.ColumnBinary(4, val);

   594 	User::LeaveIfError(err);

   595 	TEST(val.Length() == KLongColumnSize * sizeof(TUint16));

   596 	for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)

   597 		{

   598 		TUint8 valLow = val[j];

   599 		TUint8 valHigh = val[j + 1];

   600 		TEST(valLow == (TUint8)(i & 0xFF));

   601 		TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));

   602 		}

   603 	}

   604 

   605 //"RSqlStatement::ColumnCount()" OOM test

   606 void StmtColumnCount(RSqlStatement& aStmt)

   607 	{

   608 	TInt cnt = aStmt.ColumnCount();

   609 	TEST2(cnt, 5);

   610 	}

   611 

   612 //"RSqlStatement::DeclaredColumnType()" OOM test

   613 void StmtDeclaredColumnTypeL(RSqlStatement& aStmt)

   614 	{

   615 	TInt cnt = aStmt.ColumnCount();

   616 	TEST2(cnt, 5);

   617 	const TSqlColumnType KColTypes[] = {ESqlInt, ESqlInt, ESqlReal, ESqlText, ESqlBinary};

   618 	for(TInt i=0;i<cnt;++i)

   619 		{

   620 		TSqlColumnType colType;

   621 		TInt err = aStmt.DeclaredColumnType(i, colType);

   622 		User::LeaveIfError(err);

   623 		TEST2(colType, KColTypes[i]);

   624 		}

   625 	}

   626 

   627 //"RSqlColumnReadStream::ColumnBinary()" OOM test

   628 void StmtColumnBinaryStreamL(RSqlStatement& aStmt)

   629 	{

   630 	RSqlColumnReadStream strm;

   631 	CleanupClosePushL(strm);

   632 	TInt err = strm.ColumnBinary(aStmt, 4);

   633 	User::LeaveIfError(err);

   634 	strm.ReadL(TheBinaryColumnData, KLongColumnSize * sizeof(TUint16));

   635 	CleanupStack::PopAndDestroy(&strm);

   636 	for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)

   637 		{

   638 		TUint8 valLow = TheBinaryColumnData[j];

   639 		TUint8 valHigh = TheBinaryColumnData[j + 1];

   640 		TEST(valLow == (TUint8)(i & 0xFF));

   641 		TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));

   642 		}

   643 	}

   644 

   645 //"RSqlColumnReadStream::ColumnText()" OOM test

   646 void StmtColumnTextStreamL(RSqlStatement& aStmt)

   647 	{

   648 	RSqlColumnReadStream strm;

   649 	CleanupClosePushL(strm);

   650 	TInt err = strm.ColumnText(aStmt, 3);

   651 	User::LeaveIfError(err);

   652 	strm.ReadL(TheTextColumnData, KLongColumnSize);

   653 	CleanupStack::PopAndDestroy(&strm);

   654 	for(TInt i=0;i<KLongColumnSize;++i)

   655 		{

   656 		TEST(TheTextColumnData[i] == (TUint16)i);

   657 		}

   658 	}

   659 

   660 //"RSqlParamWriteStream::BindBinary()" OOM test

   661 void StmtParamBinaryStreamL(RSqlStatement& aStmt)

   662 	{

   663 	for(TInt i=0;i<KLongParameterSize;++i)

   664 		{

   665 		TheTextColumnData[i] = (TUint16)i;

   666 		}

   667 

   668 	RSqlParamWriteStream strm;

   669 	CleanupClosePushL(strm);

   670 	TInt err = strm.BindBinary(aStmt, 3);

   671 	User::LeaveIfError(err);

   672 	strm.WriteL((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));

   673 	CleanupStack::PopAndDestroy(&strm);

   674 	}

   675 

   676 //"RSqlParamWriteStream::BindText()" OOM test

   677 void StmtParamTextStreamL(RSqlStatement& aStmt)

   678 	{

   679 	for(TInt i=0;i<KLongParameterSize;++i)

   680 		{

   681 		TheTextColumnData[i] = (TUint16)i;

   682 		}

   683 

   684 	RSqlParamWriteStream strm;

   685 	CleanupClosePushL(strm);

   686 	TInt err = strm.BindText(aStmt, 3);

   687 	User::LeaveIfError(err);

   688 	strm.WriteL(TheTextColumnData, KLongColumnSize);

   689 	CleanupStack::PopAndDestroy(&strm);

   690 	}

   691 

   692 /**

   693 @SYMTestCaseID			SYSLIB-SQL-CT-1618

   694 @SYMTestCaseDesc		RSqlStatement methods OOM tests

   695 						Precondition: the database exists, opened, some record(s) inserted.

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

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

   698 @SYMTestPriority		High

   699 @SYMTestActions			RSqlStatement methods OOM tests

   700 @SYMTestExpectedResults Test must not fail

   701 @SYMREQ					REQ5792

   702                         REQ5793

   703 */

   704 void DoStmtOomTestL(TStmtFuncPtrL aStmtPrepareFuncPtrL, TStmtFuncPtr2L aStmtTestFuncPtrL, const TDesC& aDbFileName, TDbType aDbType)

   705 	{

   706 	//This is not really an OOM test, because:

   707 	//(A) The test forces the server to simulate heap failure on determied allocation step

   708 	//(B) SQL server counts only the number of active statement and stream objects, the allocated memory cells

   709 	//    are not counted.

   710 	//    The reason that the allocated memory cells are not counted and in case of OOM failure - checked is

   711 	//    because the SQL server may make some per-connection persistent memory allocations (cache pages, etc.)

   712 	//    which will not be deallocated when the statement object is closed.

   713 

   714 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1618 RSqlStatement - OOM test"));

   715 	RSqlSecurityPolicy securityPolicy;

   716 	CreateTestSecurityPolicy(securityPolicy);

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

   718 		{

   719 		RSqlDatabase::Delete(aDbFileName);

   720 		RSqlDatabase db;

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

   722 		TEST2(err, KErrNone);

   723 		err = db.Exec(KSqlDbString);

   724 		TEST(err >= 0);

   725 		err = db.Exec(KSqlDbString2);

   726 		TEST(err >= 0);

   727 

   728 		err = KErrNoMemory;

   729 		const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;

   730 		TInt allocationNo = 0;

   731 		TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.

   732 		while(allocationNo < KMaxAllocation)

   733 			{

   734 			MarkHandles();

   735 			MarkAllocatedCells();

   736 

   737 			__UHEAP_MARK;

   738 

   739 	    	RSqlStatement stmt;

   740 			TRAP(err, (*aStmtPrepareFuncPtrL)(db, stmt));

   741 			TEST2(err, KErrNone);

   742 

   743 			SetHeapFailure(TheOomTestType[i], ++allocationNo);

   744 

   745 			TRAP(err, (*aStmtTestFuncPtrL)(stmt));

   746 

   747 			//ResetHeapFailure() has to be called before stmt.Close() because,

   748 			//otherwise it will panic the server (the server resource count, marked by

   749 			//SetHeapFailure() call, is 1 (there is one prepared statement))

   750 			ResetHeapFailure(TheOomTestType[i]);

   751 

   752 			stmt.Close();

   753 

   754 			if(err != KErrNoMemory)

   755 				{

   756 				TEST2(err, KErrNone);

   757 				}

   758 			else

   759 				{

   760 				failingAllocationNo = allocationNo;	

   761 				}

   762 

   763 			__UHEAP_MARKEND;

   764 

   765 			CheckAllocatedCells();

   766 			CheckHandles();

   767 			}

   768 

   769 		db.Close();

   770 		TEST2(err, KErrNone);

   771 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);

   772 		}

   773 	//Delete the database file

   774 	RSqlDatabase::Delete(aDbFileName);

   775 	securityPolicy.Close();

   776 	}

   777 

   778 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   779 //////////////////               RSqlBlobReadStream, RSqlBlobWriteStream - OOM tests          /////////////////////

   780 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   781 

   782 //RSqlBlobReadStream, RSqlBlobWriteStream - OOM test preparation.

   783 void ExecInsertBlobL(RSqlDatabase& aDb)

   784 	{

   785 	_LIT8(KSqlString1, "CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT, Fld5 LONGBLOB)");

   786 	TInt err = aDb.Exec(KSqlString1);

   787 	User::LeaveIfError(err);

   788 	_LIT8(KSqlString2, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, 'AAA', x'");

   789 	TheSqlBuf.Copy(KSqlString2);

   790 	for(TInt i=0;i<KBlobStrLen;++i)	

   791 		{

   792 		TheSqlBuf.Append(_L8("A5"));

   793 		}

   794 	TheSqlBuf.Append(_L8("')"));

   795 	err = aDb.Exec(TheSqlBuf);

   796 	User::LeaveIfError(err);

   797 	}

   798 

   799 //"RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL()" OOM test

   800 void BlobReadStreamOpenL(RSqlDatabase& aDb, const TDesC& aAttachDbName)

   801 	{

   802 	RSqlBlobReadStream strm;

   803 	CleanupClosePushL(strm);

   804 	if(aAttachDbName.Length() > 0)

   805 		{

   806 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);

   807 		}

   808 	else

   809 		{

   810 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);

   811 		}

   812 	const TInt KReadOpCnt = 8;

   813 	for(TInt j=0;j<KReadOpCnt;++j)

   814 		{

   815 		strm.ReadL(TheSqlBuf, KBlobLen / KReadOpCnt);

   816 		TEST2(TheSqlBuf.Length(), (KBlobLen / KReadOpCnt));

   817 		for(TInt i=0;i<(KBlobLen / KReadOpCnt);++i)

   818 			{

   819 			TUint8 val = TheSqlBuf[i];

   820 			TEST2(val, 0xA5);

   821 			}

   822 		}

   823 	CleanupStack::PopAndDestroy(&strm);

   824 	}

   825 

   826 //"RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL()" OOM test

   827 void BlobReadStreamSizeL(RSqlDatabase& aDb, const TDesC& aAttachDbName)

   828 	{

   829 	RSqlBlobReadStream strm;

   830 	CleanupClosePushL(strm);

   831 	if(aAttachDbName.Length() > 0)

   832 		{

   833 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);

   834 		}

   835 	else

   836 		{

   837 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);

   838 		}

   839 	TInt size = strm.SizeL();	

   840 	TEST2(size, KBlobLen);

   841 	CleanupStack::PopAndDestroy(&strm);

   842 	}

   843 

   844 //"RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL()" OOM test

   845 void BlobWriteStreamOpenL(RSqlDatabase& aDb, const TDesC& aAttachDbName)

   846 	{

   847 	RSqlBlobWriteStream strm;

   848 	CleanupClosePushL(strm);

   849 	if(aAttachDbName.Length() > 0)

   850 		{

   851 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);

   852 		}

   853 	else

   854 		{

   855 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);

   856 		}

   857 	const TInt KWriteOpCnt = 8;

   858 	TheSqlBuf.SetLength(KBlobLen / KWriteOpCnt);

   859 	TheSqlBuf.Fill(TChar('Z'));

   860 	for(TInt j=0;j<KWriteOpCnt;++j)

   861 		{

   862 		strm.WriteL(TheSqlBuf, KBlobLen / KWriteOpCnt);

   863 		}

   864 	strm.CommitL();		

   865 	CleanupStack::PopAndDestroy(&strm);

   866 	}

   867 

   868 //"RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL()" OOM test

   869 void BlobWriteStreamSizeL(RSqlDatabase& aDb, const TDesC& aAttachDbName)

   870 	{

   871 	RSqlBlobWriteStream strm;

   872 	CleanupClosePushL(strm);

   873 	if(aAttachDbName.Length() > 0)

   874 		{

   875 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);

   876 		}

   877 	else

   878 		{

   879 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);

   880 		}

   881 	TInt size = strm.SizeL();	

   882 	TEST2(size, KBlobLen);

   883 	CleanupStack::PopAndDestroy(&strm);

   884 	}

   885 	

   886 //"TSqlBlob::GetLC()" OOM test

   887 void BlobWholeGet1L(RSqlDatabase& aDb, const TDesC& aAttachDbName)

   888 	{

   889 	HBufC8* buf = NULL;

   890 	if(aAttachDbName.Length() > 0)

   891 		{

   892 		buf = TSqlBlob::GetLC(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);

   893 		}

   894 	else

   895 		{

   896 		buf = TSqlBlob::GetLC(aDb, _L("BBB"), _L("fld5"), 1);

   897 		}

   898 	TEST(buf->Length() == KBlobStrLen);

   899 	CleanupStack::PopAndDestroy(buf);

   900 	}

   901 	

   902 //"TSqlBlob::Get()" OOM test

   903 void BlobWholeGet2L(RSqlDatabase& aDb, const TDesC& aAttachDbName)

   904 	{

   905 	if(aAttachDbName.Length() > 0)

   906 		{

   907 		TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf2, 1, aAttachDbName);

   908 		}

   909 	else

   910 		{

   911 		TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf2, 1);

   912 		}

   913 	}

   914 

   915 //"TSqlBlob::SetL()" OOM test

   916 void BlobWholeSetL(RSqlDatabase& aDb, const TDesC& aAttachDbName)

   917 	{

   918 	if(aAttachDbName.Length() > 0)

   919 		{

   920 		TSqlBlob::SetL(aDb, _L("BBB"), _L("fld5"), TheSqlBuf, 1, aAttachDbName);

   921 		}

   922 	else

   923 		{

   924 		TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf, 1);

   925 		}

   926 	}

   927 

   928 /**

   929 @SYMTestCaseID			SYSLIB-SQL-UT-4091

   930 @SYMTestCaseDesc		RSqlBlobReadStream, RSqlBlobWriteStream methods OOM tests

   931 						Precondition: the database exists, opened, some record(s) inserted.

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

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

   934 @SYMTestPriority		High

   935 @SYMTestActions			RSqlBlobReadStream, RSqlBlobWriteStream methods OOM tests

   936 @SYMTestExpectedResults Test must not fail

   937 @SYMREQ					REQ5792

   938                         REQ10410

   939                         REQ10411

   940                         REQ10418

   941 */

   942 void DoBlobOomTestL(TBlobPrepareFuncPtrL aBlobPrepareFuncPtrL, TBlobTestFuncPtrL aBlobTestFuncPtrL, 

   943 					const TDesC& aDbFileName, TDbType aDbType, TBool aAttachDb = EFalse)

   944 	{

   945 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4091 RSqlBlobReadStream, RSqlBlobWriteStream - OOM test"));

   946 	RSqlSecurityPolicy securityPolicy;

   947 	CreateTestSecurityPolicy(securityPolicy);

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

   949 		{

   950 		RSqlDatabase::Delete(aDbFileName);

   951 		RSqlDatabase db;

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

   953 		TEST2(err, KErrNone);

   954 		TRAP(err, (*aBlobPrepareFuncPtrL)(db));

   955 		TEST2(err, KErrNone);

   956 		_LIT(KAttachDbName, "AttachDb");

   957 		if(aAttachDb)

   958 			{

   959 			err = db.Attach(aDbFileName, KAttachDbName);

   960 			TEST2(err, KErrNone);

   961 			}

   962 

   963 		err = KErrNoMemory;

   964 		const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KBlobOomTestAllocLimitServer : KBlobOomTestAllocLimitClient;

   965 		TInt allocationNo = 0;

   966 		TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.

   967 		while(allocationNo < KMaxAllocation)

   968 			{

   969 			MarkHandles();

   970 			MarkAllocatedCells();

   971 

   972 			__UHEAP_MARK;

   973 

   974 			SetHeapFailure(TheOomTestType[i], ++allocationNo);

   975 			if(aAttachDb)

   976 				{

   977 				TRAP(err, (*aBlobTestFuncPtrL)(db, KAttachDbName));

   978 				}

   979 			else

   980 				{

   981 				TRAP(err, (*aBlobTestFuncPtrL)(db, KNullDesC));

   982 				}

   983 

   984 			ResetHeapFailure(TheOomTestType[i]);

   985 

   986 			if(err != KErrNoMemory)

   987 				{

   988 				if(err != KErrNone)

   989 					{

   990 					TPtrC errmsg = db.LastErrorMessage();

   991 					if(errmsg.Length() > 0)

   992 						{

   993 						TheTest.Printf(_L("\r\n@@@ error %d, error message: %S\r\n"), err, &errmsg);	

   994 						}

   995 					}

   996 				TEST2(err, KErrNone);

   997 				}

   998 			else

   999 				{

  1000 				failingAllocationNo = allocationNo;

  1001 				}				

  1002 

  1003 			__UHEAP_MARKEND;

  1004 

  1005 			CheckAllocatedCells();

  1006 			CheckHandles();

  1007 			}

  1008 		TEST2(err, KErrNone);

  1009 

  1010 		if(aAttachDb)

  1011 			{

  1012 			(void)db.Detach(KAttachDbName);

  1013 			}

  1014 

  1015 		db.Close();

  1016 		err = RSqlDatabase::Delete(aDbFileName);

  1017 		TEST2(err, KErrNone);

  1018 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);

  1019 		}

  1020 	securityPolicy.Close();

  1021 	}

  1022 

  1023 void ScalarFullSelectInt_8L(RSqlDatabase& aDb)

  1024 	{

  1025 	TSqlScalarFullSelectQuery query(aDb);

  1026 	TInt val = query.SelectIntL(_L8("SELECT F1 FROM A WHERE F3 < 0"));

  1027 	TEST2(val, 2);

  1028 	}

  1029 

  1030 void ScalarFullSelectInt64_8L(RSqlDatabase& aDb)

  1031 	{

  1032 	TSqlScalarFullSelectQuery query(aDb);

  1033 	TInt64 val = query.SelectInt64L(_L8("SELECT F2 FROM A WHERE F1 = 1"));

  1034 	TEST2(val, 10000000000LL);

  1035 	}

  1036 

  1037 void ScalarFullSelectReal_8L(RSqlDatabase& aDb)

  1038 	{

  1039 	TSqlScalarFullSelectQuery query(aDb);

  1040 	TReal val = query.SelectRealL(_L8("SELECT F3 FROM A WHERE F1 = 1"));

  1041 	TEST(val > 2.0 && val < 3.0);

  1042 	}

  1043 

  1044 void ScalarFullSelectText_8L(RSqlDatabase& aDb)

  1045 	{

  1046 	TSqlScalarFullSelectQuery query(aDb);

  1047 	TBuf<20> buf;

  1048 	TInt err = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), buf);

  1049 	TEST2(err, KErrNone);

  1050 	_LIT(KText, "NAME1234567890");

  1051 	TEST(buf == KText);

  1052 	}

  1053 

  1054 void ScalarFullSelectBinary_8L(RSqlDatabase& aDb)

  1055 	{

  1056 	TSqlScalarFullSelectQuery query(aDb);

  1057 	TBuf8<20> buf;

  1058 	TInt err = query.SelectBinaryL(_L8("SELECT F5 FROM A WHERE F1 = 1"), buf);

  1059 	TEST2(err, KErrNone);

  1060 	TEST(buf.Length() == 0);

  1061 	}

  1062 

  1063 void ScalarFullSelectInt_16L(RSqlDatabase& aDb)

  1064 	{

  1065 	TSqlScalarFullSelectQuery query(aDb);

  1066 	TInt val = query.SelectIntL(_L16("SELECT F1 FROM A WHERE F3 < 0"));

  1067 	TEST2(val, 2);

  1068 	}

  1069 

  1070 void ScalarFullSelectInt64_16L(RSqlDatabase& aDb)

  1071 	{

  1072 	TSqlScalarFullSelectQuery query(aDb);

  1073 	TInt64 val = query.SelectInt64L(_L16("SELECT F2 FROM A WHERE F1 = 1"));

  1074 	TEST2(val, 10000000000LL);

  1075 	}

  1076 

  1077 void ScalarFullSelectReal_16L(RSqlDatabase& aDb)

  1078 	{

  1079 	TSqlScalarFullSelectQuery query(aDb);

  1080 	TReal val = query.SelectRealL(_L16("SELECT F3 FROM A WHERE F1 = 1"));

  1081 	TEST(val > 2.0 && val < 3.0);

  1082 	}

  1083 

  1084 void ScalarFullSelectText_16L(RSqlDatabase& aDb)

  1085 	{

  1086 	TSqlScalarFullSelectQuery query(aDb);

  1087 	TBuf<20> buf;

  1088 	TInt err = query.SelectTextL(_L16("SELECT F4 FROM A WHERE F1 = 1"), buf);

  1089 	TEST2(err, KErrNone);

  1090 	_LIT(KText, "NAME1234567890");

  1091 	TEST(buf == KText);

  1092 	}

  1093 

  1094 void ScalarFullSelectBinary_16L(RSqlDatabase& aDb)

  1095 	{

  1096 	TSqlScalarFullSelectQuery query(aDb);

  1097 	TBuf8<20> buf;

  1098 	TInt err = query.SelectBinaryL(_L16("SELECT F5 FROM A WHERE F1 = 1"), buf);

  1099 	TEST2(err, KErrNone);

  1100 	TEST(buf.Length() == 0);

  1101 	}

  1102 

  1103 void ScalarFullSelectText2_8L(RSqlDatabase& aDb)

  1104 	{

  1105 	TSqlScalarFullSelectQuery query(aDb);

  1106 	HBufC* buf = HBufC::NewLC(8);

  1107 	TPtr name = buf->Des();

  1108 	TInt rc = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), name);

  1109 	TEST(rc >= 0); //the function may return only non-negative values

  1110 	if(rc > 0)

  1111 		{

  1112 		buf = buf->ReAllocL(rc);

  1113 		CleanupStack::Pop();

  1114 		CleanupStack::PushL(buf);

  1115 		name.Set(buf->Des());

  1116 		rc = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), name);

  1117 		TEST(rc == 0);

  1118 		_LIT(KText, "NAME1234567890");

  1119 		TEST(name == KText);

  1120 		}

  1121 	CleanupStack::PopAndDestroy(buf);

  1122 	}

  1123 

  1124 /**

  1125 @SYMTestCaseID			SYSLIB-SQL-CT-1811

  1126 @SYMTestCaseDesc		TSqlScalarFullSelectQuery functions OOM test

  1127 						Precondition: the database exists.

  1128 						The test simulates OOM failures while calling TSqlScalarFullSelectQuery functions

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

  1130 @SYMTestPriority		High

  1131 @SYMTestActions			TSqlScalarFullSelectQuery methods OOM tests

  1132 @SYMTestExpectedResults Test must not fail

  1133 @SYMREQ					REQ5792

  1134                         REQ5793

  1135 */

  1136 void DoFullSelectOomTest(TScalarFullSelectFuncPtrL aTestFunctionPtrL)

  1137 	{

  1138 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1811 TSqlScalarFullSelectQuery - OOM test"));

  1139 	//Create test database

  1140 	RSqlDatabase db;

  1141 	TInt err = db.Create(KTestDb);

  1142 	TEST2(err, KErrNone);

  1143 	err = db.Exec(_L("CREATE TABLE A(F1 INTEGER, F2 INTEGER, F3 FLOAT, F4 TEXT, F5 BLOB)"));

  1144 	TEST(err >= 0);

  1145 	err = db.Exec(_L("INSERT INTO A(F1, F2, F3, F4, F5) VALUES(1, 10000000000, 2.54, 'NAME1234567890', NULL)"));

  1146 	TEST2(err, 1);

  1147 	err = db.Exec(_L("INSERT INTO A(F1, F2, F3, F4) VALUES(2, 200, -1.11, 'ADDRESS')"));

  1148 	TEST2(err, 1);

  1149 	db.Close();

  1150 	//OOM test loop

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

  1152 		{

  1153 		err = KErrNoMemory;

  1154 		const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;

  1155 		TInt allocationNo = 0;

  1156 		TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.

  1157 		while(allocationNo < KMaxAllocation)

  1158 			{

  1159 			MarkHandles();

  1160 			MarkAllocatedCells();

  1161 

  1162 			__UHEAP_MARK;

  1163 

  1164 			if(TheOomTestType[i] == EServerSideTest)

  1165 				{//We will delay the heap failure simulation, until the database is opened

  1166 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo, ETrue);

  1167 				}

  1168 

  1169 			err = db.Open(KTestDb);

  1170 			TEST2(err, KErrNone);

  1171 

  1172 			if(TheOomTestType[i] == EClientSideTest)

  1173 				{

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

  1175 				}

  1176 

  1177 			TRAP(err, (*aTestFunctionPtrL)(db));

  1178 			db.Close();

  1179 			if(err != KErrNoMemory)

  1180 				{

  1181 				TEST2(err, KErrNone);

  1182 				}

  1183 			else

  1184 				{

  1185 				failingAllocationNo = allocationNo;	

  1186 				}

  1187 

  1188 			ResetDbHeapFailure(TheOomTestType[i]);

  1189 

  1190 			__UHEAP_MARKEND;

  1191 

  1192 			CheckAllocatedCells();

  1193 			CheckHandles();

  1194 			}

  1195 		TEST2(err, KErrNone);

  1196 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);

  1197 		}

  1198 	//Delete the database file

  1199 	RSqlDatabase::Delete(KTestDb);

  1200 	}

  1201 

  1202 //RSqlStatement OOM tests

  1203 void StmtOomTestsL()

  1204 	{

  1205 	const TInt KTestCnt = 2;

  1206 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};

  1207 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};

  1208 

  1209 	for(TInt i=0;i<KTestCnt;++i)

  1210 		{

  1211 		TheTest.Printf(_L("===RSqlStatement::Prepare(), 8-bit SQL\r\n"));

  1212 		DoStmtPrepareOomTestL(&PrepareStmt8L, dbFileName[i], dbType[i]);

  1213 

  1214 		TheTest.Printf(_L("===RSqlStatement::PrepareL(), 8-bit SQL\r\n"));

  1215 		DoStmtPrepareOomTestL(&PrepareStmt8_2L, dbFileName[i], dbType[i]);

  1216 

  1217 		TheTest.Printf(_L("===RSqlStatement::Prepare(), 16-bit SQL\r\n"));

  1218 		DoStmtPrepareOomTestL(&PrepareStmt16L, dbFileName[i], dbType[i]);

  1219 

  1220 		TheTest.Printf(_L("===RSqlStatement::PrepareL(), 16-bit SQL\r\n"));

  1221 		DoStmtPrepareOomTestL(&PrepareStmt16_2L, dbFileName[i], dbType[i]);

  1222 

  1223 		TheTest.Printf(_L("===RSqlStatement::Reset(), 8-bit SQL\r\n"));

  1224 		DoStmtOomTestL(&PrepareStmt8L, &ResetStmtL, dbFileName[i], dbType[i]);

  1225 

  1226 		TheTest.Printf(_L("===RSqlStatement::Reset(), 16-bit SQL\r\n"));

  1227 		DoStmtOomTestL(&PrepareStmt16L, &ResetStmtL, dbFileName[i], dbType[i]);

  1228 

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

  1230 		DoStmtOomTestL(&PrepareInsertStmt8L, &ExecStmtL, dbFileName[i], dbType[i]);

  1231 

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

  1233 		DoStmtOomTestL(&PrepareInsertStmt16L, &ExecStmtL, dbFileName[i], dbType[i]);

  1234 

  1235 		TheTest.Printf(_L("===RSqlStatement::Next(), 8-bit SQL\r\n"));

  1236 		DoStmtOomTestL(&PrepareStmt8L, &NextStmtL, dbFileName[i], dbType[i]);

  1237 

  1238 		TheTest.Printf(_L("===RSqlStatement::Next(), 16-bit SQL\r\n"));

  1239 		DoStmtOomTestL(&PrepareStmt16L, &NextStmtL, dbFileName[i], dbType[i]);

  1240 

  1241 		TheTest.Printf(_L("===RSqlStatement::ParameterIndex(), 8-bit SQL\r\n"));

  1242 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParameterIndexL, dbFileName[i], dbType[i]);

  1243 

  1244 		TheTest.Printf(_L("===RSqlStatement::ParameterIndex(), 16-bit SQL\r\n"));

  1245 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParameterIndexL, dbFileName[i], dbType[i]);

  1246 

  1247 		TheTest.Printf(_L("===RSqlStatement::ParameterName(), 8-bit SQL\r\n"));

  1248 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParameterNameL, dbFileName[i], dbType[i]);

  1249 

  1250 		TheTest.Printf(_L("===RSqlStatement::ParameterName(), 16-bit SQL\r\n"));

  1251 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParameterNameL, dbFileName[i], dbType[i]);

  1252 

  1253 		TheTest.Printf(_L("===RSqlStatement::ParamName(), 8-bit SQL\r\n"));

  1254 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamNameL, dbFileName[i], dbType[i]);

  1255 

  1256 		TheTest.Printf(_L("===RSqlStatement::ParamName(), 16-bit SQL\r\n"));

  1257 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamNameL, dbFileName[i], dbType[i]);

  1258 

  1259 		TheTest.Printf(_L("===RSqlStatement::ColumnIndex(), 8-bit SQL\r\n"));

  1260 		DoStmtOomTestL(&PrepareStmt8L, &StmtColumnIndexL, dbFileName[i], dbType[i]);

  1261 

  1262 		TheTest.Printf(_L("===RSqlStatement::ColumnIndex(), 16-bit SQL\r\n"));

  1263 		DoStmtOomTestL(&PrepareStmt16L, &StmtColumnIndexL, dbFileName[i], dbType[i]);

  1264 

  1265 		TheTest.Printf(_L("===RSqlStatement::ColumnType(), 8-bit SQL\r\n"));

  1266 		DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnTypeL, dbFileName[i], dbType[i]);

  1267 

  1268 		TheTest.Printf(_L("===RSqlStatement::ColumnType(), 16-bit SQL\r\n"));

  1269 		DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnTypeL, dbFileName[i], dbType[i]);

  1270 

  1271 		TheTest.Printf(_L("===RSqlStatement::ColumnSize(), 8-bit SQL\r\n"));

  1272 		DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnSizeL, dbFileName[i], dbType[i]);

  1273 

  1274 		TheTest.Printf(_L("===RSqlStatement::ColumnSize(), 16-bit SQL\r\n"));

  1275 		DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnSizeL, dbFileName[i], dbType[i]);

  1276 

  1277 		TheTest.Printf(_L("===RSqlStatement::ColumnName(), 8-bit SQL\r\n"));

  1278 		DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnNameL, dbFileName[i], dbType[i]);

  1279 

  1280 		TheTest.Printf(_L("===RSqlStatement::ColumnName(), 16-bit SQL\r\n"));

  1281 		DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnNameL, dbFileName[i], dbType[i]);

  1282 

  1283 		TheTest.Printf(_L("===RSqlStatement::BindNull(), 8-bit SQL\r\n"));

  1284 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindNullL, dbFileName[i], dbType[i]);

  1285 

  1286 		TheTest.Printf(_L("===RSqlStatement::BindNull(), 16-bit SQL\r\n"));

  1287 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindNullL, dbFileName[i], dbType[i]);

  1288 

  1289 		TheTest.Printf(_L("===RSqlStatement::BindInt(), 8-bit SQL\r\n"));

  1290 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindIntL, dbFileName[i], dbType[i]);

  1291 

  1292 		TheTest.Printf(_L("===RSqlStatement::BindInt(), 16-bit SQL\r\n"));

  1293 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindIntL, dbFileName[i], dbType[i]);

  1294 

  1295 		TheTest.Printf(_L("===RSqlStatement::BindInt64(), 8-bit SQL\r\n"));

  1296 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindInt64L, dbFileName[i], dbType[i]);

  1297 

  1298 		TheTest.Printf(_L("===RSqlStatement::BindInt64(), 16-bit SQL\r\n"));

  1299 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindInt64L, dbFileName[i], dbType[i]);

  1300 

  1301 		TheTest.Printf(_L("===RSqlStatement::BindReal(), 8-bit SQL\r\n"));

  1302 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindRealL, dbFileName[i], dbType[i]);

  1303 

  1304 		TheTest.Printf(_L("===RSqlStatement::BindReal(), 16-bit SQL\r\n"));

  1305 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindRealL, dbFileName[i], dbType[i]);

  1306 

  1307 		TheTest.Printf(_L("===RSqlStatement::BindText(), 8-bit SQL\r\n"));

  1308 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindTextL, dbFileName[i], dbType[i]);

  1309 

  1310 		TheTest.Printf(_L("===RSqlStatement::BindText(), 16-bit SQL\r\n"));

  1311 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindTextL, dbFileName[i], dbType[i]);

  1312 

  1313 		TheTest.Printf(_L("===RSqlStatement::BindBinary(), 8-bit SQL\r\n"));

  1314 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindBinaryL, dbFileName[i], dbType[i]);

  1315 

  1316 		TheTest.Printf(_L("===RSqlStatement::BindBinary(), 16-bit SQL\r\n"));

  1317 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindBinaryL, dbFileName[i], dbType[i]);

  1318 

  1319 		TheTest.Printf(_L("===RSqlStatement::BindZeroBlob(), 8-bit SQL\r\n"));

  1320 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindZeroBlobL, dbFileName[i], dbType[i]);

  1321 

  1322 		TheTest.Printf(_L("===RSqlStatement::BindZeroBlob(), 16-bit SQL\r\n"));

  1323 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindZeroBlobL, dbFileName[i], dbType[i]);

  1324 

  1325 		TheTest.Printf(_L("===RSqlStatement::IsNull(), 8-bit SQL\r\n"));

  1326 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtIsNullColumnL, dbFileName[i], dbType[i]);

  1327 

  1328 		TheTest.Printf(_L("===RSqlStatement::IsNull(), 16-bit SQL\r\n"));

  1329 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtIsNullColumnL, dbFileName[i], dbType[i]);

  1330 

  1331 		TheTest.Printf(_L("===RSqlStatement::ColumnInt(), 8-bit SQL\r\n"));

  1332 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnIntL, dbFileName[i], dbType[i]);

  1333 

  1334 		TheTest.Printf(_L("===RSqlStatement::ColumnInt(), 16-bit SQL\r\n"));

  1335 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnIntL, dbFileName[i], dbType[i]);

  1336 

  1337 		TheTest.Printf(_L("===RSqlStatement::ColumnInt64(), 8-bit SQL\r\n"));

  1338 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnInt64L, dbFileName[i], dbType[i]);

  1339 

  1340 		TheTest.Printf(_L("===RSqlStatement::ColumnInt64(), 16-bit SQL\r\n"));

  1341 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnInt64L, dbFileName[i], dbType[i]);

  1342 

  1343 		TheTest.Printf(_L("===RSqlStatement::ColumnReal(), 8-bit SQL\r\n"));

  1344 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnRealL, dbFileName[i], dbType[i]);

  1345 

  1346 		TheTest.Printf(_L("===RSqlStatement::ColumnReal(), 16-bit SQL\r\n"));

  1347 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnRealL, dbFileName[i], dbType[i]);

  1348 

  1349 		TheTest.Printf(_L("===RSqlStatement::ColumnTextL(), 8-bit SQL\r\n"));

  1350 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText1L, dbFileName[i], dbType[i]);

  1351 

  1352 		TheTest.Printf(_L("===RSqlStatement::ColumnTextL(), 16-bit SQL\r\n"));

  1353 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText1L, dbFileName[i], dbType[i]);

  1354 

  1355 		TheTest.Printf(_L("===RSqlStatement::ColumnText()-1, 8-bit SQL\r\n"));

  1356 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText2L, dbFileName[i], dbType[i]);

  1357 

  1358 		TheTest.Printf(_L("===RSqlStatement::ColumnText()-1, 16-bit SQL\r\n"));

  1359 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText2L, dbFileName[i], dbType[i]);

  1360 

  1361 		TheTest.Printf(_L("===RSqlStatement::ColumnText()-2, 8-bit SQL\r\n"));

  1362 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText3L, dbFileName[i], dbType[i]);

  1363 

  1364 		TheTest.Printf(_L("===RSqlStatement::ColumnText()-2, 16-bit SQL\r\n"));

  1365 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText3L, dbFileName[i], dbType[i]);

  1366 

  1367 		TheTest.Printf(_L("===RSqlStatement::ColumnBinaryL(), 8-bit SQL\r\n"));

  1368 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary1L, dbFileName[i], dbType[i]);

  1369 

  1370 		TheTest.Printf(_L("===RSqlStatement::ColumnBinaryL(), 16-bit SQL\r\n"));

  1371 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary1L, dbFileName[i], dbType[i]);

  1372 

  1373 		TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-1, 8-bit SQL\r\n"));

  1374 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary2L, dbFileName[i], dbType[i]);

  1375 

  1376 		TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-1, 16-bit SQL\r\n"));

  1377 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary2L, dbFileName[i], dbType[i]);

  1378 

  1379 		TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-2, 8-bit SQL\r\n"));

  1380 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary3L, dbFileName[i], dbType[i]);

  1381 

  1382 		TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-2, 16-bit SQL\r\n"));

  1383 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary3L, dbFileName[i], dbType[i]);

  1384 

  1385 		TheTest.Printf(_L("===RSqlStatement::ColumnCount(), 8-bit SQL\r\n"));

  1386 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnCount, dbFileName[i], dbType[i]);

  1387 

  1388 		TheTest.Printf(_L("===RSqlStatement::ColumnCount(), 16-bit SQL\r\n"));

  1389 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnCount, dbFileName[i], dbType[i]);

  1390 

  1391 		TheTest.Printf(_L("===RSqlStatement::DeclaredColumnType(), 8-bit SQL\r\n"));

  1392 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtDeclaredColumnTypeL, dbFileName[i], dbType[i]);

  1393 

  1394 		TheTest.Printf(_L("===RSqlStatement::DeclaredColumnType(), 16-bit SQL\r\n"));

  1395 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtDeclaredColumnTypeL, dbFileName[i], dbType[i]);

  1396 		}

  1397 	}

  1398 

  1399 //RSqlStatement - negative OOM tests

  1400 void StmtOomNegativeTestsL()

  1401 	{

  1402 	const TInt KTestCnt = 2;

  1403 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};

  1404 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};

  1405 

  1406 	for(TInt i=0;i<KTestCnt;++i)

  1407 		{

  1408 		TheTest.Printf(_L("===RSqlStatement::Prepare(), 8-bit SQL\r\n"));

  1409 		DoStmtPrepareOomTestL(&PrepareBadStmt8L, dbFileName[i], dbType[i], KSqlErrGeneral);

  1410 

  1411 		TheTest.Printf(_L("===RSqlStatement::Prepare(), 16-bit SQL\r\n"));

  1412 		DoStmtPrepareOomTestL(&PrepareBadStmt16L, dbFileName[i], dbType[i], KSqlErrGeneral);

  1413 		}

  1414 	}

  1415 

  1416 //RSqlColumnReadStream OOM tests

  1417 void ColumnReadStreamOomTestsL()

  1418 	{

  1419 	const TInt KTestCnt = 2;

  1420 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};

  1421 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};

  1422 

  1423 	for(TInt i=0;i<KTestCnt;++i)

  1424 		{

  1425 		TheTest.Printf(_L("===RSqlColumnReadStream::ColumnBinary(), 8-bit SQL\r\n"));

  1426 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinaryStreamL, dbFileName[i], dbType[i]);

  1427 

  1428 		TheTest.Printf(_L("===RSqlColumnReadStream::ColumnBinary(), 16-bit SQL\r\n"));

  1429 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinaryStreamL, dbFileName[i], dbType[i]);

  1430 

  1431 		TheTest.Printf(_L("===RSqlColumnReadStream::ColumnText(), 8-bit SQL\r\n"));

  1432 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnTextStreamL, dbFileName[i], dbType[i]);

  1433 

  1434 		TheTest.Printf(_L("===RSqlColumnReadStream::ColumnText(), 16-bit SQL\r\n"));

  1435 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnTextStreamL, dbFileName[i], dbType[i]);

  1436 		}

  1437 	}

  1438 

  1439 //RSqlParamWriteStream OOM tests

  1440 void ParamWriteStreamOomTestsL()

  1441 	{

  1442 	const TInt KTestCnt = 2;

  1443 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};

  1444 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};

  1445 

  1446 	for(TInt i=0;i<KTestCnt;++i)

  1447 		{

  1448 		TheTest.Printf(_L("===RSqlParamWriteStream::BindBinary(), 8-bit SQL\r\n"));

  1449 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamBinaryStreamL, dbFileName[i], dbType[i]);

  1450 

  1451 		TheTest.Printf(_L("===RSqlParamWriteStream::BindBinary(), 16-bit SQL\r\n"));

  1452 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamBinaryStreamL, dbFileName[i], dbType[i]);

  1453 

  1454 		TheTest.Printf(_L("===RSqlParamWriteStream::BindText(), 8-bit SQL\r\n"));

  1455 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamTextStreamL, dbFileName[i], dbType[i]);

  1456 

  1457 		TheTest.Printf(_L("===RSqlParamWriteStream::BindText(), 16-bit SQL\r\n"));

  1458 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamTextStreamL, dbFileName[i], dbType[i]);

  1459 		}

  1460 	}

  1461 

  1462 //TSqlScalarFullSelectQuery OOM tests

  1463 void ScalarFullSelectQueryOomTestsL()

  1464 	{

  1465 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectIntL(), 8-bit SQL\r\n"));

  1466 	DoFullSelectOomTest(&ScalarFullSelectInt_8L);

  1467 

  1468 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectInt64L(), 8-bit SQL\r\n"));

  1469 	DoFullSelectOomTest(&ScalarFullSelectInt64_8L);

  1470 

  1471 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectRealL(), 8-bit SQL\r\n"));

  1472 	DoFullSelectOomTest(&ScalarFullSelectReal_8L);

  1473 

  1474 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 8-bit SQL\r\n"));

  1475 	DoFullSelectOomTest(&ScalarFullSelectText_8L);

  1476 

  1477 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectBinaryL(), 8-bit SQL\r\n"));

  1478 	DoFullSelectOomTest(&ScalarFullSelectBinary_8L);

  1479 

  1480 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectIntL(), 16-bit SQL\r\n"));

  1481 	DoFullSelectOomTest(&ScalarFullSelectInt_16L);

  1482 

  1483 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectInt64L(), 16-bit SQL\r\n"));

  1484 	DoFullSelectOomTest(&ScalarFullSelectInt64_16L);

  1485 

  1486 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectRealL(), 16-bit SQL\r\n"));

  1487 	DoFullSelectOomTest(&ScalarFullSelectReal_16L);

  1488 

  1489 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 16-bit SQL\r\n"));

  1490 	DoFullSelectOomTest(&ScalarFullSelectText_16L);

  1491 

  1492 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectBinaryL(), 16-bit SQL\r\n"));

  1493 	DoFullSelectOomTest(&ScalarFullSelectBinary_16L);

  1494 

  1495 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 8-bit SQL, small buffer\r\n"));

  1496 	DoFullSelectOomTest(&ScalarFullSelectText2_8L);

  1497 	}

  1498 

  1499 void BlobReadStreamOomTestsL()

  1500 	{

  1501 	const TInt KTestCnt = 2;

  1502 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};

  1503 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};

  1504 

  1505 	for(TInt i=0;i<KTestCnt;++i)

  1506 		{

  1507 		TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL()\r\n"));

  1508 		DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamOpenL, dbFileName[i], dbType[i]);

  1509 

  1510 		TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL() + attached database\r\n"));

  1511 		DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamOpenL, dbFileName[i], dbType[i], ETrue);

  1512 

  1513 		TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL()\r\n"));

  1514 		DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamSizeL, dbFileName[i], dbType[i]);

  1515 

  1516 		TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL() + attached database\r\n"));

  1517 		DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamSizeL, dbFileName[i], dbType[i], ETrue);

  1518 		}

  1519 	}

  1520 

  1521 void BlobWriteStreamOomTestsL()

  1522 	{

  1523 	const TInt KTestCnt = 2;

  1524 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};

  1525 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};

  1526 

  1527 	for(TInt i=0;i<KTestCnt;++i)

  1528 		{

  1529 		TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL()\r\n"));

  1530 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamOpenL, dbFileName[i], dbType[i]);

  1531 

  1532 		TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL() + attached database\r\n"));

  1533 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamOpenL, dbFileName[i], dbType[i], ETrue);

  1534 

  1535 		TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL()\r\n"));

  1536 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamSizeL, dbFileName[i], dbType[i]);

  1537 

  1538 		TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL() + attached database\r\n"));

  1539 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamSizeL, dbFileName[i], dbType[i], ETrue);

  1540 		}

  1541 	}

  1542 	

  1543 void BlobWholeOomTestsL()

  1544 	{

  1545 	const TInt KTestCnt = 2;

  1546 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};

  1547 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};

  1548 

  1549 	for(TInt i=0;i<KTestCnt;++i)

  1550 		{

  1551 		TheTest.Printf(_L("===TSqlBlob::GetLC()\r\n"));

  1552 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeGet1L, dbFileName[i], dbType[i]);

  1553 

  1554 		TheTest.Printf(_L("===TSqlBlob::Get()\r\n"));

  1555 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeGet2L, dbFileName[i], dbType[i]);

  1556 

  1557 		TheTest.Printf(_L("===TSqlBlob::SetL()\r\n"));

  1558 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeSetL, dbFileName[i], dbType[i]);

  1559 		}

  1560 	}

  1561 

  1562 void DoTestsL()

  1563 	{

  1564 	TheTest.Start(_L("SQL OOM tests - 2"));

  1565 	

  1566 	StmtOomTestsL();

  1567 

  1568 	StmtOomNegativeTestsL();

  1569 

  1570 	ColumnReadStreamOomTestsL();

  1571 

  1572 	ParamWriteStreamOomTestsL();

  1573 

  1574 	ScalarFullSelectQueryOomTestsL();

  1575 

  1576 	BlobReadStreamOomTestsL();

  1577 

  1578 	BlobWriteStreamOomTestsL();

  1579 	

  1580 	BlobWholeOomTestsL();

  1581 	}

  1582 

  1583 TInt E32Main()

  1584 	{

  1585 	TheTest.Title();

  1586 

  1587 	CTrapCleanup* tc = CTrapCleanup::New();

  1588 

  1589 	__UHEAP_MARK;

  1590 

  1591 	CreateTestDir();

  1592 	DeleteTestFiles();

  1593 

  1594 	TRAPD(err, DoTestsL());

  1595 	DeleteTestFiles();

  1596 	TEST2(err, KErrNone);

  1597 

  1598 	__UHEAP_MARKEND;

  1599 

  1600 	TheTest.End();

  1601 	TheTest.Close();

  1602 

  1603 	delete tc;

  1604 

  1605 	User::Heap().Check();

  1606 	return KErrNone;

  1607 	}
Symaptic