sl@0: // Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "t_sqloom.h"
sl@0: 
sl@0: RTest TheTest(_L("t_sqloom2 test"));
sl@0: 
sl@0: const TInt KSqlBufMaxLen = 16 * 1024;
sl@0: const TInt KBlobStrLen = KSqlBufMaxLen / 2 - 100;
sl@0: const TInt KBlobLen = KBlobStrLen;
sl@0: 
sl@0: TBuf8<KSqlBufMaxLen> TheSqlBuf;
sl@0: TBuf8<KBlobStrLen> TheSqlBuf2;
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////         RSqlStatement OOM tests         ///////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: _LIT8(KSqlDbString, "BEGIN;\
sl@0: 					 CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT, Fld5 LONGBLOB);\
sl@0:                      INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(4562, 123456789012345, 78612.0091, 'text data');\
sl@0:                      COMMIT;");
sl@0: _LIT8(KSqlDbString2,"INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(1, 34, 10.9897, 'data2');");
sl@0: 
sl@0: const TInt KLongColumnSize = 3013;
sl@0: const TInt KLongParameterSize = 4501;
sl@0: 
sl@0: #define MAX(a, b) ((a) > (b) ? (a) : (b))
sl@0: 
sl@0: static TUint16 TheTextColumnData[MAX(KLongColumnSize, KLongParameterSize)];
sl@0: static TUint8 TheBinaryColumnData[MAX(KLongColumnSize, KLongParameterSize) * sizeof(TUint16)];
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement)
sl@0: void PrepareStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::PrepareL()" OOM test (8-bit SELECT SQL statement)
sl@0: void PrepareStmt8_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");
sl@0: 	aStmt.PrepareL(aDb, KSqlString);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement), syntax error
sl@0: void PrepareBadStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT8(KSqlString, "SELECT123 * FROM BBB WHERE Fld1=? AND Fld4<>?");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (8-bit SELECT SQL statement, move next)
sl@0: void PrepareMoveStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT8(KSqlString, "SELECT * FROM BBB WHERE Fld1=? AND Fld4<>?");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0:     User::LeaveIfError(err);
sl@0:     err = aStmt.BindInt(0, 1);
sl@0:     User::LeaveIfError(err);
sl@0:     err = aStmt.BindText(1, _L("data244weewfn43wr83224iu23ewkjfbrektug4i433b3k45b"));
sl@0:     User::LeaveIfError(err);
sl@0:     err = aStmt.Next();
sl@0:     if(err == KSqlAtRow)
sl@0:         {
sl@0:         err = KErrNone;
sl@0:         }
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (8-bit INSERT SQL statement)
sl@0: void PrepareInsertStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT8(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(2, 22, 22.2222, '2-2-2-2');");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare(), RSqlStatement::Exec(), RSqlStatement::Next()" OOM test (8-bit INSERT SQL statement, long column)
sl@0: void ExecInsertNextStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT8(KSqlString1, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, :Prm1, :Prm2);");
sl@0: 	_LIT8(KSqlString2, "SELECT * FROM BBB WHERE fld1 = 10");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString1);
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		for(TInt i=0;i<KLongColumnSize;++i)
sl@0: 			{
sl@0: 			TheTextColumnData[i] = (TUint16)i;
sl@0: 			}
sl@0: 		const TPtrC textVal(TheTextColumnData, KLongColumnSize);
sl@0: 		const TPtrC8 binVal((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
sl@0: 		TInt err = aStmt.BindText(0, textVal);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = aStmt.BindBinary(1, binVal);
sl@0: 			}
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = aStmt.Exec();
sl@0: 			}
sl@0: 		}
sl@0: 	if(err >= 0)
sl@0: 		{
sl@0: 		aStmt.Close();
sl@0: 		err = aStmt.Prepare(aDb, KSqlString2);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = aStmt.Next();
sl@0: 			}
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (8-bit INSERT SQL statement with parameters)
sl@0: void PrepareInsertPrmStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT8(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(:Prm0, :Prm1, :Prm2, :Prm3);");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement)
sl@0: void PrepareStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT(KSqlString, "SELECT * FROM BBB");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::PrepareL()" OOM test (16-bit SELECT SQL statement)
sl@0: void PrepareStmt16_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT(KSqlString, "SELECT * FROM BBB");
sl@0: 	aStmt.PrepareL(aDb, KSqlString);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement), syntax error
sl@0: void PrepareBadStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT(KSqlString, "23478SELECT * FROM BBB");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (16-bit SELECT SQL statement, move next)
sl@0: void PrepareMoveStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT(KSqlString, "SELECT * FROM BBB");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Next();
sl@0: 		if(err == KSqlAtRow)
sl@0: 			{
sl@0: 			err = KErrNone;
sl@0: 			}
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (16-bit INSERT SQL statement)
sl@0: void PrepareInsertStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(2, 22, 22.2222, '2-2-2-2');");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare(), RSqlStatement::Exec(), RSqlStatement::Next()" OOM test (16-bit INSERT SQL statement, long column)
sl@0: void ExecInsertNextStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT(KSqlString1, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, :Prm1, :Prm2);");
sl@0: 	_LIT(KSqlString2, "SELECT * FROM BBB WHERE fld1 = 10");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString1);
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		for(TInt i=0;i<KLongColumnSize;++i)
sl@0: 			{
sl@0: 			TheTextColumnData[i] = (TUint16)i;
sl@0: 			}
sl@0: 		const TPtrC textVal(TheTextColumnData, KLongColumnSize);
sl@0: 		const TPtrC8 binVal((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
sl@0: 		TInt err = aStmt.BindText(0, textVal);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = aStmt.BindBinary(1, binVal);
sl@0: 			}
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = aStmt.Exec();
sl@0: 			}
sl@0: 		}
sl@0: 	if(err >= 0)
sl@0: 		{
sl@0: 		aStmt.Close();
sl@0: 		err = aStmt.Prepare(aDb, KSqlString2);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = aStmt.Next();
sl@0: 			}
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Prepare()" OOM test (16-bit INSERT SQL statement with parameters)
sl@0: void PrepareInsertPrmStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	_LIT(KSqlString, "INSERT INTO BBB(fld1, fld2, fld3, fld4) VALUES(:Prm0, :Prm1, :Prm2, :Prm3);");
sl@0: 	TInt err = aStmt.Prepare(aDb, KSqlString);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1617
sl@0: @SYMTestCaseDesc		RSqlStatement::Prepare() OOM test
sl@0: 						Precondition: the database exists, opened, some record(s) inserted.
sl@0: 						The test calls the given as an argument function while simulating OOM failures
sl@0: 						and checks that there are no memory and resource leaks.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlStatement::Prepare() OOM test
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */
sl@0: void DoStmtPrepareOomTestL(TStmtFuncPtrL aStmtFuncPtrL, const TDesC& aDbFileName, TDbType aDbType, TInt aExpectedError = KErrNone)
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1617 RSqlStatement::Prepare() - OOM test"));
sl@0: 	RSqlSecurityPolicy securityPolicy;
sl@0: 	CreateTestSecurityPolicy(securityPolicy);
sl@0: 	for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 		{
sl@0: 		RSqlDatabase::Delete(aDbFileName);
sl@0: 		RSqlDatabase db;
sl@0: 		TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		err = db.Exec(KSqlDbString);
sl@0: 		TEST(err >= 0);
sl@0: 		//The next operation is executed to force the SQL server side session to make one memory allocation
sl@0: 		//for the statement handle in its RDbObjContainer contrainer data member. Otherwise the OOM test will fail,
sl@0: 		//because the server side session will do one additional allocation, which stays alive untill the
sl@0: 		//session gets closed.
sl@0: 		RSqlStatement dummyStmt;
sl@0: 		err = dummyStmt.Prepare(db, _L("SELECT * FROM BBB"));
sl@0: 		TEST2(err, KErrNone);
sl@0: 		dummyStmt.Close();
sl@0: 
sl@0: 		err = KErrNoMemory;
sl@0: 		const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
sl@0: 		TInt allocationNo = 0;
sl@0: 		TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.
sl@0: 		while(allocationNo < KMaxAllocation)
sl@0: 			{
sl@0: 			MarkHandles();
sl@0: 			MarkAllocatedCells();
sl@0: 
sl@0: 			__UHEAP_MARK;
sl@0: 
sl@0: 			SetHeapFailure(TheOomTestType[i], ++allocationNo);
sl@0: 
sl@0: 	    	RSqlStatement stmt;
sl@0: 			TRAP(err, (*aStmtFuncPtrL)(db, stmt));
sl@0: 			stmt.Close();
sl@0: 			if(err != KErrNoMemory)
sl@0: 				{
sl@0: 				TEST2(err, aExpectedError);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				failingAllocationNo = allocationNo;	
sl@0: 				}
sl@0: 
sl@0: 			ResetHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 			__UHEAP_MARKEND;
sl@0: 
sl@0: 			CheckAllocatedCells();
sl@0: 			CheckHandles();
sl@0: 			}
sl@0: 
sl@0: 		db.Close();
sl@0: 		TEST2(err, aExpectedError);
sl@0: 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
sl@0: 		}
sl@0: 	//Delete the database file
sl@0: 	RSqlDatabase::Delete(aDbFileName);
sl@0: 	securityPolicy.Close();
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Reset()" OOM test
sl@0: void ResetStmtL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt err = aStmt.Next();
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Reset();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Exec()" OOM test
sl@0: void ExecStmtL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt err = aStmt.Exec();
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::Next()" OOM test
sl@0: void NextStmtL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt err = aStmt.Next();
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Next();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ParameterIndex()" OOM test
sl@0: void StmtParameterIndexL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt err = aStmt.ParameterIndex(_L(":Prm2"));
sl@0: 	if(err == 1) //":Prm2" index is 1
sl@0: 		{
sl@0: 		err = KErrNone;
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ParameterName()" OOM test
sl@0: void StmtParameterNameL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	// _LIT(KExcpected, ":Prm2");
sl@0: 	TPtrC paramName;
sl@0: 	TInt err = aStmt.ParameterName(1, paramName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ParamName()" OOM test
sl@0: void StmtParamNameL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TPtrC paramName;
sl@0: 	TInt err = aStmt.ParamName(1, paramName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnIndex()" OOM test
sl@0: void StmtColumnIndexL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt err = aStmt.ColumnIndex(_L("fLd3"));
sl@0: 	if(err == 2) //"fLd3" index is 2
sl@0: 		{
sl@0: 		err = KErrNone;
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnName()" OOM test
sl@0: void StmtColumnNameL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	//_LIT(KExpected, "fLd3");
sl@0: 	TPtrC colName;
sl@0: 	TInt err = aStmt.ColumnName(2, colName);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: //"RSqlStatement::ColumnType()" OOM test
sl@0: void StmtColumnTypeL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TSqlColumnType coltype = aStmt.ColumnType(2);
sl@0: 	TEST(coltype == ESqlReal);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnSize()" OOM test
sl@0: void StmtColumnSizeL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt colsize = aStmt.ColumnSize(2);
sl@0: 	TEST(colsize == sizeof(TReal));
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::BindNull()" OOM test
sl@0: void StmtBindNullL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt err = aStmt.BindNull(1);
sl@0: 	//The bindings will be transferred on the server side right before Next() or Exec() call
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Exec();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::BindInt()" OOM test
sl@0: void StmtBindIntL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt val = 184;
sl@0: 	TInt err = aStmt.BindInt(0, val);
sl@0: 	//The bindings will be transferred on the server side right before Next() or Exec() call
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Exec();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::BindInt64()" OOM test
sl@0: void StmtBindInt64L(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt64 val = MAKE_TINT64(0x00FF00FF, 0x12345678);
sl@0: 	TInt err = aStmt.BindInt64(1, val);
sl@0: 	//The bindings will be transferred on the server side right before Next() or Exec() call
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Exec();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::BindReal()" OOM test
sl@0: void StmtBindRealL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TReal val = 25.2423;
sl@0: 	TInt err = aStmt.BindReal(2, val);
sl@0: 	//The bindings will be transferred on the server side right before Next() or Exec() call
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Exec();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::BindText()" OOM test
sl@0: void StmtBindTextL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	for(TInt i=0;i<KLongParameterSize;++i)
sl@0: 		{
sl@0: 		TheTextColumnData[i] = (TUint16)i;
sl@0: 		}
sl@0: 	const TPtrC val(TheTextColumnData, KLongParameterSize);
sl@0: 	TInt err = aStmt.BindText(3, val);
sl@0: 	//The bindings will be transferred on the server side right before a Next() or Exec() call
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Exec();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::BindBinary()" OOM test
sl@0: void StmtBindBinaryL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	for(TInt i=0;i<KLongParameterSize;++i)
sl@0: 		{
sl@0: 		TheBinaryColumnData[i] = (TUint8)i;
sl@0: 		}
sl@0: 	const TPtrC8 val(TheBinaryColumnData, KLongParameterSize);
sl@0: 	TInt err = aStmt.BindBinary(3, val);
sl@0: 	//The bindings will be transferred on the server side right before a Next() or Exec() call
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Exec();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::BindZeroBlob()" OOM test
sl@0: void StmtBindZeroBlobL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt err = aStmt.BindZeroBlob(3, KLongParameterSize);
sl@0: 	//The bindings will be transferred on the server side right before a Next() or Exec() call
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		err = aStmt.Exec();
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::IsNull()" OOM test
sl@0: void StmtIsNullColumnL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TBool rc = aStmt.IsNull(0);
sl@0: 	TEST(!rc);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnInt()" OOM test
sl@0: void StmtColumnIntL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt val = aStmt.ColumnInt(0);
sl@0: 	TEST(val == 10);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnInt64()" OOM test
sl@0: void StmtColumnInt64L(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt64 val = aStmt.ColumnInt64(1);
sl@0: 	TEST(val == 100);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnReal()" OOM test
sl@0: void StmtColumnRealL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TReal val = aStmt.ColumnReal(2);
sl@0: 	TEST(Abs(val - 100.001) < 0.000001);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnTextL()" OOM test
sl@0: void StmtColumnText1L(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TPtrC val = aStmt.ColumnTextL(3);
sl@0: 	TEST(val.Length() == KLongColumnSize);
sl@0: 	for(TInt i=0;i<KLongColumnSize;++i)
sl@0: 		{
sl@0: 		TEST(val[i] == (TUint16)i);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnText()" OOM test
sl@0: void StmtColumnText2L(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TPtrC val;
sl@0: 	TInt err = aStmt.ColumnText(3, val);
sl@0: 	User::LeaveIfError(err);
sl@0: 	TEST(val.Length() == KLongColumnSize);
sl@0: 	for(TInt i=0;i<KLongColumnSize;++i)
sl@0: 		{
sl@0: 		TEST(val[i] == (TUint16)i);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnText()" OOM test
sl@0: void StmtColumnText3L(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TPtr val(TheTextColumnData, KLongColumnSize);
sl@0: 	TInt err = aStmt.ColumnText(3, val);
sl@0: 	User::LeaveIfError(err);
sl@0: 	TEST(val.Length() == KLongColumnSize);
sl@0: 	for(TInt i=0;i<KLongColumnSize;++i)
sl@0: 		{
sl@0: 		TEST(val[i] == (TUint16)i);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnBinaryL()" OOM test
sl@0: void StmtColumnBinary1L(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TPtrC8 val = aStmt.ColumnBinaryL(4);
sl@0: 	TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
sl@0: 	for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
sl@0: 		{
sl@0: 		TUint8 valLow = val[j];
sl@0: 		TUint8 valHigh = val[j + 1];
sl@0: 		TEST(valLow == (TUint8)(i & 0xFF));
sl@0: 		TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnBinary()" OOM test
sl@0: void StmtColumnBinary2L(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TPtrC8 val;
sl@0: 	TInt err = aStmt.ColumnBinary(4, val);
sl@0: 	User::LeaveIfError(err);
sl@0: 	TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
sl@0: 	for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
sl@0: 		{
sl@0: 		TUint8 valLow = val[j];
sl@0: 		TUint8 valHigh = val[j + 1];
sl@0: 		TEST(valLow == (TUint8)(i & 0xFF));
sl@0: 		TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnBinary()" OOM test
sl@0: void StmtColumnBinary3L(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TPtr8 val(TheBinaryColumnData, KLongColumnSize * sizeof(TUint16));
sl@0: 	TInt err = aStmt.ColumnBinary(4, val);
sl@0: 	User::LeaveIfError(err);
sl@0: 	TEST(val.Length() == KLongColumnSize * sizeof(TUint16));
sl@0: 	for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
sl@0: 		{
sl@0: 		TUint8 valLow = val[j];
sl@0: 		TUint8 valHigh = val[j + 1];
sl@0: 		TEST(valLow == (TUint8)(i & 0xFF));
sl@0: 		TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::ColumnCount()" OOM test
sl@0: void StmtColumnCount(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt cnt = aStmt.ColumnCount();
sl@0: 	TEST2(cnt, 5);
sl@0: 	}
sl@0: 
sl@0: //"RSqlStatement::DeclaredColumnType()" OOM test
sl@0: void StmtDeclaredColumnTypeL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	TInt cnt = aStmt.ColumnCount();
sl@0: 	TEST2(cnt, 5);
sl@0: 	const TSqlColumnType KColTypes[] = {ESqlInt, ESqlInt, ESqlReal, ESqlText, ESqlBinary};
sl@0: 	for(TInt i=0;i<cnt;++i)
sl@0: 		{
sl@0: 		TSqlColumnType colType;
sl@0: 		TInt err = aStmt.DeclaredColumnType(i, colType);
sl@0: 		User::LeaveIfError(err);
sl@0: 		TEST2(colType, KColTypes[i]);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlColumnReadStream::ColumnBinary()" OOM test
sl@0: void StmtColumnBinaryStreamL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	RSqlColumnReadStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	TInt err = strm.ColumnBinary(aStmt, 4);
sl@0: 	User::LeaveIfError(err);
sl@0: 	strm.ReadL(TheBinaryColumnData, KLongColumnSize * sizeof(TUint16));
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	for(TInt i=0,j=0;i<KLongColumnSize;++i,j+=2)
sl@0: 		{
sl@0: 		TUint8 valLow = TheBinaryColumnData[j];
sl@0: 		TUint8 valHigh = TheBinaryColumnData[j + 1];
sl@0: 		TEST(valLow == (TUint8)(i & 0xFF));
sl@0: 		TEST(valHigh == (TUint8)(((TUint)i >> 8) & 0xFF));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlColumnReadStream::ColumnText()" OOM test
sl@0: void StmtColumnTextStreamL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	RSqlColumnReadStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	TInt err = strm.ColumnText(aStmt, 3);
sl@0: 	User::LeaveIfError(err);
sl@0: 	strm.ReadL(TheTextColumnData, KLongColumnSize);
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	for(TInt i=0;i<KLongColumnSize;++i)
sl@0: 		{
sl@0: 		TEST(TheTextColumnData[i] == (TUint16)i);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"RSqlParamWriteStream::BindBinary()" OOM test
sl@0: void StmtParamBinaryStreamL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	for(TInt i=0;i<KLongParameterSize;++i)
sl@0: 		{
sl@0: 		TheTextColumnData[i] = (TUint16)i;
sl@0: 		}
sl@0: 
sl@0: 	RSqlParamWriteStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	TInt err = strm.BindBinary(aStmt, 3);
sl@0: 	User::LeaveIfError(err);
sl@0: 	strm.WriteL((TUint8*)TheTextColumnData, KLongColumnSize * sizeof(TUint16));
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	}
sl@0: 
sl@0: //"RSqlParamWriteStream::BindText()" OOM test
sl@0: void StmtParamTextStreamL(RSqlStatement& aStmt)
sl@0: 	{
sl@0: 	for(TInt i=0;i<KLongParameterSize;++i)
sl@0: 		{
sl@0: 		TheTextColumnData[i] = (TUint16)i;
sl@0: 		}
sl@0: 
sl@0: 	RSqlParamWriteStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	TInt err = strm.BindText(aStmt, 3);
sl@0: 	User::LeaveIfError(err);
sl@0: 	strm.WriteL(TheTextColumnData, KLongColumnSize);
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1618
sl@0: @SYMTestCaseDesc		RSqlStatement methods OOM tests
sl@0: 						Precondition: the database exists, opened, some record(s) inserted.
sl@0: 						The test calls the given as an argument function while simulating OOM failures
sl@0: 						and checks that there are no memory and resource leaks.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlStatement methods OOM tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */
sl@0: void DoStmtOomTestL(TStmtFuncPtrL aStmtPrepareFuncPtrL, TStmtFuncPtr2L aStmtTestFuncPtrL, const TDesC& aDbFileName, TDbType aDbType)
sl@0: 	{
sl@0: 	//This is not really an OOM test, because:
sl@0: 	//(A) The test forces the server to simulate heap failure on determied allocation step
sl@0: 	//(B) SQL server counts only the number of active statement and stream objects, the allocated memory cells
sl@0: 	//    are not counted.
sl@0: 	//    The reason that the allocated memory cells are not counted and in case of OOM failure - checked is
sl@0: 	//    because the SQL server may make some per-connection persistent memory allocations (cache pages, etc.)
sl@0: 	//    which will not be deallocated when the statement object is closed.
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1618 RSqlStatement - OOM test"));
sl@0: 	RSqlSecurityPolicy securityPolicy;
sl@0: 	CreateTestSecurityPolicy(securityPolicy);
sl@0: 	for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 		{
sl@0: 		RSqlDatabase::Delete(aDbFileName);
sl@0: 		RSqlDatabase db;
sl@0: 		TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		err = db.Exec(KSqlDbString);
sl@0: 		TEST(err >= 0);
sl@0: 		err = db.Exec(KSqlDbString2);
sl@0: 		TEST(err >= 0);
sl@0: 
sl@0: 		err = KErrNoMemory;
sl@0: 		const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
sl@0: 		TInt allocationNo = 0;
sl@0: 		TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.
sl@0: 		while(allocationNo < KMaxAllocation)
sl@0: 			{
sl@0: 			MarkHandles();
sl@0: 			MarkAllocatedCells();
sl@0: 
sl@0: 			__UHEAP_MARK;
sl@0: 
sl@0: 	    	RSqlStatement stmt;
sl@0: 			TRAP(err, (*aStmtPrepareFuncPtrL)(db, stmt));
sl@0: 			TEST2(err, KErrNone);
sl@0: 
sl@0: 			SetHeapFailure(TheOomTestType[i], ++allocationNo);
sl@0: 
sl@0: 			TRAP(err, (*aStmtTestFuncPtrL)(stmt));
sl@0: 
sl@0: 			//ResetHeapFailure() has to be called before stmt.Close() because,
sl@0: 			//otherwise it will panic the server (the server resource count, marked by
sl@0: 			//SetHeapFailure() call, is 1 (there is one prepared statement))
sl@0: 			ResetHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 			stmt.Close();
sl@0: 
sl@0: 			if(err != KErrNoMemory)
sl@0: 				{
sl@0: 				TEST2(err, KErrNone);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				failingAllocationNo = allocationNo;	
sl@0: 				}
sl@0: 
sl@0: 			__UHEAP_MARKEND;
sl@0: 
sl@0: 			CheckAllocatedCells();
sl@0: 			CheckHandles();
sl@0: 			}
sl@0: 
sl@0: 		db.Close();
sl@0: 		TEST2(err, KErrNone);
sl@0: 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
sl@0: 		}
sl@0: 	//Delete the database file
sl@0: 	RSqlDatabase::Delete(aDbFileName);
sl@0: 	securityPolicy.Close();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////               RSqlBlobReadStream, RSqlBlobWriteStream - OOM tests          /////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //RSqlBlobReadStream, RSqlBlobWriteStream - OOM test preparation.
sl@0: void ExecInsertBlobL(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	_LIT8(KSqlString1, "CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, Fld4 TEXT, Fld5 LONGBLOB)");
sl@0: 	TInt err = aDb.Exec(KSqlString1);
sl@0: 	User::LeaveIfError(err);
sl@0: 	_LIT8(KSqlString2, "INSERT INTO BBB(fld1, fld2, fld3, fld4, fld5) VALUES(10, 100, 100.001, 'AAA', x'");
sl@0: 	TheSqlBuf.Copy(KSqlString2);
sl@0: 	for(TInt i=0;i<KBlobStrLen;++i)	
sl@0: 		{
sl@0: 		TheSqlBuf.Append(_L8("A5"));
sl@0: 		}
sl@0: 	TheSqlBuf.Append(_L8("')"));
sl@0: 	err = aDb.Exec(TheSqlBuf);
sl@0: 	User::LeaveIfError(err);
sl@0: 	}
sl@0: 
sl@0: //"RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL()" OOM test
sl@0: void BlobReadStreamOpenL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	RSqlBlobReadStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	if(aAttachDbName.Length() > 0)
sl@0: 		{
sl@0: 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
sl@0: 		}
sl@0: 	const TInt KReadOpCnt = 8;
sl@0: 	for(TInt j=0;j<KReadOpCnt;++j)
sl@0: 		{
sl@0: 		strm.ReadL(TheSqlBuf, KBlobLen / KReadOpCnt);
sl@0: 		TEST2(TheSqlBuf.Length(), (KBlobLen / KReadOpCnt));
sl@0: 		for(TInt i=0;i<(KBlobLen / KReadOpCnt);++i)
sl@0: 			{
sl@0: 			TUint8 val = TheSqlBuf[i];
sl@0: 			TEST2(val, 0xA5);
sl@0: 			}
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	}
sl@0: 
sl@0: //"RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL()" OOM test
sl@0: void BlobReadStreamSizeL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	RSqlBlobReadStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	if(aAttachDbName.Length() > 0)
sl@0: 		{
sl@0: 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
sl@0: 		}
sl@0: 	TInt size = strm.SizeL();	
sl@0: 	TEST2(size, KBlobLen);
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	}
sl@0: 
sl@0: //"RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL()" OOM test
sl@0: void BlobWriteStreamOpenL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	RSqlBlobWriteStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	if(aAttachDbName.Length() > 0)
sl@0: 		{
sl@0: 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
sl@0: 		}
sl@0: 	const TInt KWriteOpCnt = 8;
sl@0: 	TheSqlBuf.SetLength(KBlobLen / KWriteOpCnt);
sl@0: 	TheSqlBuf.Fill(TChar('Z'));
sl@0: 	for(TInt j=0;j<KWriteOpCnt;++j)
sl@0: 		{
sl@0: 		strm.WriteL(TheSqlBuf, KBlobLen / KWriteOpCnt);
sl@0: 		}
sl@0: 	strm.CommitL();		
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	}
sl@0: 
sl@0: //"RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL()" OOM test
sl@0: void BlobWriteStreamSizeL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	RSqlBlobWriteStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	if(aAttachDbName.Length() > 0)
sl@0: 		{
sl@0: 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		strm.OpenL(aDb, _L("BBB"), _L("fld5"), 1);
sl@0: 		}
sl@0: 	TInt size = strm.SizeL();	
sl@0: 	TEST2(size, KBlobLen);
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	}
sl@0: 	
sl@0: //"TSqlBlob::GetLC()" OOM test
sl@0: void BlobWholeGet1L(RSqlDatabase& aDb, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	HBufC8* buf = NULL;
sl@0: 	if(aAttachDbName.Length() > 0)
sl@0: 		{
sl@0: 		buf = TSqlBlob::GetLC(aDb, _L("BBB"), _L("fld5"), 1, aAttachDbName);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		buf = TSqlBlob::GetLC(aDb, _L("BBB"), _L("fld5"), 1);
sl@0: 		}
sl@0: 	TEST(buf->Length() == KBlobStrLen);
sl@0: 	CleanupStack::PopAndDestroy(buf);
sl@0: 	}
sl@0: 	
sl@0: //"TSqlBlob::Get()" OOM test
sl@0: void BlobWholeGet2L(RSqlDatabase& aDb, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	if(aAttachDbName.Length() > 0)
sl@0: 		{
sl@0: 		TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf2, 1, aAttachDbName);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf2, 1);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //"TSqlBlob::SetL()" OOM test
sl@0: void BlobWholeSetL(RSqlDatabase& aDb, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	if(aAttachDbName.Length() > 0)
sl@0: 		{
sl@0: 		TSqlBlob::SetL(aDb, _L("BBB"), _L("fld5"), TheSqlBuf, 1, aAttachDbName);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TSqlBlob::Get(aDb, _L("BBB"), _L("fld5"), TheSqlBuf, 1);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4091
sl@0: @SYMTestCaseDesc		RSqlBlobReadStream, RSqlBlobWriteStream methods OOM tests
sl@0: 						Precondition: the database exists, opened, some record(s) inserted.
sl@0: 						The test calls the given as an argument function while simulating OOM failures
sl@0: 						and checks that there are no memory and resource leaks.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlBlobReadStream, RSqlBlobWriteStream methods OOM tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ10410
sl@0:                         REQ10411
sl@0:                         REQ10418
sl@0: */
sl@0: void DoBlobOomTestL(TBlobPrepareFuncPtrL aBlobPrepareFuncPtrL, TBlobTestFuncPtrL aBlobTestFuncPtrL, 
sl@0: 					const TDesC& aDbFileName, TDbType aDbType, TBool aAttachDb = EFalse)
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4091 RSqlBlobReadStream, RSqlBlobWriteStream - OOM test"));
sl@0: 	RSqlSecurityPolicy securityPolicy;
sl@0: 	CreateTestSecurityPolicy(securityPolicy);
sl@0: 	for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 		{
sl@0: 		RSqlDatabase::Delete(aDbFileName);
sl@0: 		RSqlDatabase db;
sl@0: 		TInt err = aDbType == ESecureDb ? db.Create(aDbFileName, securityPolicy) : db.Create(aDbFileName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TRAP(err, (*aBlobPrepareFuncPtrL)(db));
sl@0: 		TEST2(err, KErrNone);
sl@0: 		_LIT(KAttachDbName, "AttachDb");
sl@0: 		if(aAttachDb)
sl@0: 			{
sl@0: 			err = db.Attach(aDbFileName, KAttachDbName);
sl@0: 			TEST2(err, KErrNone);
sl@0: 			}
sl@0: 
sl@0: 		err = KErrNoMemory;
sl@0: 		const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KBlobOomTestAllocLimitServer : KBlobOomTestAllocLimitClient;
sl@0: 		TInt allocationNo = 0;
sl@0: 		TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.
sl@0: 		while(allocationNo < KMaxAllocation)
sl@0: 			{
sl@0: 			MarkHandles();
sl@0: 			MarkAllocatedCells();
sl@0: 
sl@0: 			__UHEAP_MARK;
sl@0: 
sl@0: 			SetHeapFailure(TheOomTestType[i], ++allocationNo);
sl@0: 			if(aAttachDb)
sl@0: 				{
sl@0: 				TRAP(err, (*aBlobTestFuncPtrL)(db, KAttachDbName));
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				TRAP(err, (*aBlobTestFuncPtrL)(db, KNullDesC));
sl@0: 				}
sl@0: 
sl@0: 			ResetHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 			if(err != KErrNoMemory)
sl@0: 				{
sl@0: 				if(err != KErrNone)
sl@0: 					{
sl@0: 					TPtrC errmsg = db.LastErrorMessage();
sl@0: 					if(errmsg.Length() > 0)
sl@0: 						{
sl@0: 						TheTest.Printf(_L("\r\n@@@ error %d, error message: %S\r\n"), err, &errmsg);	
sl@0: 						}
sl@0: 					}
sl@0: 				TEST2(err, KErrNone);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				failingAllocationNo = allocationNo;
sl@0: 				}				
sl@0: 
sl@0: 			__UHEAP_MARKEND;
sl@0: 
sl@0: 			CheckAllocatedCells();
sl@0: 			CheckHandles();
sl@0: 			}
sl@0: 		TEST2(err, KErrNone);
sl@0: 
sl@0: 		if(aAttachDb)
sl@0: 			{
sl@0: 			(void)db.Detach(KAttachDbName);
sl@0: 			}
sl@0: 
sl@0: 		db.Close();
sl@0: 		err = RSqlDatabase::Delete(aDbFileName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
sl@0: 		}
sl@0: 	securityPolicy.Close();
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectInt_8L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TInt val = query.SelectIntL(_L8("SELECT F1 FROM A WHERE F3 < 0"));
sl@0: 	TEST2(val, 2);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectInt64_8L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TInt64 val = query.SelectInt64L(_L8("SELECT F2 FROM A WHERE F1 = 1"));
sl@0: 	TEST2(val, 10000000000LL);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectReal_8L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TReal val = query.SelectRealL(_L8("SELECT F3 FROM A WHERE F1 = 1"));
sl@0: 	TEST(val > 2.0 && val < 3.0);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectText_8L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TBuf<20> buf;
sl@0: 	TInt err = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), buf);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	_LIT(KText, "NAME1234567890");
sl@0: 	TEST(buf == KText);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectBinary_8L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TBuf8<20> buf;
sl@0: 	TInt err = query.SelectBinaryL(_L8("SELECT F5 FROM A WHERE F1 = 1"), buf);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST(buf.Length() == 0);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectInt_16L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TInt val = query.SelectIntL(_L16("SELECT F1 FROM A WHERE F3 < 0"));
sl@0: 	TEST2(val, 2);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectInt64_16L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TInt64 val = query.SelectInt64L(_L16("SELECT F2 FROM A WHERE F1 = 1"));
sl@0: 	TEST2(val, 10000000000LL);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectReal_16L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TReal val = query.SelectRealL(_L16("SELECT F3 FROM A WHERE F1 = 1"));
sl@0: 	TEST(val > 2.0 && val < 3.0);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectText_16L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TBuf<20> buf;
sl@0: 	TInt err = query.SelectTextL(_L16("SELECT F4 FROM A WHERE F1 = 1"), buf);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	_LIT(KText, "NAME1234567890");
sl@0: 	TEST(buf == KText);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectBinary_16L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	TBuf8<20> buf;
sl@0: 	TInt err = query.SelectBinaryL(_L16("SELECT F5 FROM A WHERE F1 = 1"), buf);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST(buf.Length() == 0);
sl@0: 	}
sl@0: 
sl@0: void ScalarFullSelectText2_8L(RSqlDatabase& aDb)
sl@0: 	{
sl@0: 	TSqlScalarFullSelectQuery query(aDb);
sl@0: 	HBufC* buf = HBufC::NewLC(8);
sl@0: 	TPtr name = buf->Des();
sl@0: 	TInt rc = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), name);
sl@0: 	TEST(rc >= 0); //the function may return only non-negative values
sl@0: 	if(rc > 0)
sl@0: 		{
sl@0: 		buf = buf->ReAllocL(rc);
sl@0: 		CleanupStack::Pop();
sl@0: 		CleanupStack::PushL(buf);
sl@0: 		name.Set(buf->Des());
sl@0: 		rc = query.SelectTextL(_L8("SELECT F4 FROM A WHERE F1 = 1"), name);
sl@0: 		TEST(rc == 0);
sl@0: 		_LIT(KText, "NAME1234567890");
sl@0: 		TEST(name == KText);
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(buf);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1811
sl@0: @SYMTestCaseDesc		TSqlScalarFullSelectQuery functions OOM test
sl@0: 						Precondition: the database exists.
sl@0: 						The test simulates OOM failures while calling TSqlScalarFullSelectQuery functions
sl@0: 						and checks that there are no memory and resource leaks.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			TSqlScalarFullSelectQuery methods OOM tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */
sl@0: void DoFullSelectOomTest(TScalarFullSelectFuncPtrL aTestFunctionPtrL)
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1811 TSqlScalarFullSelectQuery - OOM test"));
sl@0: 	//Create test database
sl@0: 	RSqlDatabase db;
sl@0: 	TInt err = db.Create(KTestDb);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = db.Exec(_L("CREATE TABLE A(F1 INTEGER, F2 INTEGER, F3 FLOAT, F4 TEXT, F5 BLOB)"));
sl@0: 	TEST(err >= 0);
sl@0: 	err = db.Exec(_L("INSERT INTO A(F1, F2, F3, F4, F5) VALUES(1, 10000000000, 2.54, 'NAME1234567890', NULL)"));
sl@0: 	TEST2(err, 1);
sl@0: 	err = db.Exec(_L("INSERT INTO A(F1, F2, F3, F4) VALUES(2, 200, -1.11, 'ADDRESS')"));
sl@0: 	TEST2(err, 1);
sl@0: 	db.Close();
sl@0: 	//OOM test loop
sl@0: 	for(TInt i=0;i<(TInt)(sizeof(TheOomTestType)/sizeof(TheOomTestType[0]));++i)
sl@0: 		{
sl@0: 		err = KErrNoMemory;
sl@0: 		const TInt KMaxAllocation = TheOomTestType[i] == EServerSideTest ? KStmtOomTestAllocLimitServer : KStmtOomTestAllocLimitClient;
sl@0: 		TInt allocationNo = 0;
sl@0: 		TInt failingAllocationNo = 0;//the real exit point of the OOM test. allocationNo is set KMaxAllocation times.
sl@0: 		while(allocationNo < KMaxAllocation)
sl@0: 			{
sl@0: 			MarkHandles();
sl@0: 			MarkAllocatedCells();
sl@0: 
sl@0: 			__UHEAP_MARK;
sl@0: 
sl@0: 			if(TheOomTestType[i] == EServerSideTest)
sl@0: 				{//We will delay the heap failure simulation, until the database is opened
sl@0: 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo, ETrue);
sl@0: 				}
sl@0: 
sl@0: 			err = db.Open(KTestDb);
sl@0: 			TEST2(err, KErrNone);
sl@0: 
sl@0: 			if(TheOomTestType[i] == EClientSideTest)
sl@0: 				{
sl@0: 				SetDbHeapFailure(TheOomTestType[i], ++allocationNo);
sl@0: 				}
sl@0: 
sl@0: 			TRAP(err, (*aTestFunctionPtrL)(db));
sl@0: 			db.Close();
sl@0: 			if(err != KErrNoMemory)
sl@0: 				{
sl@0: 				TEST2(err, KErrNone);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				failingAllocationNo = allocationNo;	
sl@0: 				}
sl@0: 
sl@0: 			ResetDbHeapFailure(TheOomTestType[i]);
sl@0: 
sl@0: 			__UHEAP_MARKEND;
sl@0: 
sl@0: 			CheckAllocatedCells();
sl@0: 			CheckHandles();
sl@0: 			}
sl@0: 		TEST2(err, KErrNone);
sl@0: 		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);
sl@0: 		}
sl@0: 	//Delete the database file
sl@0: 	RSqlDatabase::Delete(KTestDb);
sl@0: 	}
sl@0: 
sl@0: //RSqlStatement OOM tests
sl@0: void StmtOomTestsL()
sl@0: 	{
sl@0: 	const TInt KTestCnt = 2;
sl@0: 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};
sl@0: 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
sl@0: 
sl@0: 	for(TInt i=0;i<KTestCnt;++i)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Prepare(), 8-bit SQL\r\n"));
sl@0: 		DoStmtPrepareOomTestL(&PrepareStmt8L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::PrepareL(), 8-bit SQL\r\n"));
sl@0: 		DoStmtPrepareOomTestL(&PrepareStmt8_2L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Prepare(), 16-bit SQL\r\n"));
sl@0: 		DoStmtPrepareOomTestL(&PrepareStmt16L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::PrepareL(), 16-bit SQL\r\n"));
sl@0: 		DoStmtPrepareOomTestL(&PrepareStmt16_2L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Reset(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareStmt8L, &ResetStmtL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Reset(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareStmt16L, &ResetStmtL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Exec(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertStmt8L, &ExecStmtL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Exec(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertStmt16L, &ExecStmtL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Next(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareStmt8L, &NextStmtL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Next(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareStmt16L, &NextStmtL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ParameterIndex(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParameterIndexL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ParameterIndex(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParameterIndexL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ParameterName(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParameterNameL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ParameterName(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParameterNameL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ParamName(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamNameL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ParamName(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamNameL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnIndex(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareStmt8L, &StmtColumnIndexL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnIndex(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareStmt16L, &StmtColumnIndexL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnType(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnTypeL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnType(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnTypeL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnSize(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnSizeL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnSize(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnSizeL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnName(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareMoveStmt8L, &StmtColumnNameL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnName(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareMoveStmt16L, &StmtColumnNameL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindNull(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindNullL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindNull(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindNullL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindInt(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindIntL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindInt(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindIntL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindInt64(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindInt64L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindInt64(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindInt64L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindReal(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindRealL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindReal(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindRealL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindText(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindTextL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindText(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindTextL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindBinary(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindBinaryL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindBinary(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindBinaryL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindZeroBlob(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtBindZeroBlobL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::BindZeroBlob(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtBindZeroBlobL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::IsNull(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtIsNullColumnL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::IsNull(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtIsNullColumnL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnInt(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnIntL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnInt(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnIntL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnInt64(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnInt64L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnInt64(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnInt64L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnReal(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnRealL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnReal(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnRealL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnTextL(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText1L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnTextL(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText1L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnText()-1, 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText2L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnText()-1, 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText2L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnText()-2, 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnText3L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnText()-2, 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnText3L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnBinaryL(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary1L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnBinaryL(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary1L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-1, 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary2L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-1, 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary2L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-2, 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinary3L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnBinary()-2, 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinary3L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnCount(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnCount, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::ColumnCount(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnCount, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::DeclaredColumnType(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtDeclaredColumnTypeL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::DeclaredColumnType(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtDeclaredColumnTypeL, dbFileName[i], dbType[i]);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //RSqlStatement - negative OOM tests
sl@0: void StmtOomNegativeTestsL()
sl@0: 	{
sl@0: 	const TInt KTestCnt = 2;
sl@0: 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};
sl@0: 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
sl@0: 
sl@0: 	for(TInt i=0;i<KTestCnt;++i)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Prepare(), 8-bit SQL\r\n"));
sl@0: 		DoStmtPrepareOomTestL(&PrepareBadStmt8L, dbFileName[i], dbType[i], KSqlErrGeneral);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlStatement::Prepare(), 16-bit SQL\r\n"));
sl@0: 		DoStmtPrepareOomTestL(&PrepareBadStmt16L, dbFileName[i], dbType[i], KSqlErrGeneral);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //RSqlColumnReadStream OOM tests
sl@0: void ColumnReadStreamOomTestsL()
sl@0: 	{
sl@0: 	const TInt KTestCnt = 2;
sl@0: 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};
sl@0: 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
sl@0: 
sl@0: 	for(TInt i=0;i<KTestCnt;++i)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===RSqlColumnReadStream::ColumnBinary(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnBinaryStreamL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlColumnReadStream::ColumnBinary(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnBinaryStreamL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlColumnReadStream::ColumnText(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt8L, &StmtColumnTextStreamL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlColumnReadStream::ColumnText(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&ExecInsertNextStmt16L, &StmtColumnTextStreamL, dbFileName[i], dbType[i]);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //RSqlParamWriteStream OOM tests
sl@0: void ParamWriteStreamOomTestsL()
sl@0: 	{
sl@0: 	const TInt KTestCnt = 2;
sl@0: 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};
sl@0: 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
sl@0: 
sl@0: 	for(TInt i=0;i<KTestCnt;++i)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===RSqlParamWriteStream::BindBinary(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamBinaryStreamL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlParamWriteStream::BindBinary(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamBinaryStreamL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlParamWriteStream::BindText(), 8-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt8L, &StmtParamTextStreamL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlParamWriteStream::BindText(), 16-bit SQL\r\n"));
sl@0: 		DoStmtOomTestL(&PrepareInsertPrmStmt16L, &StmtParamTextStreamL, dbFileName[i], dbType[i]);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //TSqlScalarFullSelectQuery OOM tests
sl@0: void ScalarFullSelectQueryOomTestsL()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectIntL(), 8-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectInt_8L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectInt64L(), 8-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectInt64_8L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectRealL(), 8-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectReal_8L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 8-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectText_8L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectBinaryL(), 8-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectBinary_8L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectIntL(), 16-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectInt_16L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectInt64L(), 16-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectInt64_16L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectRealL(), 16-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectReal_16L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 16-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectText_16L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectBinaryL(), 16-bit SQL\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectBinary_16L);
sl@0: 
sl@0: 	TheTest.Printf(_L("===TSqlScalarFullSelectQuery::SelectTextL(), 8-bit SQL, small buffer\r\n"));
sl@0: 	DoFullSelectOomTest(&ScalarFullSelectText2_8L);
sl@0: 	}
sl@0: 
sl@0: void BlobReadStreamOomTestsL()
sl@0: 	{
sl@0: 	const TInt KTestCnt = 2;
sl@0: 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};
sl@0: 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
sl@0: 
sl@0: 	for(TInt i=0;i<KTestCnt;++i)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL()\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamOpenL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::ReadL() + attached database\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamOpenL, dbFileName[i], dbType[i], ETrue);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL()\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamSizeL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlBlobReadStream::OpenL()/RSqlBlobReadStream::SizeL() + attached database\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobReadStreamSizeL, dbFileName[i], dbType[i], ETrue);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void BlobWriteStreamOomTestsL()
sl@0: 	{
sl@0: 	const TInt KTestCnt = 2;
sl@0: 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};
sl@0: 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
sl@0: 
sl@0: 	for(TInt i=0;i<KTestCnt;++i)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL()\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamOpenL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::WriteL() + attached database\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamOpenL, dbFileName[i], dbType[i], ETrue);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL()\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamSizeL, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===RSqlBlobWriteStream::OpenL()/RSqlBlobWriteStream::SizeL() + attached database\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWriteStreamSizeL, dbFileName[i], dbType[i], ETrue);
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: void BlobWholeOomTestsL()
sl@0: 	{
sl@0: 	const TInt KTestCnt = 2;
sl@0: 	const TPtrC dbFileName[KTestCnt] = {KTestDb(), 	KSecureTestDb()};
sl@0: 	TDbType dbType[KTestCnt] = {ENonSecureDb, ESecureDb};
sl@0: 
sl@0: 	for(TInt i=0;i<KTestCnt;++i)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===TSqlBlob::GetLC()\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeGet1L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===TSqlBlob::Get()\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeGet2L, dbFileName[i], dbType[i]);
sl@0: 
sl@0: 		TheTest.Printf(_L("===TSqlBlob::SetL()\r\n"));
sl@0: 		DoBlobOomTestL(&ExecInsertBlobL, &BlobWholeSetL, dbFileName[i], dbType[i]);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void DoTestsL()
sl@0: 	{
sl@0: 	TheTest.Start(_L("SQL OOM tests - 2"));
sl@0: 	
sl@0: 	StmtOomTestsL();
sl@0: 
sl@0: 	StmtOomNegativeTestsL();
sl@0: 
sl@0: 	ColumnReadStreamOomTestsL();
sl@0: 
sl@0: 	ParamWriteStreamOomTestsL();
sl@0: 
sl@0: 	ScalarFullSelectQueryOomTestsL();
sl@0: 
sl@0: 	BlobReadStreamOomTestsL();
sl@0: 
sl@0: 	BlobWriteStreamOomTestsL();
sl@0: 	
sl@0: 	BlobWholeOomTestsL();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 
sl@0: 	__UHEAP_MARK;
sl@0: 
sl@0: 	CreateTestDir();
sl@0: 	DeleteTestFiles();
sl@0: 
sl@0: 	TRAPD(err, DoTestsL());
sl@0: 	DeleteTestFiles();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 
sl@0: 	delete tc;
sl@0: 
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}