// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "t_sqloom.h"

RTest TheTest(_L("t_sqloom2 test"));

const TInt KSqlBufMaxLen = 16 * 1024;

const TInt KBlobStrLen = KSqlBufMaxLen / 2 - 100;

const TInt KBlobLen = KBlobStrLen;

TBuf8<KSqlBufMaxLen> TheSqlBuf;

TBuf8<KBlobStrLen> TheSqlBuf2;

///////////////////////////////////////////////////////////////////////////////////////

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

///////////////////////////////////////////////////////////////////////////////////////

_LIT8(KSqlDbString, "BEGIN;\

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

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

                     COMMIT;");

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

const TInt KLongColumnSize = 3013;

const TInt KLongParameterSize = 4501;

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

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

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

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

void PrepareStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

	_LIT8(KSqlString, "SELECT * FROM BBB");

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

	User::LeaveIfError(err);

	}

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

void PrepareStmt8_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

	_LIT8(KSqlString, "SELECT * FROM BBB");

	aStmt.PrepareL(aDb, KSqlString);

	}

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

void PrepareBadStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

	_LIT8(KSqlString, "SELECT123 * FROM BBB");

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

	User::LeaveIfError(err);

	}

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

void PrepareMoveStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

	_LIT8(KSqlString, "SELECT * FROM BBB");

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

	if(err == KErrNone)

		{

		err = aStmt.Next();

		if(err == KSqlAtRow)

			{

			err = KErrNone;

			}

		}

	User::LeaveIfError(err);

	}

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

void PrepareInsertStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

	User::LeaveIfError(err);

	}

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

void ExecInsertNextStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

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

	if(err == KErrNone)

		{

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

			{

			TheTextColumnData[i] = (TUint16)i;

			}

		const TPtrC textVal(TheTextColumnData, KLongColumnSize);

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

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

		if(err == KErrNone)

			{

			err = aStmt.BindBinary(1, binVal);

			}

		if(err == KErrNone)

			{

			err = aStmt.Exec();

			}

		}

	if(err >= 0)

		{

		aStmt.Close();

		err = aStmt.Prepare(aDb, KSqlString2);

		if(err == KErrNone)

			{

			err = aStmt.Next();

			}

		}

	User::LeaveIfError(err);

	}

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

void PrepareInsertPrmStmt8L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

	User::LeaveIfError(err);

	}

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

void PrepareStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

	User::LeaveIfError(err);

	}

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

void PrepareStmt16_2L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

	aStmt.PrepareL(aDb, KSqlString);

	}

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

void PrepareBadStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

	User::LeaveIfError(err);

	}

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

void PrepareMoveStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

	if(err == KErrNone)

		{

		err = aStmt.Next();

		if(err == KSqlAtRow)

			{

			err = KErrNone;

			}

		}

	User::LeaveIfError(err);

	}

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

void PrepareInsertStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

	User::LeaveIfError(err);

	}

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

void ExecInsertNextStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

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

	if(err == KErrNone)

		{

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

			{

			TheTextColumnData[i] = (TUint16)i;

			}

		const TPtrC textVal(TheTextColumnData, KLongColumnSize);

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

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

		if(err == KErrNone)

			{

			err = aStmt.BindBinary(1, binVal);

			}

		if(err == KErrNone)

			{

			err = aStmt.Exec();

			}

		}

	if(err >= 0)

		{

		aStmt.Close();

		err = aStmt.Prepare(aDb, KSqlString2);

		if(err == KErrNone)

			{

			err = aStmt.Next();

			}

		}

	User::LeaveIfError(err);

	}

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

void PrepareInsertPrmStmt16L(RSqlDatabase& aDb, RSqlStatement& aStmt)

	{

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

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

	User::LeaveIfError(err);

	}

/**

@SYMTestCaseID			SYSLIB-SQL-CT-1617

@SYMTestCaseDesc		RSqlStatement::Prepare() OOM test

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

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

						and checks that there are no memory and resource leaks.

@SYMTestPriority		High

@SYMTestActions			RSqlStatement::Prepare() OOM test

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ5792

                        REQ5793

*/

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

	{

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

	RSqlSecurityPolicy securityPolicy;

	CreateTestSecurityPolicy(securityPolicy);

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

		{

		RSqlDatabase::Delete(aDbFileName);

		RSqlDatabase db;

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

		TEST2(err, KErrNone);

		err = db.Exec(KSqlDbString);

		TEST(err >= 0);

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

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

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

		//session gets closed.

		RSqlStatement dummyStmt;

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

		TEST2(err, KErrNone);

		dummyStmt.Close();

		err = KErrNoMemory;

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

		TInt allocationNo = 0;

		TInt failingAllocationNo = 0;

		while(allocationNo < KMaxAllocation)

			{

			MarkHandles();

			MarkAllocatedCells();

			__UHEAP_MARK;

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

	    	RSqlStatement stmt;

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

			stmt.Close();

			if(err != KErrNoMemory)

				{

				TEST2(err, aExpectedError);

				}

			else

				{

				failingAllocationNo = allocationNo;	

				}

			ResetHeapFailure(TheOomTestType[i]);

			__UHEAP_MARKEND;

			CheckAllocatedCells();

			CheckHandles();

			}

		db.Close();

		TEST2(err, aExpectedError);

		PrintEndOfOomTest(TheOomTestType[i], failingAllocationNo);

		}

	//Delete the database file

	RSqlDatabase::Delete(aDbFileName);

	securityPolicy.Close();

	}

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

void ResetStmtL(RSqlStatement& aStmt)

	{

	TInt err = aStmt.Next();

	if(err == KErrNone)

		{

		err = aStmt.Reset();

		}

	User::LeaveIfError(err);

	}

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

void ExecStmtL(RSqlStatement& aStmt)

	{

	TInt err = aStmt.Exec();

	User::LeaveIfError(err);

	}

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

void NextStmtL(RSqlStatement& aStmt)

	{

	TInt err = aStmt.Next();

	if(err == KErrNone)

		{

		err = aStmt.Next();

		}

	User::LeaveIfError(err);

	}

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

void StmtParameterIndexL(RSqlStatement& aStmt)

	{

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

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

		{

		err = KErrNone;

		}

	User::LeaveIfError(err);

	}

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

void StmtParameterNameL(RSqlStatement& aStmt)

	{

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

	TPtrC paramName;

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

	User::LeaveIfError(err);

	}

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

void StmtParamNameL(RSqlStatement& aStmt)

	{

	TPtrC paramName;

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

	User::LeaveIfError(err);

	}

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

void StmtColumnIndexL(RSqlStatement& aStmt)

	{

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

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

		{

		err = KErrNone;

		}

	User::LeaveIfError(err);

	}

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

void StmtColumnNameL(RSqlStatement& aStmt)

	{

	//_LIT(KExpected, "fLd3");

	TPtrC colName;

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

	User::LeaveIfError(err);

	}

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

void StmtColumnTypeL(RSqlStatement& aStmt)

	{

	TSqlColumnType coltype = aStmt.ColumnType(2);

	TEST(coltype == ESqlReal);

	}

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

void StmtColumnSizeL(RSqlStatement& aStmt)

	{

	TInt colsize = aStmt.ColumnSize(2);

	TEST(colsize == sizeof(TReal));

	}

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

void StmtBindNullL(RSqlStatement& aStmt)

	{

	TInt err = aStmt.BindNull(1);

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

	if(err == KErrNone)

		{

		err = aStmt.Exec();

		}

	User::LeaveIfError(err);

	}

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

void StmtBindIntL(RSqlStatement& aStmt)

	{

	TInt val = 184;

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

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

	if(err == KErrNone)

		{

		err = aStmt.Exec();

		}

	User::LeaveIfError(err);

	}

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

void StmtBindInt64L(RSqlStatement& aStmt)

	{

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

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

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

	if(err == KErrNone)

		{

		err = aStmt.Exec();

		}

	User::LeaveIfError(err);

	}

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

void StmtBindRealL(RSqlStatement& aStmt)

	{

	TReal val = 25.2423;

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

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

	if(err == KErrNone)

		{

		err = aStmt.Exec();

		}

	User::LeaveIfError(err);

	}

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

void StmtBindTextL(RSqlStatement& aStmt)

	{

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

		{

		TheTextColumnData[i] = (TUint16)i;

		}

	const TPtrC val(TheTextColumnData, KLongParameterSize);

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

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

	if(err == KErrNone)

		{

		err = aStmt.Exec();

		}

	User::LeaveIfError(err);

	}

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

void StmtBindBinaryL(RSqlStatement& aStmt)

	{

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

		{

		TheBinaryColumnData[i] = (TUint8)i;

		}

	const TPtrC8 val(TheBinaryColumnData, KLongParameterSize);

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

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

	if(err == KErrNone)

		{

		err = aStmt.Exec();

		}

	User::LeaveIfError(err);

	}

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

void StmtBindZeroBlobL(RSqlStatement& aStmt)

	{

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

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

	if(err == KErrNone)

		{

		err = aStmt.Exec();

		}

	User::LeaveIfError(err);

	}

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

void StmtIsNullColumnL(RSqlStatement& aStmt)

	{

	TBool rc = aStmt.IsNull(0);

	TEST(!rc);

	}

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

void StmtColumnIntL(RSqlStatement& aStmt)

	{

	TInt val = aStmt.ColumnInt(0);

	TEST(val == 10);

	}

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

void StmtColumnInt64L(RSqlStatement& aStmt)

	{

	TInt64 val = aStmt.ColumnInt64(1);

	TEST(val == 100);

	}

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

void StmtColumnRealL(RSqlStatement& aStmt)

	{

	TReal val = aStmt.ColumnReal(2);

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

	}

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

void StmtColumnText1L(RSqlStatement& aStmt)

	{

	TPtrC val = aStmt.ColumnTextL(3);

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

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

		{

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

		}