// Copyright (c) 2007-2010 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 <e32test.h>

 #include <e32math.h>

 #include <bautils.h>

 #include <s32buf.h>				//MStreamBuf

 #include <sqldb.h>

 #include "SqlResourceProfiler.h"

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

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

 RSqlDatabase TheDb;

 RSqlStatement TheStmt;

 _LIT(KTestDir, "c:\\test\\");

 _LIT(KTestDbName1, "c:\\test\\t_sqlapi2_1.db");

 _LIT(KTestDbName2, "c:\\private\\1111C1EF\\t_sqlapi2_2.db");//t_sqlapi2 app - private database

 _LIT(KDbInjectedName1, "DELETE FROM symbian_settings;c:\\test\\A.db");

 _LIT(KDbInjectedName2, "c:\\test\\A.db;DELETE FROM symbian_settings;");

 const TInt KBufLen = 8192;

 TBuf<KBufLen> TheBuf;

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

 void DeleteTestFiles()

 	{

 	TheStmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KDbInjectedName2);

 	(void)RSqlDatabase::Delete(KDbInjectedName1);

 	(void)RSqlDatabase::Delete(KTestDbName2);

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

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

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

 //Test macros and functions

 void Check(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		DeleteTestFiles();

 		TheTest(EFalse, aLine);

 		}

 	}

 void Check(TInt aValue, TInt aExpected, TInt aLine)

 	{

 	if(aValue != aExpected)

 		{

 		DeleteTestFiles();

 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

 		TheTest(EFalse, aLine);

 		}

 	}

 #define TEST(arg) ::Check((arg), __LINE__)

 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

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

 void CreateTestEnv()

     {

     RFs fs;

 	TInt err = fs.Connect();

 	TEST2(err, KErrNone);

 	err = fs.MkDir(KTestDir);

 	TEST(err == KErrNone || err == KErrAlreadyExists);

 	err = fs.CreatePrivatePath(EDriveC);

 	TEST(err == KErrNone || err == KErrAlreadyExists);

 	fs.Close();

 	}

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

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3512

 @SYMTestCaseDesc		RSqlStatement::ColumnCount() - SELECT statements test

 						The test creates a database with a table and then checks the ColumnCount()

 						return result for the following statements:

 						- select all columns;

 						- select a subset;

 						- select an expression;

 						- select a constant;

 						- multi-table select;

 						- select a function;

 						- select plus sub-query;

 @SYMTestPriority		High

 @SYMTestActions			RSqlStatement::ColumnCount() test

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ8035

 */

 void ColumnCountTest()

 	{

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	//Create table 1

 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT,Id2 INTEGER,Data BLOB)"));

 	TEST(err >= 0);

 	err = TheDb.Exec(_L("INSERT INTO A VALUES(1,'AAA',6234567890,x'11AAFD0C771188')"));

 	TEST2(err, 1);

 	//Select all columns (SELECT *)

 	err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));

 	TEST2(err, KErrNone);

 	TInt cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 4);

 	TheStmt.Close();

 	//Select all columns (SELECT a,b,c...)

 	err = TheStmt.Prepare(TheDb, _L("SELECT Id,Name,Id2,Data FROM A"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 4);

 	TheStmt.Close();

 	//Select column subset

 	err = TheStmt.Prepare(TheDb, _L("SELECT Id,Name,Data FROM A"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 3);

 	TheStmt.Close();

 	//Select column subset + expression

 	err = TheStmt.Prepare(TheDb, _L("SELECT Id,Id+Id2 FROM A"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 2);

 	TheStmt.Close();

 	//Select column subset + constant

 	err = TheStmt.Prepare(TheDb, _L("SELECT Id,Id2,345.78 FROM A"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 3);

 	TheStmt.Close();

 	//Select SQL function

 	err = TheStmt.Prepare(TheDb, _L("SELECT COUNT(*) FROM A"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 1);

 	TheStmt.Close();

 	//Create table 2

 	err = TheDb.Exec(_L("CREATE TABLE B(Id INTEGER, S INTEGER)"));

 	TEST(err >= 0);

 	err = TheDb.Exec(_L("INSERT INTO B VALUES(1,25)"));

 	TEST2(err, 1);

 	//Multitable select

 	err = TheStmt.Prepare(TheDb, _L("SELECT A.Id,B.S FROM A,B WHERE A.Id = B.Id"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 2);

 	TheStmt.Close();

 	//Select + Subquery

 	err = TheStmt.Prepare(TheDb, _L("SELECT Id FROM A WHERE (SELECT S FROM B WHERE A.Id = B.Id) > 10"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 1);

 	TheStmt.Close();

 	//Cleanup

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3513

 @SYMTestCaseDesc		RSqlStatement::ColumnCount() - DDL and DML statements test

 						The test creates a database with a table and then checks the ColumnCount() return result for

 						DML statements (INSERT/UPDATE/DELETE) and DDL statements (CREATE TABLE/INDEX, DROP TABLE?INDEX).

 						The column count for DML and DDL statements should be 0.

 @SYMTestPriority		High

 @SYMTestActions			RSqlStatement::ColumnCount() test

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ8035

 */

 void ColumnCountTest2()

 	{

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	//Create table

 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT,Id2 INTEGER,Data BLOB)"));

 	TEST(err >= 0);

 	err = TheDb.Exec(_L("INSERT INTO A VALUES(1,'AAA',6234567890,x'11AAFD0C771188')"));

 	TEST2(err, 1);

 	//INSERT statement

 	err = TheStmt.Prepare(TheDb, _L("INSERT INTO A(Id,Id2) VALUES(:P1,:P2)"));

 	TEST2(err, KErrNone);

 	TInt cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	TheStmt.Close();

 	//UPDATE statement

 	err = TheStmt.Prepare(TheDb, _L("UPDATE A SET Id2=100 WHERE Id=:P1"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	TheStmt.Close();

 	//DELETE statement

 	err = TheStmt.Prepare(TheDb, _L("DELETE FROM A WHERE Id=:P1"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	TheStmt.Close();

 	//CREATE TABLE statement

 	err = TheStmt.Prepare(TheDb, _L("CREATE TABLE B AS SELECT * FROM A"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	TheStmt.Close();

 	//DROP TABLE statement

 	err = TheStmt.Prepare(TheDb, _L("DROP TABLE A"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	TheStmt.Close();

 	//CREATE INDEX statement

 	err = TheStmt.Prepare(TheDb, _L("CREATE INDEX I ON A(Id)"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	err = TheStmt.Exec();

 	TEST(err >= 0);

 	TheStmt.Close();

 	//DROP INDEX statement

 	err = TheStmt.Prepare(TheDb, _L("DROP INDEX I"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	TheStmt.Close();

 	//CREATE TRIGGER statement

 	err = TheStmt.Prepare(TheDb,

 			_L("CREATE TRIGGER Trg BEFORE DELETE ON A \

 	             BEGIN \

 	                SELECT CASE WHEN ((SELECT Id2 FROM A WHERE A.Id = old.Id) > 0) \

 	                            THEN RAISE (ABORT, 'Id2 > 0') \

 	                END;\

 	             END;"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	TheStmt.Close();

 	//CREATE VIEW statement

 	err = TheStmt.Prepare(TheDb, _L("CREATE VIEW V AS SELECT * FROM A"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	err = TheStmt.Exec();

 	TEST(err >= 0);

 	TheStmt.Close();

 	//DROP VIEW statement

 	err = TheStmt.Prepare(TheDb, _L("DROP VIEW V"));

 	TEST2(err, KErrNone);

 	cnt = TheStmt.ColumnCount();

 	TEST2(cnt, 0);

 	TheStmt.Close();

 	//Cleanup

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3514

 @SYMTestCaseDesc		RSqlStatement::DeclaredColumnType() test

 						The test creates a database with a table and then checks the DeclaredColumnType() return result for:

 						- select all column from the table and check their types;

 						- multi-table select plus column type checks;

 						- select expression - the expected column type is ESqlInt;

 						- select constant - the expected column type is ESqlInt;

 @SYMTestPriority		High

 @SYMTestActions			RSqlStatement::ColumnCount() test

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ8035

 */

 void DeclaredColumnTypeTest()

 	{

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	const char* KColTypeNames[] =

 		{"INTEGER", "LONG INTEGER", "INT", "SHORT INT", "SMALL INT", "TINY INT", "SHORT", "INT64",

 		"TEXT", "LONGTEXT", "CLOB", "CHAR", "CHARACTER(20)", "LONG TEXT",

 		"BINARY", "LONG BINARY", "LONGBINARY", "BLOB", "LONGBLOB", "LONG BLOB",

 		"REAL", "FLOAT", "DOUBLE", "LONG DOUBLE",

 		"LONG LONG", "BOO HOO"};

 	const TSqlColumnType KColTypes[] =

 		{ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,

 		 ESqlText,ESqlText,ESqlText,ESqlText,ESqlText,ESqlText,

 		 ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,

 		 ESqlReal,ESqlReal,ESqlReal,ESqlReal,

 		 ESqlInt,ESqlInt};

 	const TInt KColTypeCnt = sizeof(KColTypes) / sizeof(KColTypes[0]);

 	TEST2(sizeof(KColTypeNames) / sizeof(KColTypeNames[0]), KColTypeCnt);

 	//Create table 1

 	TBuf8<512> sql;

 	sql.Copy(_L8("CREATE TABLE T("));

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

 		{

 		sql.Append(TChar('A'));

 		sql.AppendNum(i + 1);

 		sql.Append(TChar(' '));

 		sql.Append((TUint8*)KColTypeNames[i], User::StringLength((TUint8*)KColTypeNames[i]));

 		sql.Append(TChar(','));

 		}

 	sql.Replace(sql.Length() - 1, 1, _L8(")"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

 	//Select all columns (SELECT *)

 	err = TheStmt.Prepare(TheDb, _L("SELECT * FROM T"));

 	TEST2(err, KErrNone);

 	TInt cnt = TheStmt.ColumnCount();

 	TEST2(cnt, KColTypeCnt);

 	TSqlColumnType colType;

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

 		{

 		TInt err = TheStmt.DeclaredColumnType(i, colType);

 		TEST2(err, KErrNone);

 		TEST2(colType, KColTypes[i]);

 		}

 	TheStmt.Close();

 	//Create table 2

 	err = TheDb.Exec(_L8("CREATE TABLE T2(Id INTEGER, DATA BLOB)"));

 	TEST(err >= 0);

 	//Multi-table select

 	err = TheStmt.Prepare(TheDb, _L("SELECT T.A1,T2.Id,T.A9,T2.Data FROM T,T2"));

 	TEST2(err, KErrNone);

 	err = TheStmt.DeclaredColumnType(0, colType);

 	TEST2(err, KErrNone);

 	TEST2(colType, ESqlInt);

 	err = TheStmt.DeclaredColumnType(1, colType);

 	TEST2(err, KErrNone);

 	TEST2(colType, ESqlInt);

 	err = TheStmt.DeclaredColumnType(2, colType);

 	TEST2(err, KErrNone);

 	TEST2(colType, ESqlText);

 	err = TheStmt.DeclaredColumnType(3, colType);

 	TEST2(err, KErrNone);

 	TEST2(colType, ESqlBinary);

 	TheStmt.Close();

 	//Select expression

 	err = TheStmt.Prepare(TheDb, _L("SELECT (Id + Data) AS RES FROM t2"));

 	TEST2(err, KErrNone);

 	err = TheStmt.DeclaredColumnType(0, colType);

 	TEST2(err, KErrNone);

 	TEST2(colType, ESqlInt);

 	TheStmt.Close();

 	//Select constant

 	err = TheStmt.Prepare(TheDb, _L("SELECT (Id + Data) AS RES, 55.89 FROM t2"));

 	TEST2(err, KErrNone);

 	err = TheStmt.DeclaredColumnType(1, colType);

 	TEST2(err, KErrNone);

 	TEST2(colType, ESqlInt);

 	TheStmt.Close();

 	//Cleanup

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4017

 @SYMTestCaseDesc		RSqlStatement::ColumnName(TInt, TPtrC&) test

 						The test creates a database with a table and then checks the ColumnName() return result for:

 						- select all column from the table and check their names;

 						- multi-table select plus column name checks;

 						- select expression - the expected column name is RES

 						- select constant - the expected column type is 55.89 

 @SYMTestPriority		High

 @SYMTestActions			RSqlStatement::ColumnName() test

 @SYMTestExpectedResults Test must not fail

 @SYMCR				    RMAD-7B7EV5

                         Add SQL Server APIs to retrieve column and parameter names

 */	

 void ColumnNameTest()

 	{

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	const char* KColTypeNames[] = 

 		{"INTEGER", "LONG INTEGER", "INT", "SHORT INT", "SMALL INT", "TINY INT", "SHORT", "INT64",

 		"TEXT", "LONGTEXT", "CLOB", "CHAR", "CHARACTER(20)", "LONG TEXT",

 		"BINARY", "LONG BINARY", "LONGBINARY", "BLOB", "LONGBLOB", "LONG BLOB",

 		"REAL", "FLOAT", "DOUBLE", "LONG DOUBLE",

 		"LONG LONG", "BOO HOO"};

 	const TSqlColumnType KColTypes[] = 

 		{ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,

 		 ESqlText,ESqlText,ESqlText,ESqlText,ESqlText,ESqlText,

 		 ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,

 		 ESqlReal,ESqlReal,ESqlReal,ESqlReal,

 		 ESqlInt,ESqlInt};

 	const TInt KColTypeCnt = sizeof(KColTypes) / sizeof(KColTypes[0]);

 	TEST2(sizeof(KColTypeNames) / sizeof(KColTypeNames[0]), KColTypeCnt);

 	//Create table 1

 	TBuf8<512> sql;

 	sql.Copy(_L8("CREATE TABLE T("));

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

 		{

 		sql.Append(TChar('A'));

 		sql.AppendNum(i + 1);

 		sql.Append(TChar(' '));

 		sql.Append((TUint8*)KColTypeNames[i], User::StringLength((TUint8*)KColTypeNames[i]));

 		sql.Append(TChar(','));

 		}

 	sql.Replace(sql.Length() - 1, 1, _L8(")"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

 	//Select all columns (SELECT *)

 	err = TheStmt.Prepare(TheDb, _L("SELECT * FROM T"));

 	TEST2(err, KErrNone);

 	TInt cnt = TheStmt.ColumnCount();

 	TEST2(cnt, KColTypeCnt);

 	TPtrC colName;

 	TBuf<128> expectedColName;

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

 		{

 		expectedColName.Zero();

 		expectedColName.Append(TChar('A'));

 		expectedColName.AppendNum(i + 1);

 		TInt err = TheStmt.ColumnName(i, colName);

 		TEST2(err, KErrNone);

 		TEST2(colName.Compare(expectedColName), 0);

 		TSqlColumnType type;

 		err = TheStmt.DeclaredColumnType(i, type);

 		TEST2(err, KErrNone);

 		TEST2(type, KColTypes[i]);

 		}

 	TheStmt.Close();

 	//Create table 2

 	err = TheDb.Exec(_L8("CREATE TABLE T2(Id INTEGER, DATA BLOB)"));

 	TEST(err >= 0);

 	//Multi-table select

 	err = TheStmt.Prepare(TheDb, _L("SELECT T.A1,T2.Id,T.A9,T2.DATA FROM T,T2"));

 	TEST2(err, KErrNone);

 	err = TheStmt.ColumnName(0, colName);

 	TEST2(err, KErrNone);

 	TEST2(colName.Compare(_L("A1")), 0);

 	err = TheStmt.ColumnName(1, colName);

 	TEST2(err, KErrNone);

 	TEST2(colName.Compare(_L("Id")), 0);

 	err = TheStmt.ColumnName(2, colName);

 	TEST2(err, KErrNone);

 	TEST2(colName.Compare(_L("A9")), 0);

 	err = TheStmt.ColumnName(3, colName);

 	TEST2(err, KErrNone);

 	TEST2(colName.Compare(_L("DATA")), 0);

 	TheStmt.Close();

 	//Select expression

 	err = TheStmt.Prepare(TheDb, _L("SELECT (Id + Data) AS RES FROM t2"));

 	TEST2(err, KErrNone);

 	err = TheStmt.ColumnName(0, colName);

 	TEST2(err, KErrNone);

 	TEST2(colName.Compare(_L("RES")), 0);

 	//Too big column index

     err = TheStmt.ColumnName(1323, colName);

     TEST2(err, KErrNotFound);

     //Negative column index 

     err = TheStmt.ColumnName(-100, colName);

     TEST2(err, KErrNotFound);

 	TheStmt.Close();

 	//Select constant

 	err = TheStmt.Prepare(TheDb, _L("SELECT (Id + Data) AS RES, 55.89 FROM t2"));

 	TEST2(err, KErrNone);

 	err = TheStmt.ColumnName(1, colName);

 	TEST2(err, KErrNone);

 	TEST2(colName.Compare(_L("55.89")), 0);

 	TheStmt.Close();

 	//Cleanup

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4018

 @SYMTestCaseDesc		RSqlStatement::ParameterName(TInt, TPtrC&) and RSqlStatement::ParamName(TInt, TPtrC&) test

 						DML test:

 						The test creates a database with a table and prepares an insert query.

 						The test then checks the ParameterName() and ParamName() return result for:

 						- Named parameters - return the named param

 						- Unnamed parameters - return ?<param-index>

 @SYMTestPriority		High

 @SYMTestActions			RSqlStatement::ParameterName() and RSqlStatement::ParamName() test

 @SYMTestExpectedResults Test must not fail

 @SYMCR					RMAD-7B7EV5

                         Add SQL Server APIs to retrieve column and parameter names

 */	

 void ParamNameTest()

 	{

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	const char* KColTypeNames[] = 

 		{"INTEGER", "TEXT"};

 	const TInt KColTypeCnt = sizeof(KColTypeNames) / sizeof(KColTypeNames[0]);

 	//Create table 1

 	TBuf8<256> sql;

 	sql.Copy(_L8("CREATE TABLE T("));

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

 		{

 		sql.Append(TChar('A'));

 		sql.AppendNum(i + 1);

 		sql.Append(TChar(' '));

 		sql.Append((TUint8*)KColTypeNames[i], User::StringLength((TUint8*)KColTypeNames[i]));

 		sql.Append(TChar(','));

 		}

 	sql.Replace(sql.Length() - 1, 1, _L8(")"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

 	TheStmt.Close();

 	// Create insert statement, then check param names

 	err = TheStmt.Prepare(TheDb, _L("INSERT INTO T (A1, A2) VALUES (:prm1, :prm2)"));

 	TEST2(err, KErrNone);

 	TPtrC paramName;

 	TBuf<128> expectedParamName;

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

 		{

 		expectedParamName.Zero();

 		expectedParamName.Append(_L(":prm"));

 		expectedParamName.AppendNum(i + 1);

 		TInt paramIndex = TheStmt.ParameterIndex(expectedParamName);

 		TEST2(paramIndex, i);

 		TInt err = TheStmt.ParameterName(i, paramName);

 		TEST2(err, KErrNone);

 		TEST2(paramName.Compare(expectedParamName), 0);

 		err = TheStmt.ParamName(i, paramName);

 		TEST2(err, KErrNone);

 		TEST2(paramName.Compare(expectedParamName), 0);

 		}

     //Too big parameter index

     err = TheStmt.ParamName(1323, paramName);

     TEST2(err, KErrNotFound);

     //Negative parameter index 

     err = TheStmt.ParamName(-100, paramName);

     TEST2(err, KErrNotFound);

 	TheStmt.Close();

 	//SQL statement without parameters

     err = TheStmt.Prepare(TheDb, _L("INSERT INTO T (A1, A2) VALUES (1, '1')"));

     TEST2(err, KErrNone);

     err = TheStmt.ParamName(0, paramName);

     TEST2(err, KErrNotFound);

     TheStmt.Close();

 	// Create insert statement, then check param names

 	err = TheStmt.Prepare(TheDb, _L("INSERT INTO T (A1, A2) VALUES (:prm1, ?)"));

 	TEST2(err, KErrNone);

 	expectedParamName.Zero();

 	expectedParamName.Append(_L(":prm1"));

 	TInt paramIndex = TheStmt.ParameterIndex(expectedParamName);

 	TEST2(paramIndex, 0);

 	err = TheStmt.ParameterName(0, paramName);

 	TEST2(err, KErrNone);

 	TEST2(paramName.Compare(expectedParamName), 0);

 	err = TheStmt.ParamName(0, paramName);

 	TEST2(err, KErrNone);

 	TEST2(paramName.Compare(expectedParamName), 0);

 	expectedParamName.Zero();

 	expectedParamName.Append(_L("?1"));

 	err = TheStmt.ParameterName(1, paramName);

 	TEST2(err, KErrNone);

 	paramIndex = TheStmt.ParameterIndex(expectedParamName);

 	TEST2(paramIndex, 1);

 	TEST2(paramName.Compare(expectedParamName), 0);

 	err = TheStmt.ParamName(1, paramName);

 	TEST2(err, KErrNone);

 	TEST2(paramName.Compare(expectedParamName), 0);

 	TheStmt.Close();

 	//Cleanup

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4006

 @SYMTestCaseDesc		Test for DEF115300 - SqlSrv.EXE::!SQL Server when preparing invalid LEFT JOIN sql query.

 						The test does the following steps:

 						1) Creates a 16-bit database and using 16-bit queries proves that the "GROUP BY GROUP BY" syntax error

 						   does not cause an assert inside the SQLITE code.

 						2) Creates a 8-bit database and using 8-bit queries proves that the "GROUP BY GROUP BY" syntax error

 						   does not cause an assert inside the SQLITE code.

 @SYMTestPriority		Medium

 @SYMTestActions			Test for DEF115300 - SqlSrv.EXE::!SQL Server when preparing invalid LEFT JOIN sql query.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF115300

 */

 void DEF115300()

 	{

 	//Step 1: 16-bit statements

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE MAIN(Id INTEGER, Id1 INTEGER, F2 BLOB)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO MAIN(Id,Id1) VALUES(2,3)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO MAIN(Id,Id1) VALUES(3,4)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER, Id1 INTEGER, F2 BLOB)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO A(Id, Id1) VALUES(2,3)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO A(Id, Id1) VALUES(4,4)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("CREATE TABLE B(Id INTEGER, Id1 INTEGER, F2 BLOB)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO B(Id, Id1) VALUES(2,3)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO B(Id, Id1) VALUES(5,4)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO B(Id, Id1) VALUES(5,4)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("CREATE VIEW v2 AS SELECT Id,Id1,F2 FROM B"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("CREATE VIEW v1 AS SELECT Id,Id1,F2 FROM A"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("CREATE VIEW v3 AS SELECT Id,Id1,F2 FROM B"));

 	TEST2(err, 1);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("SELECT * FROM v2 LEFT JOIN MAIN ON v2.Id = MAIN.Id LEFT JOIN A ON MAIN.Id = A.Id GROUP BY GROUP BY MAIN.Id"));

 	stmt.Close();

 	TEST(err != KErrNone && err != KErrServerTerminated);

 	TheDb.Close();

 	err = RSqlDatabase::Delete(KTestDbName1);

 	TEST2(err, KErrNone);

 	//Step 2: 8-bit statements

 	_LIT8(KServerConfigString1, "encoding=\"UTF-8\"");

 	err = TheDb.Create(KTestDbName1, &KServerConfigString1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L8("CREATE TABLE MAIN(Id INTEGER, Id1 INTEGER, F2 BLOB)"));

 	TEST2(err, 1);

 	err = stmt.Prepare(TheDb, _L8("SELECT * FROM main GROUP BY GROUP BY main.Id"));

 	stmt.Close();

 	TEST(err != KErrNone && err != KErrServerTerminated);

 	TheDb.Close();

 	err = RSqlDatabase::Delete(KTestDbName1);

 	TEST2(err, KErrNone);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4007

 @SYMTestCaseDesc		Test for DEF115331 - SQL, bad code coverage for db reindexing if default collation has changed.

 						The test does the following steps, using public shared and private secure database:

 						1) Creates a test database with a table and one index using one of the collations.

 						2) Updates the symbian_settings table, setting the collation dll name column value 

 						   to be a "bbbababz" string (Simulates that there is no valid collation dll name).

 						3) Reopens the database. This operation should cause a database reindexing, since the index uses

 						   one of the user-defined collation methods.

 						   The default system collation dll name should be stored in the symbian_settings table.

 						4) Verifies that symbian_settings table contains only one record and that the collation dll name

 						   column value has been updated.

 @SYMTestPriority		Medium

 @SYMTestActions			Test for DEF115331 - SQL, bad code coverage for db reindexing if default collation has changed.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF115331

 */

 void DEF115331L()

 	{

 	const TPtrC KDbNames[]		=	{KTestDbName1(),	KTestDbName2()};

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

 		{

 		//Step 1: Create a test database with a table and one index using one of the collations.

 		(void)RSqlDatabase::Delete(KDbNames[i]);

 		TInt err = TheDb.Create(KDbNames[i]);

 		TEST2(err, KErrNone);

 		err = TheDb.Exec(_L("CREATE TABLE A(C TEXT)"));

 		TEST2(err, 1);

 		err = TheDb.Exec(_L("CREATE INDEX I ON A(C COLLATE CompareC1)"));

 		TEST2(err, 1);

 		//Step 2: Make sure that the collation dll name is set and unique (not the default collation).

 		err = TheDb.Exec(_L("UPDATE symbian_settings SET CollationDllName='bbbababz'"));

 		TEST2(err, 1);

 		TheDb.Close();

 		//Step 3: Reopen the database. That step should cause a database reindexing, because the default collation dll 

 		//        name is not the one stored in the table.

 		err = TheDb.Open(KDbNames[i]);

 		TEST2(err, KErrNone);

 		TSqlScalarFullSelectQuery query(TheDb);

 		//Step 4: Check that the settigns table has only one record.

 		TInt cnt = query.SelectIntL(_L("SELECT COUNT(*) FROM symbian_settings"));

 		TEST2(cnt, 1);

 		//Step 5: Check that the collation dll name in the settings table has been updated.

 		TFileName collationDllName;

 		err = query.SelectTextL(_L("SELECT CollationDllName FROM symbian_settings"), collationDllName);

 		TEST2(err, KErrNone);

 		_LIT(KTestCollationDllName, "bbbababz");//The same as the used in step 2 - above.

 		TEST(collationDllName != KTestCollationDllName);

 		TheDb.Close();

 		err = RSqlDatabase::Delete(KDbNames[i]);

 		TEST2(err, KErrNone);

 		}

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4079

 @SYMTestCaseDesc		RSqlDatabase::Create() and RSqlDatabase::Open() - injection test

 						The test attempts to create or open a database which name contains

 						"DELETE FROM symbian_settings" statement.If it is possible to open or

 						create a database with that name, the "symbian_settings" table content

 						should stay unchanged.

 @SYMTestPriority		Medium

 @SYMTestActions			RSqlDatabase::Create() and RSqlDatabase::Open() - injection test

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ5792

 */

 void InjectionTest()

 	{

 	TInt err = TheDb.Create(KDbInjectedName1);

 	TEST(err != KErrNone);

 	err = TheDb.Create(KDbInjectedName2);

 	TEST2(err, KErrNone);

 	TSqlScalarFullSelectQuery query(TheDb);

 	TInt recCount = 0;

 	TRAP(err, recCount = query.SelectIntL(_L("SELECT COUNT(*) FROM symbian_settings")));

 	TEST2(err, KErrNone);

 	TEST2(recCount, 1);

 	TheDb.Close();

 	err = TheDb.Open(KDbInjectedName2);

 	TEST2(err, KErrNone);

 	recCount = 0;

 	query.SetDatabase(TheDb);

 	TRAP(err, recCount = query.SelectIntL(_L("SELECT COUNT(*) FROM symbian_settings")));

 	TEST2(err, KErrNone);

 	TEST2(recCount, 1);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KDbInjectedName2);

 	(void)RSqlDatabase::Delete(KDbInjectedName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4038

 @SYMTestCaseDesc		Background compaction - two connections usability test.

 						The test creates a database connection with a background compaction mode. The the test 

 						locks the database in a transaction. Then the test creates a second connection

 						to the same database while the first connection is in a transaction.

 @SYMTestPriority		Medium

 @SYMTestActions			Background compaction - two connections usability test.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ10271

 */

 void TwoConnectionsTest()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	RSqlDatabase db1, db2;

 	TInt err = db1.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = db1.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A VALUES(1)"));

 	TEST2(err, 1);

 	err = db1.Exec(_L("BEGIN TRANSACTION"));

 	TEST(err >= 0);

 	err = db1.Exec(_L("INSERT INTO A VALUES(2)"));

 	TEST2(err, 1);

 	err = db2.Open(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = db1.Exec(_L("COMMIT TRANSACTION"));

 	TEST(err >= 0);

 	db2.Close();		

 	db1.Close();		

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 TInt StackOverflowThreadFunc(void* aData)

 	{

 	CTrapCleanup* tc = CTrapCleanup::New();

 	TEST(tc != NULL);

 	User::SetJustInTime(EFalse);	// disable debugger panic handling

 	TInt* cntptr = reinterpret_cast<TInt*> (aData);

 	TEST(cntptr != NULL);

 	TInt cnt = *cntptr;

 	HBufC* buf = HBufC::New(cnt * 12 + 32);//enough for the "SELECT Id FROM A WHERE Id=v1 OR Id=v2 OR ..." string

 	if(!buf)

 		{

 		delete tc;

 		return KErrNoMemory;	

 		}

 	TPtr sql = buf->Des();

 	TInt err = TheDb.Open(KTestDbName1);

 	if(err != KErrNone)

 		{

 		delete buf;

 		delete tc;

 		return err;	

 		}

 	TTime now;

 	now.UniversalTime();

 	TInt64 seed = now.Int64();

 	sql.Copy(_L("SELECT Id FROM A WHERE "));

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

 		{

 		sql.Append(_L("Id="));

 		sql.AppendNum(Math::Rand(seed) % cnt);

 		sql.Append(_L(" OR "));

 		}

 	sql.SetLength(sql.Length() - 4);//Remove the last " OR "

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, sql);

 	stmt.Close();

 	TheDb.Close();

 	delete buf;

 	delete tc;

 	return err;

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4080

 @SYMTestCaseDesc		SQL server stack overflow test

 						The test creates a database and runs a thread. The thread opens the database

 						and attempts to execute a SELECT statement, which format is:

 						"SELECT Id FROM A WHERE Id=1 OR Id=2 OR...OR Id=N",

 						where N is a number passed as an argument from the main thread, starts from 100000

 						and is increased or decreased on each test iteration, depending on the reported result from the thread.

 						Finally, the main thread will report the max number of the OR subexpressions that can be included

 						in the SELECT statement, without an error to be reported.

 						The test should not crash the SQL server, if the server stack size and parsing tree depth has

 						been properly configured.

 @SYMTestPriority		Medium

 @SYMTestActions			SQL server stack overflow test

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ5792

 */

 void SqlServerStackOverflowTest()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER PRIMARY KEY AUTOINCREMENT)"));

 	TEST2(err, 1);

 	TheDb.Close();

 	TInt prev = 0, next = 100000;

 	while(Abs(next - prev) > 0)

 		{

 		TInt count = next;

 		TheTest.Printf(_L("'OR' expr. count: %d\r\n"), count);

 		RThread thread;

 		_LIT(KThreadName,"ORThread");						//stack	minheap		maxheap

 		err = thread.Create(KThreadName, &StackOverflowThreadFunc, 0x2000, 0x00100000, 0x02000000, &count);

 		TEST2(err, KErrNone);

 		TRequestStatus status;

 		thread.Logon(status);

 		TEST2(status.Int(), KRequestPending);

 		thread.Resume();

 		User::WaitForRequest(status);

 		User::SetJustInTime(ETrue);	// enable debugger panic handling

 		TInt exitType = thread.ExitType();

 		const TDesC& exitCategory = thread.ExitCategory();

 		TInt exitReason = thread.ExitReason();

 		TheTest.Printf(_L("Exit type: %d, exit reason: %d, exit category: %S\r\n"), exitType, exitReason, &exitCategory);

 		thread.Close();

 		TEST(exitReason != KErrServerTerminated);

 		TEST(exitType != EExitPanic);

 		TInt tmp = next;		

 		if(status.Int() != KErrNone)

 			{//The number of the OR subexpressions is too big and cannot be parsed. Decrease the number, repeat the test.

 			next -= Abs(next - prev) / 2;

 			}

 		else

 			{//KErrNone: The number of the OR subexpressions has been successfully parsed. Increase the number, repeat the test.

 			next += Abs(next - prev) / 2;

 			}

 		prev = tmp;

 		}

 	TheTest.Printf(_L("The test has succeeded with an expression with %d ORs\r\n"), prev);

 	}

 void AssertSettingsTable()

 	{

 	TSqlScalarFullSelectQuery query(TheDb);

 	TInt recCount = 0;

 	TRAPD(err, recCount = query.SelectIntL(_L("SELECT COUNT(*) FROM symbian_settings")));

 	TEST2(err, KErrNone);

 	TEST2(recCount, 1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4086

 @SYMTestCaseDesc		RSqlBlobWriteStream::OpenL() and RSqlBlobReadStream::OpenL() - injection test

 						The test attempts to open a blob stream with an attached database name containing

 						"DELETE FROM symbian_settings" statement. The test should not delete the content of the

 						"symbian_settings" table.

 						The test also attempts to open a blob stream with a set of very long database/table/column names.

 @SYMTestPriority		Medium

 @SYMTestActions			RSqlBlobWriteStream::OpenL() and RSqlBlobReadStream::OpenL() - injection test

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ5792

                         REQ10410

 						REQ10411

 						REQ10418

 */

 void BlobStreamInjectionTest()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Data BLOB)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO A VALUES(1, x'11223344556677889900')"));

 	TEST2(err, 1);

 	_LIT(KAttachDb, "AttachDb");

 	err = TheDb.Attach(KTestDbName1, KAttachDb);

 	TEST2(err, KErrNone);

 	//RSqlBlobWriteStream::OpenL() - attached database  name injected

 	RSqlBlobWriteStream strm1;

 	TRAP(err, strm1.OpenL(TheDb, _L("A"), _L("Data"), 1, _L("Id;DELETE FROM symbian_settings;")));

 	TEST(err != KErrNone);

 	AssertSettingsTable();

 	//RSqlBlobReadStream::OpenL() - attached database  name injected

 	RSqlBlobReadStream strm2;

 	TRAP(err, strm2.OpenL(TheDb, _L("A"), _L("Data"), 1, _L("Id;DELETE FROM symbian_settings;")));

 	TEST(err != KErrNone);

 	AssertSettingsTable();

 	//Attempt to open a write blob stream with a set of very long database/table/column names.

 	TBuf<KMaxFileName + 10> longName;

 	longName.SetLength(longName.MaxLength());

 	RSqlBlobWriteStream strm3;

 	TRAP(err, strm3.OpenL(TheDb, longName, longName, 1, longName));

 	TEST(err != KErrNone);

 	//Attempt to open a read blob stream with a set of very long database/table/column names.

 	RSqlBlobReadStream strm4;

 	TRAP(err, strm4.OpenL(TheDb, longName, longName, 1, longName));

 	TEST(err != KErrNone);

 	//Attempt to open a write blob stream with a set of KNullDesC database/table/column names.

 	RSqlBlobWriteStream strm5;

 	TRAP(err, strm5.OpenL(TheDb, KNullDesC, KNullDesC, 1, KNullDesC));

 	TEST(err != KErrNone);

 	//Attempt to open a read blob stream with a set of KNullDesC database/table/column names.

 	RSqlBlobReadStream strm6;

 	TRAP(err, strm6.OpenL(TheDb, KNullDesC, KNullDesC, 1, KNullDesC));

 	TEST(err != KErrNone);

 	//Attempt to open a read blob stream, where the blob column name is invalid and contains non-convertible characters.

     TBuf<3> invName;

     invName.SetLength(3);

     invName[0] = TChar(0xD800); 

     invName[1] = TChar(0xFC00); 

     invName[2] = TChar(0x0000);

 	RSqlBlobReadStream strm7;

 	TRAP(err, strm7.OpenL(TheDb,  _L("A"), invName, 1, KNullDesC));

 	TEST(err != KErrNone);

 	//Attempt to open a read blob stream, where the table name is invalid and contains non-convertible characters.

 	RSqlBlobReadStream strm8;

 	TRAP(err, strm8.OpenL(TheDb, invName, _L("Data"), 1, KNullDesC));

 	TEST(err != KErrNone);

 	//Attempt to open a read blob stream, where the attached db name is invalid and contains non-convertible characters.

 	RSqlBlobReadStream strm9;

 	TRAP(err, strm9.OpenL(TheDb, _L("A"), _L("Data"), 1, invName));

 	TEST(err != KErrNone);

 	//

 	err = TheDb.Detach(KAttachDb);

 	TEST2(err, KErrNone);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4087

 @SYMTestCaseDesc		Bound parameter values test.

 						The test verifies that bound parameters with big text/binary values retain their values after

 						the RSqlStatement::Reset() call. The old bound paramegter values can be used for the next 

 						RSqlStatement::Exec() call.

 @SYMTestActions			Bound parameter values test.

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 @SYMREQ					REQ5792

 */

 void BoundParameterValuesTest()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("CREATE TABLE A2(T1 TEXT, T2 TEXT)"));

 	TEST2(err, 1);

 	RSqlStatement stmt1, stmt2;

 	err = stmt1.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));

 	TEST2(err, KErrNone);

 	err = stmt2.Prepare(TheDb, _L("INSERT INTO A2 VALUES(:Prm1, :Prm2)"));

 	TEST2(err, KErrNone);

 	//Insert 1 record into table "A1". T2 = "ZZZZ.....".

 	TheBuf.SetLength(KBufLen - 100);

 	TheBuf.Fill(TChar('Z'));

 	err = stmt1.BindText(0, TheBuf);

 	TEST2(err, KErrNone);

 	err = stmt1.BindText(1, TheBuf);

 	TEST2(err, KErrNone);

 	err = stmt1.Exec();

 	TEST2(err, 1);

 	err = stmt1.Reset();

 	TEST2(err, KErrNone);

 	//Insert 1 record into table "A2". T2 = "AAAAAAA.....".

 	TheBuf.SetLength(KBufLen);

 	TheBuf.Fill(TChar('A'));

 	err = stmt2.BindText(0, TheBuf);

 	TEST2(err, KErrNone);

 	err = stmt2.BindText(1, TheBuf);

 	TEST2(err, KErrNone);

 	err = stmt2.Exec();

 	TEST2(err, 1);

 	err = stmt2.Reset();

 	TEST2(err, KErrNone);

 	//Insert 1 record into table "A1". T2 not set. T2 should be initialized with the previous bound value - "ZZZZZZ....".

 	//If the problem is not fixed, the SQLITE will attempt to access an already deleted region of memory.

 	TheBuf.SetLength(KBufLen - 100);

 	TheBuf.Fill(TChar('B'));

 	err = stmt1.BindText(0, TheBuf);

 	TEST2(err, KErrNone);

 	err = stmt1.Exec();

 	TEST2(err, 1);

 	err = stmt1.Reset();

 	TEST2(err, KErrNone);

 	stmt2.Close();

 	stmt1.Close();

 	//Check the inserted records.

 	TSqlScalarFullSelectQuery q(TheDb);

 	TRAP(err, q.SelectTextL(_L("SELECT T2 FROM A1 WHERE ROWID=1"), TheBuf));

 	TEST2(err, KErrNone);

 	TEST2(TheBuf.Length(), (KBufLen - 100));

 	for(TInt i1=0;i1<(KBufLen - 100);++i1)

 		{

 		TEST2(TheBuf[i1], TChar('Z'));	

 		}

 	TRAP(err, q.SelectTextL(_L("SELECT T2 FROM A1 WHERE ROWID=2"), TheBuf));

 	TEST2(err, KErrNone);

 	TEST2(TheBuf.Length(), (KBufLen - 100));

 	for(TInt i2=0;i2<(KBufLen - 100);++i2)

 		{

 		TEST2(TheBuf[i2], TChar('Z'));	

 		}

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4076

 @SYMTestCaseDesc		Bound parameter values test.

 						The test verifies that when a RSqlParamWriteStream object is used for binding parameter values,

 						it is safe to erverse the order of RSqlParamWriteStream::Close() and RSqlStatement::Close() calls.

 @SYMTestActions			Bound parameter values test.

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 @SYMREQ					REQ5792

 */

 void BoundParameterValuesTest2()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));

 	TEST2(err, 1);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));

 	TEST2(err, KErrNone);

 	RSqlParamWriteStream strm;

 	err = strm.BindText(stmt, 0);

 	TEST2(err, KErrNone);

 	err = stmt.Exec();

 	TEST2(err, 1);

 	stmt.Close();

 	strm.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4077

 @SYMTestCaseDesc		Bound parameter values test.

 						The test verifies that when a RSqlParamWriteStream object is used for binding parameter values,

 						it is possible to write the parameter value, then call RSqlParamWriteStream::Close() and finally -

 						RSqlStatement::Exec() to execute the operation (an INSERT statement). The test verifies that the record

 						has really been inserted and the column value is equal to the bound parameter value

 @SYMTestActions			Bound parameter values test.

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 @SYMREQ					REQ5792

 */

 void BoundParameterValuesTest3()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));

 	TEST2(err, 1);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));

 	TEST2(err, KErrNone);

 	RSqlParamWriteStream strm;

 	err = strm.BindText(stmt, 0);

 	TEST2(err, KErrNone);

 	_LIT(KText, "AAAA");

 	TRAP(err, strm.WriteL(KText));

 	TEST2(err, KErrNone);

 	TRAP(err, strm.CommitL());

 	TEST2(err, KErrNone);

 	strm.Close();

 	err = stmt.Exec();

 	TEST2(err, 1);

 	stmt.Close();

 	TSqlScalarFullSelectQuery q(TheDb);

 	TRAP(err, q.SelectTextL(_L("SELECT T1 FROM A1"), TheBuf));

 	TEST2(err, KErrNone);

 	TEST(KText() == TheBuf);	

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4083

 @SYMTestCaseDesc		Bound parameter values test.

 						The test prepares an INSERT sql statement and inserts two records using streams to bind the parameter values.

 						For the second INSERT no parameter value is bound to the first parameter. The expectation is that the value

 						that has been bound for the first record will be used for the second record also.

 @SYMTestActions			Bound parameter values test.

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 @SYMREQ					REQ5792

 */

 void BoundParameterValuesTest4()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));

 	TEST2(err, 1);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));

 	TEST2(err, KErrNone);

 	RSqlParamWriteStream strm;

 	err = strm.BindText(stmt, 0);

 	TEST2(err, KErrNone);

 	_LIT(KText1, "AAAA");

 	TRAP(err, strm.WriteL(KText1));

 	TEST2(err, KErrNone);

 	TRAP(err, strm.CommitL());

 	TEST2(err, KErrNone);

 	strm.Close();

 	err = strm.BindText(stmt, 1);

 	TEST2(err, KErrNone);

 	_LIT(KText2, "BBBBBBBBBB");

 	TRAP(err, strm.WriteL(KText2));

 	TEST2(err, KErrNone);

 	TRAP(err, strm.CommitL());

 	TEST2(err, KErrNone);

 	strm.Close();

 	err = stmt.Exec();

 	TEST2(err, 1);

 	err = stmt.Reset();

 	TEST2(err, KErrNone);

 	err = strm.BindText(stmt, 1);

 	TEST2(err, KErrNone);

 	_LIT(KText3, "CCCCCCCCCCC");

 	TRAP(err, strm.WriteL(KText3));

 	TEST2(err, KErrNone);

 	TRAP(err, strm.CommitL());

 	TEST2(err, KErrNone);

 	strm.Close();

 	err = stmt.Exec();

 	TEST2(err, 1);

 	stmt.Close();

 	TSqlScalarFullSelectQuery q(TheDb);

 	TRAP(err, q.SelectTextL(_L("SELECT T1 FROM A1 WHERE ROWID=1"), TheBuf));

 	TEST2(err, KErrNone);

 	TEST(KText1() == TheBuf);	

 	TRAP(err, q.SelectTextL(_L("SELECT T2 FROM A1 WHERE ROWID=1"), TheBuf));

 	TEST2(err, KErrNone);

 	TEST(KText2() == TheBuf);	

 	TRAP(err, q.SelectTextL(_L("SELECT T1 FROM A1 WHERE ROWID=2"), TheBuf));

 	TEST2(err, KErrNone);

 	TEST(KText1() == TheBuf);	

 	TRAP(err, q.SelectTextL(_L("SELECT T2 FROM A1 WHERE ROWID=2"), TheBuf));

 	TEST2(err, KErrNone);

 	TEST(KText3() == TheBuf);	

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4105

 @SYMTestCaseDesc		Bound parameter values test.

 						BC test. Even though it is correct to execute only one CommitL() on a parameter stream,

 						it should be possible to execute more than one CommitL(). It should be possible also

 						the stream data to be updated after the first commit operation and the expectation is that

 						the updated parameter data should be used for the column value.

 @SYMTestActions			Bound parameter values test.

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 @SYMREQ					REQ5792

 */

 void BoundParameterValuesTest5()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));

 	TEST2(err, 1);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));

 	TEST2(err, KErrNone);

 	RSqlParamWriteStream strm;

 	err = strm.BindText(stmt, 0);

 	TEST2(err, KErrNone);

 	_LIT(KText1, "AAAA");

 	TRAP(err, strm.WriteL(KText1));

 	TEST2(err, KErrNone);

 	TRAP(err, strm.CommitL());

 	TEST2(err, KErrNone);

 	TRAP(err, strm.Sink()->SeekL(MStreamBuf::EWrite, EStreamBeginning, 0));

 	TEST2(err, KErrNone);

 	_LIT(KText2, "DTAA");

 	TRAP(err, strm.WriteL(KText2));

 	TEST2(err, KErrNone);

 	TRAP(err, strm.CommitL());

 	TEST2(err, KErrNone);

 	strm.Close();

 	err = stmt.Exec();

 	TEST2(err, 1);

 	stmt.Close();

 	TSqlScalarFullSelectQuery q(TheDb);

 	TRAP(err, q.SelectTextL(_L("SELECT T1 FROM A1 WHERE ROWID=1"), TheBuf));

 	TEST2(err, KErrNone);

 	TEST(KText2() == TheBuf);	

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 void PrintConfig(TSqlResourceProfiler& aProfiler)

 	{

 	TBuf8<128> config;

 	if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterConfig, config) == KErrNone)

 		{

 		_LIT(KCacheSize, "Cache size: %S pages\r\n");

 		_LIT(KPageSize, "Page size: %S bytes\r\n");

 		_LIT(KEncoding, "Encoding: %S\r\n");

 		_LIT(KDefaultSoftHeapLimit, "Default soft heap limit: %S Kb\r\n");

 		_LIT(KVacuumMode, "Vacuum mode: %S\r\n");

 		TPtrC KText[] = {KCacheSize(), KPageSize(), KEncoding(), KDefaultSoftHeapLimit(), KVacuumMode()};

 		for(TInt i=0;i<config.Length();++i)

 			{

 			if(config[i] == TChar(';'))	

 				{

 				config[i] = TChar(' ');	

 				}

 			}

 		TInt idx = 0;

 		TLex8 lex(config);

 		while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))

 			{

 			TPtrC8 num8 = lex.NextToken();

 			TBuf<20> num;

 			num.Copy(num8);

 			TheTest.Printf(KText[idx], &num);

 			++idx;

 			}

 		}

 	}

 void PrintFileIo(TSqlResourceProfiler& aProfiler)

 	{

 	TBuf8<300> countersValues;

 	if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterFileIO, countersValues) == KErrNone)

 		{

 		TheTest.Printf(_L("=========================\r\n"));

 		_LIT(KFileCreate, "File Create");

 		_LIT(KFileOpen, "File Open");

 		_LIT(KFileClose, "File Close");

 		_LIT(KFileDelete, "File Delete");

 		_LIT(KFileRead, "File Read");

 		_LIT(KFileWrite, "File Write");

 		_LIT(KFileSeek, "File Seek");

 		_LIT(KFileSize, "File Size");

 		_LIT(KFileSetSize, "File SetSize");

 		_LIT(KFileSync, "File Sync");

 		_LIT(KFileDrive, "File Drive");

 		_LIT(KFileAdopt, "File Adopt");

 		_LIT(KFsClose, "Fs Close");

 		_LIT(KFsConnect, "Fs Connect");

 		_LIT(KFsGetSystemDrive, "Fs GetSystemDrive");

 		_LIT(KFsCreatePrivatePath, "Fs CreatePrivatePath");

 		_LIT(KFsPrivatePath, "Fs PrivatePath");

 		_LIT(KFsVolumeIoParam, "Fs VolumeIoParam");

 		_LIT(KFsEntry, "Fs Entry");

 		_LIT(KFsAtt, "Fs Att");

 		_LIT(KFileCreateTemp, "File CreateTemp");

 		_LIT(KFileAttach, "File Attach");

 		_LIT(KBytesWritten, "File Bytes Written");

 		_LIT(KBytesRead, "File Bytes Read");

 		TPtrC KText[] = 

 			{

 			KFileCreate(), KFileOpen(), KFileClose(), KFileDelete(), KFileRead(), KFileWrite(), KFileSeek(), KFileSize(),

 			KFileSetSize(), KFileSync(), KFileDrive(), KFileAdopt(), KFsClose(), KFsConnect(), KFsGetSystemDrive(), 

 			KFsCreatePrivatePath(), KFsPrivatePath(), KFsVolumeIoParam(), KFsEntry(), KFsAtt(), KFileCreateTemp(), 

 			KFileAttach(), KBytesWritten(), KBytesRead()

 			};

 		for(TInt i=0;i<countersValues.Length();++i)

 			{

 			if(countersValues[i] == TChar(';'))	

 				{

 				countersValues[i] = TChar(' ');	

 				}

 			}

 		TInt idx = 0;

 		TLex8 lex(countersValues);

 		while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))

 			{

 			TPtrC8 num8 = lex.NextToken();

 			TBuf<20> num;

 			num.Copy(num8);

 			TheTest.Printf(_L("==Operation %S, count %S\r\n"), &KText[idx], &num);

 			++idx;

 			}

 		}

 	}

 void PrintOsCall(TSqlResourceProfiler& aProfiler)

 	{

 	TBuf8<300> countersValues;

 	if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterOsCall, countersValues) == KErrNone)

 		{

 		TheTest.Printf(_L("=========================\r\n"));

 		_LIT(KEOsFileClose, "FileClose");

 		_LIT(KEOsFileRead, "FileRead");

 		_LIT(KEOsFileWrite, "FileWrite");

 		_LIT(KEOsFileTruncate, "FileTruncate");

 		_LIT(KEOsFileSync, "FileSync");

 		_LIT(KEOsFileFileSize, "FileSize");

 		_LIT(KEOsFileLock, "FileLock");

 		_LIT(KEOsFileUnlock, "FileUnlock");

 		_LIT(KEOsFileCheckReservedLock, "FileCheckReservedLock");

 		_LIT(KEOsFileFileControl, "FileIoControl");

 		_LIT(KEOsFileSectorSize, "FileSectorSize");

 		_LIT(KEOsFileDeviceCharacteristics, "FileDeviceCharacteristics");

 		_LIT(KEOsVfsOpen, "VfsOpen");

 		_LIT(KEOsVfsDelete, "VfsDelete");

 		_LIT(KEOsVfsAccess, "VfsAccess");

 		_LIT(KEOsVfsFullPathName, "VfsFullPathName");

 		_LIT(KEOsVfsRandomness, "VfsRandomnes");

 		_LIT(KEOsVfsSleep, "VfsSleep");

 		_LIT(KEOsVfsCurrentTime, "VfsCurrentTime");

 		_LIT(KEOsVfsGetLastError, "VfsGetLastError");

 		TPtrC KText[] = 

 			{

 			KEOsFileClose(), KEOsFileRead(), KEOsFileWrite(), KEOsFileTruncate(), KEOsFileSync(), 

 			KEOsFileFileSize(), KEOsFileLock(), KEOsFileUnlock(), KEOsFileCheckReservedLock(), KEOsFileFileControl(), 

 			KEOsFileSectorSize(), KEOsFileDeviceCharacteristics(), 

 			KEOsVfsOpen(), KEOsVfsDelete(), KEOsVfsAccess(), KEOsVfsFullPathName(), KEOsVfsRandomness(), KEOsVfsSleep(), 

 			KEOsVfsCurrentTime(), KEOsVfsGetLastError()};

 		for(TInt i=0;i<countersValues.Length();++i)

 			{

 			if(countersValues[i] == TChar(';'))	

 				{

 				countersValues[i] = TChar(' ');	

 				}

 			}

 		TInt idx = 0;

 		TLex8 lex(countersValues);

 		while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))

 			{

 			TPtrC8 num8 = lex.NextToken();

 			TBuf<20> num;

 			num.Copy(num8);

 			TheTest.Printf(_L("==Operation %S, count %S\r\n"), &KText[idx], &num);

 			++idx;

 			}

 		}

 	}

 void PrintOsCallTime(TSqlResourceProfiler& aProfiler)

 	{

 	TBuf8<300> callTimes;

 	if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterOsCallTime, callTimes) == KErrNone)

 		{

 		TheTest.Printf(_L("=========================\r\n"));

 		_LIT(KEOsFileClose, "FileClose");

 		_LIT(KEOsFileRead, "FileRead");

 		_LIT(KEOsFileWrite, "FileWrite");

 		_LIT(KEOsFileTruncate, "FileTruncate");

 		_LIT(KEOsFileSync, "FileSync");

 		_LIT(KEOsFileFileSize, "FileSize");

 		_LIT(KEOsFileLock, "FileLock");

 		_LIT(KEOsFileUnlock, "FileUnlock");

 		_LIT(KEOsFileCheckReservedLock, "FileCheckReservedLock");

 		_LIT(KEOsFileFileControl, "FileIoControl");

 		_LIT(KEOsFileSectorSize, "FileSectorSize");

 		_LIT(KEOsFileDeviceCharacteristics, "FileDeviceCharacteristics");

 		_LIT(KEOsVfsOpen, "VfsOpen");

 		_LIT(KEOsVfsDelete, "VfsDelete");

 		_LIT(KEOsVfsAccess, "VfsAccess");

 		_LIT(KEOsVfsFullPathName, "VfsFullPathName");

 		_LIT(KEOsVfsRandomness, "VfsRandomnes");

 		_LIT(KEOsVfsSleep, "VfsSleep");

 		_LIT(KEOsVfsCurrentTime, "VfsCurrentTime");

 		_LIT(KEOsVfsGetLastError, "VfsGetLastError");

 		TPtrC KText[] = 

 			{

 			KEOsFileClose(), KEOsFileRead(), KEOsFileWrite(), KEOsFileTruncate(), KEOsFileSync(), 

 			KEOsFileFileSize(), KEOsFileLock(), KEOsFileUnlock(), KEOsFileCheckReservedLock(), KEOsFileFileControl(), 

 			KEOsFileSectorSize(), KEOsFileDeviceCharacteristics(), 

 			KEOsVfsOpen(), KEOsVfsDelete(), KEOsVfsAccess(), KEOsVfsFullPathName(), KEOsVfsRandomness(), KEOsVfsSleep(), 

 			KEOsVfsCurrentTime(), KEOsVfsGetLastError()};

 		for(TInt i=0;i<callTimes.Length();++i)

 			{

 			if(callTimes[i] == TChar(';'))	

 				{

 				callTimes[i] = TChar(' ');	

 				}

 			}

 		TInt idx = 0;

 		TLex8 lex(callTimes);

 		while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))

 			{

 			TPtrC8 num8 = lex.NextToken();

 			TBuf<20> num;

 			num.Copy(num8);

 			TheTest.Printf(_L("==Operation %S, time %S us\r\n"), &KText[idx], &num);

 			++idx;

 			}

 		}

 	}

 void PrintIpc(TSqlResourceProfiler& aProfiler)

 	{

 	TBuf8<300> countersValues;

 	if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterIpc, countersValues) == KErrNone)

 		{

 		TheTest.Printf(_L("=========================\r\n"));

 		_LIT(KIpcRq, "IPC requests");

 		_LIT(KIpcRead, "IPC read");

 		_LIT(KIpcWrite, "IPC write");

 		_LIT(KIpcReadBytes, "IPC read bytes");

 		_LIT(KIpcWriteBytes, "IPC write bytes");

 		TPtrC KText[] = 

 			{

 			KIpcRq(), KIpcRead(), KIpcWrite(), KIpcReadBytes(), KIpcWriteBytes()

 			};

 		for(TInt i=0;i<countersValues.Length();++i)

 			{

 			if(countersValues[i] == TChar(';'))	

 				{

 				countersValues[i] = TChar(' ');	

 				}

 			}

 		TInt idx = 0;

 		TLex8 lex(countersValues);

 		while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))

 			{

 			TPtrC8 num8 = lex.NextToken();

 			TBuf<20> num;

 			num.Copy(num8);

 			TheTest.Printf(_L("==Operation %S, count %S\r\n"), &KText[idx], &num);

 			++idx;

 			}

 		}

 	}

 void PrintMemory(TSqlResourceProfiler& aProfiler)

 	{

 	TBuf8<300> countersValues;

 	if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterMemory, countersValues) == KErrNone)

 		{

 		TheTest.Printf(_L("=========================\r\n"));

 		_LIT(KMemorySrvAllocatedCnt, "Server allocated cnt");

 		_LIT(KMemorySrvAllocatedSize, "Server allocated size");

 		_LIT(KMemorySrvFreeSpace, "Server free space");

 		_LIT(KMemorySrvLargestBlockSize, "Server larges block size");

 		_LIT(KMemorySQLiteAllocatedCnt, "SQLite allocated cnt");

 		_LIT(KMemorySQLiteReallocatedCnt, "SQLite reallocated cnt");

 		_LIT(KMemorySQLiteFreedCnt, "SQLite freed cnt");

 		_LIT(KMemorySQLiteAllocatedBytes, "SQLite allocated bytes");

 		_LIT(KMemorySQLiteFreedBytes, "SQLite freed bytes");

 		_LIT(KMemorySQLiteAllocTime, "SQLite alloc, us");

 		_LIT(KMemorySQLiteReallocTime, "SQLite realloc, us");

 		_LIT(KMemorySQLiteFreeTime, "SQLite free, us");

 		TPtrC KText[] = 

 			{

 			KMemorySrvAllocatedCnt(), KMemorySrvAllocatedSize(), KMemorySrvFreeSpace(), KMemorySrvLargestBlockSize(), 

 			KMemorySQLiteAllocatedCnt(), KMemorySQLiteReallocatedCnt(), KMemorySQLiteFreedCnt(), 

 			KMemorySQLiteAllocatedBytes(), KMemorySQLiteFreedBytes(),

 			KMemorySQLiteAllocTime(), KMemorySQLiteReallocTime(), KMemorySQLiteFreeTime()

 			};

 		for(TInt i=0;i<countersValues.Length();++i)

 			{

 			if(countersValues[i] == TChar(';'))	

 				{

 				countersValues[i] = TChar(' ');	

 				}

 			}

 		TInt idx = 0;

 		TLex8 lex(countersValues);

 		while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))

 			{

 			TPtrC8 num8 = lex.NextToken();

 			TBuf<20> num;

 			num.Copy(num8);

 			TheTest.Printf(_L("==%S=%S\r\n"), &KText[idx], &num);

 			++idx;

 			}

 		}

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4088

 @SYMTestCaseDesc		TSqlResouceProfiler - file I/O and configuration test.

 						The test enables the file I/O profiling and then executes a simple INSERT statement

 						and prints out the profiling results. The test also prints the current database configuration.

 @SYMTestActions			TSqlResouceProfiler - file I/O and configuration test.

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		Medium

 @SYMREQ					REQ5792

 */

 void ProfilerTest()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	TInt err = TheDb.Create(KTestDbName1);	

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER, T TEXT)"));

 	TEST2(err, 1);

 	TSqlResourceProfiler profiler(TheDb);

 	PrintConfig(profiler);

 	(void)profiler.Start(TSqlResourceProfiler::ESqlCounterFileIO);

 	(void)profiler.Start(TSqlResourceProfiler::ESqlCounterOsCall);

 	(void)profiler.Start(TSqlResourceProfiler::ESqlCounterOsCallTime);

 	(void)profiler.Start(TSqlResourceProfiler::ESqlCounterIpc);

 	(void)profiler.Start(TSqlResourceProfiler::ESqlCounterMemory);

 	(void)profiler.Reset(TSqlResourceProfiler::ESqlCounterFileIO);

 	(void)profiler.Reset(TSqlResourceProfiler::ESqlCounterOsCall);

 	(void)profiler.Reset(TSqlResourceProfiler::ESqlCounterOsCallTime);

 	(void)profiler.Reset(TSqlResourceProfiler::ESqlCounterIpc);

 	(void)profiler.Reset(TSqlResourceProfiler::ESqlCounterMemory);

 	err = TheDb.Exec(_L("INSERT INTO A VALUES(1, 'ABCDEEFGH')"));

 	TEST2(err, 1);

 	PrintFileIo(profiler);

 	PrintOsCall(profiler);

 	PrintOsCallTime(profiler);

 	PrintIpc(profiler);

 	PrintMemory(profiler);

 	(void)profiler.Stop(TSqlResourceProfiler::ESqlCounterIpc);

 	(void)profiler.Stop(TSqlResourceProfiler::ESqlCounterOsCallTime);

 	(void)profiler.Stop(TSqlResourceProfiler::ESqlCounterOsCall);

 	(void)profiler.Stop(TSqlResourceProfiler::ESqlCounterFileIO);

 	(void)profiler.Stop(TSqlResourceProfiler::ESqlCounterMemory);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	}

 TInt CompoundSelectStackOverflowThreadFunc(void* aData)

 	{

 	CTrapCleanup* tc = CTrapCleanup::New();

 	TEST(tc != NULL);

 	User::SetJustInTime(EFalse);	// disable debugger panic handling

 	TInt* cntptr = reinterpret_cast<TInt*> (aData);

 	TEST(cntptr != NULL);

 	const TInt KSelectStmtCnt = *cntptr;

 	HBufC* buf = HBufC::New(KSelectStmtCnt * 25 + 32);//enough for the "SELECT I FROM A UNION SELECT I FROM A..." string

 	if(!buf)

 		{

 		delete tc;

 		return KErrNoMemory;	

 		}

 	TPtr sql = buf->Des();

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	RSqlDatabase db;

 	TInt err = db.Create(KTestDbName1);

 	if(err != KErrNone)

 		{

 		delete buf;

 		return err;	

 		}

 	err = db.Exec(_L("CREATE TABLE A(I INTEGER);INSERT INTO A VALUES(1);"));

 	if(err < 1)

 		{

 		delete buf;

 		return err;	

 		}

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

 		{

 		sql.Append(_L("SELECT I FROM A UNION ")); 

 		}

 	sql.SetLength(sql.Length() - 7);

 	RSqlStatement stmt;

 	err = stmt.Prepare(db, sql);//This call can crash the server with "stack overflow"

 	stmt.Close(); 

 	db.Close();

 	delete buf;

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	return err;

 	}

 void CompoundSelectStackOverflowTest()

 	{

 	const TInt KMaxSelectStmtCnt = 64;

 	for(TInt cnt=KMaxSelectStmtCnt;cnt>0;--cnt)

 		{

 		TheTest.Printf(_L("SELECT statement count: %d\r\n"), cnt);

 		RThread thread;

 		_LIT(KThreadName,"S2Thread");						//stack	minheap		maxheap

 		TInt err = thread.Create(KThreadName, &CompoundSelectStackOverflowThreadFunc, 0x2000, 0x00100000, 0x02000000, &cnt);

 		TEST2(err, KErrNone);

 		TRequestStatus status;

 		thread.Logon(status);

 		TEST2(status.Int(), KRequestPending);

 		thread.Resume();

 		User::WaitForRequest(status);

 		User::SetJustInTime(ETrue);	// enable debugger panic handling

 		TInt exitType = thread.ExitType();

 		const TDesC& exitCategory = thread.ExitCategory();

 		TInt exitReason = thread.ExitReason();

 		TheTest.Printf(_L("Exit type: %d, exit reason: %d, exit category: %S\r\n"), exitType, exitReason, &exitCategory);

 		thread.Close();

 		if(exitReason == KErrServerTerminated)	//SQL server --> stack overflow

 			{

 			continue;	

 			}

 		TEST2(exitReason, KErrNone);

 		TheTest.Printf(_L("  The test has succeeded with SELECT statement count=%d\r\n"), cnt);

 		break;

 		}

 	}

 /**

 @SYMTestCaseID			PDS-SQL-CT-4198

 @SYMTestCaseDesc		Expired SQL statements test.

 						The test creates a database and opens 2 connections to that database.

 						Connection 2 prepares couple of SELECT and INSERT statements (8-bit and 16-bit).

 						Then connection 1 renames the table used in the already prepared statements.

 						Connection 2 attempts to execute the prepared statements. The execution should fail

 						because the database schema has changed after they were prepared.

 @SYMTestActions			Expired SQL statements test.

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority		High

 @SYMDEF					DEF145236

 */

 void ExpiredStmtTest()

 	{

 	(void)RSqlDatabase::Delete(KTestDbName1);

 	//Create a database and create db connection 1.

 	TInt err = TheDb.Create(KTestDbName1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE A(C1 INTEGER)"));

 	TEST(err >= 0);

 	err = TheDb.Exec(_L("INSERT INTO A(C1) VALUES(1)"));

 	TEST2(err, 1);

 	//Create db connection 2 to the same database, as db connection 1.

 	RSqlDatabase db2;

 	err = db2.Open(KTestDbName1);

 	TEST2(err, KErrNone);

 	//Db connection 2. Prepare SELECT and INSERT, 8-bit and 16-bit statements. 

 	RSqlStatement stmt1, stmt2, stmt3, stmt4;

 	err = stmt1.Prepare(db2, _L("SELECT * FROM A"));

 	TEST2(err, KErrNone);

 	err = stmt2.Prepare(db2, _L8("SELECT * FROM A"));

 	TEST2(err, KErrNone);

 	err = stmt3.Prepare(db2, _L("INSERT INTO A(C1) VALUES(2)"));

 	TEST2(err, KErrNone);

 	err = stmt4.Prepare(db2, _L8("INSERT INTO A(C1) VALUES(3)"));

 	TEST2(err, KErrNone);

 	//Modify the A table structure from the other connection

 	//err = TheDb.Exec(_L("ALTER TABLE A ADD C2 INTEGER"));

 	err = TheDb.Exec(_L("ALTER TABLE A RENAME TO B"));

 	TEST(err >= 0);

 	//Try to execute the already prepared statements.

 	err = stmt1.Next();

 	TEST2(err, KSqlErrSchema);

 	err = stmt1.Next();

 	TEST(err != KSqlAtRow);

 	err = stmt2.Next();

 	TEST(err != KSqlAtRow);

 	err = stmt3.Exec();

 	TEST(err < 0);

 	err = stmt4.Exec();

 	TEST(err < 0);

 	//

 	stmt4.Close();

 	stmt3.Close();

 	stmt2.Close();

 	stmt1.Close();

 	db2.Close();

 	TheDb.Close();

 	err = RSqlDatabase::Delete(KTestDbName1);

 	TEST2(err, KErrNone);

 	}

 void DoTestsL()

 	{

 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3512 RSqlStatement::ColumnCount() tests "));

 	ColumnCountTest();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3513 RSqlStatement::ColumnCount(), non-SELECT tests "));

 	ColumnCountTest2();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3514 RSqlStatement::DeclaredColumnType() tests "));

 	DeclaredColumnTypeTest();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4017 RSqlStatement::ColumnName() tests"));	

 	ColumnNameTest();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4018 RSqlStatement::ParameterName() and RSqlStatement::ParamName() tests"));	

 	ParamNameTest();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4006 DEF115300 - SqlSrv.EXE::!SQL Server when preparing invalid LEFT JOIN sql query "));	

 	DEF115300();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4007 DEF115331 - SQL, bad code coverage for db reindexing if default collation has changed "));

 	DEF115331L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4079 RSqlDatabase::Create() and RSqlDatabase::Open() - injection tests"));	

 	InjectionTest();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4038 Two connections test"));	

 	TwoConnectionsTest();

 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4080 SQL server stack overflow test"));

 	SqlServerStackOverflowTest();

 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4086 RSqlBlobWriteStream/RSqlBlobReadStream injection test"));

 	BlobStreamInjectionTest();

 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4087 Bound parameter values test 1"));

 	BoundParameterValuesTest();

 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4076 Bound parameter values test 2"));

 	BoundParameterValuesTest2();

 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4077 Bound parameter values test 3"));

 	BoundParameterValuesTest3();

 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4083 Bound parameter values test 4"));

 	BoundParameterValuesTest4();

 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4105 Bound parameter values test 5"));

 	BoundParameterValuesTest5();

 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4088 TSqlResourceProfiler - file I/O and configuration test"));

 	ProfilerTest();

 	TheTest.Next( _L(" Compound SELECT, stack overflow test"));

 	CompoundSelectStackOverflowTest();

 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4198 Expired statements test"));

 	ExpiredStmtTest();

 	}

 TInt E32Main()

 	{

 	TheTest.Title();

 	CTrapCleanup* tc = CTrapCleanup::New();

 	__UHEAP_MARK;

 	CreateTestEnv();

 	DeleteTestFiles();

 	TRAPD(err, DoTestsL());

 	DeleteTestFiles();

 	TEST2(err, KErrNone);

 	__UHEAP_MARKEND;

 	TheTest.End();

 	TheTest.Close();

 	delete tc;

 	User::Heap().Check();

 	return KErrNone;

 	}