// Copyright (c) 2006-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:

 // NTT DOCOMO, INC - Fix for Bug 1915 "SQL server panics when using long column type strings"

 //

 // Description:

 //

 #include <e32test.h>

 #include <bautils.h>

 #include <s32stor.h>

 #include <sqldb.h>

 #include "SqlResourceProfiler.h"

 #include "SqlResourceTester.h"

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

 static RFs TheFs;

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

 RSqlDatabase TheDb;

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

 _LIT(KTestDatabase1, "c:\\test\\t_sqldefect_1.db");

 _LIT(KTestDatabase2, "c:\\test\\t_sqldefect_2.db");

 _LIT(KCorruptDb, "c:\\test\\t_SqlShortNonDb.db");

 _LIT(KCorruptDbZ, "z:\\test\\t_SqlShortNonDb.db");	//Created outside this test app

 _LIT(KSecureTestDb1, "c:[21212122]BBDb2.db");		//Created outside this test app

 _LIT(KTestDatabase3, "c:\\test\\t_sqldefect_3.db");

 _LIT(KTestDatabase4, "z:\\test\\t_inc095412.db");	//Created outside this test app

 _LIT(KTestDatabase5, "c:\\test\\t_sqldefect_5.db");

 _LIT(KTestDatabase6, "c:\\test\\t_def120237.db");

 _LIT(KTestDatabase7, "c:\\test\\t_def144027.db");

 _LIT(KTestDatabase7Journal, "c:\\test\\t_def144027.db-journal");

 // This value has been found by performing the OOM test

 // with an allocation limit of 2000 and then taking a value

 // which is just above the allocation failure rate.

 const TInt KDEF115954MaxAllocLimit = 1300;

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

 //Deletes all created test files.

 void DeleteTestFiles()

 	{

 	TheDb.Close();

 	(void)TheFs.Delete(KTestDatabase7Journal);

 	(void)RSqlDatabase::Delete(KTestDatabase7);

 	(void)RSqlDatabase::Delete(KTestDatabase6);

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	(void)RSqlDatabase::Delete(KTestDatabase2);

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	(void)RSqlDatabase::Delete(KCorruptDb);

 	}

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

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

 //Test macros and functions

 void Check1(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		DeleteTestFiles();

 		RDebug::Print(_L("*** Line %d\r\n"), aLine);

 		TheTest(EFalse, aLine);

 		}

 	}

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

 	{

 	if(aValue != aExpected)

 		{

 		DeleteTestFiles();

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

 		TheTest(EFalse, aLine);

 		}

 	}

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

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

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

 //Creates file session instance and the test directory

 void CreateTestEnv()

     {

 	TInt err = TheFs.Connect();

 	TEST2(err, KErrNone);

 	err = TheFs.MkDir(KTestDir);

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

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-CT-1763

 @SYMTestCaseDesc		The test creates database 1 and attaches database 2.

 					    Then the test prepares a SELECT sql statement which is supposed to

 					    retrieve records from the attached database 2. Then the test tries to detach

 					    database 2. The expectation is that the detaching operation must fail.

 					    The database can be detached only when there are no alive sql statements prepared on it.

 @SYMTestPriority		High

 @SYMTestActions			SQL, "Detach database" test.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ5792

                         REQ5793

 */	

 void SqlDetachedDbTest()

 	{

 	TInt err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L8("CREATE TABLE A(Id INTEGER)"));	

 	TEST(err >= 0);

 	err = TheDb.Exec(_L8("INSERT INTO A(Id) VALUES(1)"));	

 	TEST2(err, 1);

 	TheDb.Close();	

 	err = TheDb.Create(KTestDatabase2);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L8("CREATE TABLE B(N INTEGER)"));	

 	TEST(err >= 0);

 	err = TheDb.Exec(_L8("INSERT INTO B(N) VALUES(10)"));	

 	TEST2(err, 1);

 	err = TheDb.Exec(_L8("INSERT INTO B(N) VALUES(20)"));	

 	TEST2(err, 1);

 	TheDb.Close();	

 	err = TheDb.Open(KTestDatabase1);

 	TEST2(err, KErrNone);

 	err = TheDb.Attach(KTestDatabase2, _L("Db2"));

 	TEST2(err, KErrNone);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L8("SELECT * FROM B"));

 	TEST2(err, KErrNone);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	err = TheDb.Detach(_L("Db2"));

 	TEST(err != KErrNone);

 	TPtrC errMsg = TheDb.LastErrorMessage();

 	RDebug::Print(_L("Detach err: %S\r\n"), &errMsg);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	stmt.Close();

 	err = TheDb.Detach(_L("Db2"));

 	TEST2(err, KErrNone);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase2);

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4034

 @SYMTestCaseDesc		Corrupted database test.

 						The test tries to open a corrupted database file which length is too short.

 						The 'database open' operation is expected to fail with KSqlErrNotDb error.

 @SYMTestPriority		High

 @SYMTestActions			Corrupted database test.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ5792

 */

 void CorruptDbFileTest()

 	{

 	TInt err = TheDb.Open(KCorruptDb);

 	TEST2(err, KSqlErrNotDb);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4035

 @SYMTestCaseDesc		Attach database with bad name.

 						Attempt to attach a file which name cannot be parsed.

 						The 'attach database' operation is expected to fail with KErrBadName error.

 @SYMTestPriority		High

 @SYMTestActions			Attach database with bad name.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ5792

 */

 void AttachBadDbFileNameTest()

 	{

 	TInt err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

 	err = TheDb.Attach(_L("\"c:\\test\\d12345678.db\""), _L("Db10"));

 	TEST2(err, KErrBadName);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4036

 @SYMTestCaseDesc		Attach secure database. The client cannot pass the security checks.

 						Attempt to attach a secure database. The client cannot pass the security checks.

 						The 'attach database' operation is expected to fail with KErrPermissionDenied error.

 @SYMTestPriority		High

 @SYMTestActions			Attach secure database. The client cannot pass the security checks.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ5794

 */

 void AttachSecureDbTest()

 	{

 	TInt err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

 	err = TheDb.Attach(KSecureTestDb1, _L("Db10"));

 	TEST2(err, KErrPermissionDenied);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4032

 @SYMTestCaseDesc		Test for defect INC091579 - SQL Panic 7 when streaming BLOB fields.

 						The test creates a database with a table with a BLOB column. Then inserts

 						a record. Then the test makes an attempt to read the BLOB column using a stream - 

 						RSqlColumnReadStream. If the defect is not fixed, the code will panic.

 @SYMTestPriority		High

 @SYMTestActions			Test for defect INC091579 - SQL Panic 7 when streaming BLOB fields.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					INC091579

 */

 void INC091579L()

 	{

 	//Create test database

 	TInt err = TheDb.Create(KTestDatabase3);

 	TEST2(err, KErrNone);

 	_LIT8(KCreateStmt, "CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB)"); 

 	err = TheDb.Exec(KCreateStmt);

 	TEST(err >= 0);

 	//Insert 1 row, using a binary stream

 	_LIT8(KInsertStmt, "INSERT INTO A(Fld1,Fld2) VALUES(:p1,:p2)"); 

 	RSqlStatement stmt; 

 	err = stmt.Prepare(TheDb, KInsertStmt);

 	TEST2(err, KErrNone);

 	err = stmt.BindInt(0, 1);

 	TEST2(err, KErrNone);

 	RSqlParamWriteStream out;

 	err = out.BindBinary(stmt, 1);

 	TEST2(err, KErrNone);

 	const TInt KDataSize = 100;

 	TUint16 columnData[KDataSize];

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

 		{

 		columnData[i] = (TUint16)i;

 		}

 	out.WriteL(columnData, KDataSize);

 	out.CommitL();

 	err = stmt.Exec();

 	TEST2(err, 1);

 	out.Close();

 	stmt.Close();

 	//Try to read the inserted row, using a binary stream

 	_LIT8(KSelectStmt, "SELECT * FROM A WHERE Fld1=1"); 

 	err = stmt.Prepare(TheDb, KSelectStmt);

 	TEST2(err, KErrNone);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	RSqlColumnReadStream in;

 	TInt idx = stmt.ColumnIndex(_L("Fld2"));

 	TInt type = stmt.ColumnType(idx);

 	TInt size = stmt.ColumnSize(idx);

 	err = in.ColumnBinary(stmt,idx); // panic occurs here, if the defect is not fixed

 	TEST2(err, KErrNone);

 	in.Close();

 	//Cleanup

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4033

 @SYMTestCaseDesc		Test for defect INC091580 - SQL returns bogus pointer when too much text in field.

 						The test creates a database with a table with 2 TEXT columns. Then inserts

 						a record using a prepared statement with parameters. 

 						The second text column value is set twice calling RSqlStatement::BindText().

 						Then the test makes an attempt to read the TEXT columns using a SELECT statement - 

 						RSqlStatement. If the defect is not fixed, the RSqlStatement::ColumnText() returns a 

 						bad value for the first TEXT column.

 @SYMTestPriority		High

 @SYMTestActions			Test for defect INC091580 - SQL returns bogus pointer when too much text in field.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					INC091580

 */

 void INC091580L()

 	{

 	_LIT8(KCreateStmt, "CREATE TABLE A(Fld1 INTEGER, Fld2 TEXT, Fld3 TEXT)"); 

 	TInt err = TheDb.Create(KTestDatabase3); 

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(KCreateStmt);

 	TEST(err >= 0);

 	_LIT8(KInsertStmt,"INSERT INTO A(Fld1,Fld2,Fld3) VALUES(1,:p1,:p2)"); 

 	RSqlStatement stmt; 

 	err = stmt.Prepare(TheDb, KInsertStmt); 

 	TEST2(err, KErrNone);

 	err = stmt.BindText(0, _L("AAA"));// "AAA" assigned to p1 parameter

 	TEST2(err, KErrNone);

 	err = stmt.BindText(1,_L("123456789ABCD"));//"123456789ABCD" assigned to p2 parameter (Fld2 column)

 	TEST2(err, KErrNone);

 	err = stmt.BindText(1, _L("123456789ABCDE"));//"123456789ABCDE" assigned to p2 parameter (Fld3 column)

 	TEST2(err, KErrNone);

 	err = stmt.Exec();

 	TEST(err >= 0);

 	stmt.Close();

 	_LIT8(KSelectStmt,"SELECT * FROM A WHERE Fld1=1"); 

 	err = stmt.Prepare(TheDb, KSelectStmt); 

 	TEST2(err, KErrNone);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	TPtrC fld2 = stmt.ColumnTextL(1); // returns bad value if the defect is not fixed

 	TPtrC fld3 = stmt.ColumnTextL(2);

 	TEST(fld2 == _L("AAA"));

 	TEST(fld3 == _L("123456789ABCDE"));

 	//Cleanup

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-CT-1815

 @SYMTestCaseDesc		KSqlErrFull test.

 						Create a test database with a table, which first column is declared as

 						"INTEGER PRIMARY KEY AUTOINCREMENT".

 						Insert one record into the table, initializing the ROWID with 0x7FFFFFFFFFFFFFFF

 						(KMaxTInt64). Try to insert one more record into the table. The operation must

 						fails with KSqlErrDiskFull.

 @SYMTestPriority		High

 @SYMTestActions			Verifying that SQL server returns KSqlErrFull when there are no more available row ids.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ					REQ5792

                         REQ5793

 */

 void SqlErrFullTest()

 	{

 	TInt err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L8("CREATE TABLE A(Id INTEGER PRIMARY KEY AUTOINCREMENT, T TEXT)"));

 	TEST(err >= 0);

 	TBuf8<100> sql;

 	sql.Copy(_L8("INSERT INTO A(ROWID,T) VALUES("));

 	sql.AppendNum(KMaxTInt64);

 	sql.Append(_L8(", 'TTT')"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

 	err = TheDb.Exec(_L8("INSERT INTO A(T) VALUES('UUU')"));

 	TEST2(err, KSqlErrFull);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L8("SELECT ROWID FROM A"));

 	TEST2(err, KErrNone);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	TInt64 val = stmt.ColumnInt64(0);

 	TEST(val == KMaxTInt64);

 	err = stmt.Next();

 	TEST2(err, KSqlAtEnd);

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-CT-1816-0001

 @SYMTestCaseDesc		Test for defect INC094870 - Database became corrupted and cannot be opened.

 						Case 1: Create a test database and set the database encoding to be UTF-8. Create a table.

 						Close and open again the database. "Database open" operation should not panic.

 						Case 2: Create a test database and set the database encoding to be UTF-8. Open two 

 						connections to the database and check the encoding. It should be UTF-8.

 @SYMTestPriority		High

 @SYMTestActions			Test for defect INC094870 - Database became corrupted and cannot be opened.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					INC094870

 */

 void INC094870L()

 	{

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	//Test 1 - with a single database

 	TInt err = TheDb.Create(KTestDatabase3);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L8("PRAGMA cache_size=1000"));

 	TEST(err >= 0);

     err = TheDb.SetIsolationLevel(RSqlDatabase::EReadUncommitted);

 	TEST(err >= 0);

     err = TheDb.Exec(_L8("PRAGMA encoding = \"UTF-8\";"));

 	TEST(err >= 0);

     err = TheDb.Exec(_L8("PRAGMA case_sensitive_like = 0"));

 	TEST(err >= 0);

     err = TheDb.Exec(_L8("CREATE TABLE RDFS_Namespace(NamespaceId        INTEGER NOT NULL,Uri                TEXT NOT NULL,ReadOnly           INTEGER NOT NULL,VID                INTEGER NOT NULL,PRIMARY KEY(NamespaceId),UNIQUE(Uri));"));

 	TEST(err >= 0);

 	//Close and reopen the database. The Open() call should not fail.

     TheDb.Close();

     err  = TheDb.Open(KTestDatabase3); // This call fails if the defect is not fixed

 	TEST2(err, KErrNone);

     TheDb.Close();

 	//Test 2 - with two database connections

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	_LIT8(KEncoding, "encoding=UTF-8");

 	_LIT(KUtf8, "UTF-8");

 	RSqlDatabase db1, db2;

 	//Connection 1: Create a database with default encoding UTF-8.

 	err = db1.Create(KTestDatabase3, &KEncoding);

 	TEST2(err, KErrNone);

 	TBuf<100> buf;

 	//Connection 1: Check the database encoding

 	TSqlScalarFullSelectQuery query(db1);

 	err = query.SelectTextL(_L8("PRAGMA encoding"), buf);

 	TEST2(err, KErrNone);

 	TEST(buf.Find(KUtf8) >= 0);

 	//Connection 1: Create a table

 	err = db1.Exec(_L8("CREATE TABLE Tbl(Id INTEGER, T BLOB)"));

 	TEST(err >= 0);

 	//Connection 1: Check the database encoding

 	err = query.SelectTextL(_L8("PRAGMA encoding"), buf);

 	TEST2(err, KErrNone);

 	TEST(buf.Find(KUtf8) >= 0);

 	//Connection 2: open the same database

 	err = db2.Open(KTestDatabase3);

 	TEST2(err, KErrNone);

 	//Connection 1: Check the database encoding

 	err = query.SelectTextL(_L8("PRAGMA encoding"), buf);

 	TEST2(err, KErrNone);

 	TEST(buf.Find(KUtf8) >= 0);

 	//Connection 2: Check the database encoding

 	query.SetDatabase(db2);

 	err = query.SelectTextL(_L8("PRAGMA encoding"), buf);

 	TEST2(err, KErrNone);

 	TEST(buf.Find(KUtf8) >= 0);

 	//Cleanup

 	db2.Close();

 	db1.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-CT-1817-0001

 @SYMTestCaseDesc		Test for defect INC095412 - Retrieving query results may corrupt heap.

 						Open t_inc095412.db test database and prepare SQL query (the SQL statement is in the test code). 

 						Execute RSqlStatement::Next() and then try to retrieve the text value of column number 1.

 						If the defect is not fixed RSqlStatement::ColumnText() will panic.

 @SYMTestPriority		High

 @SYMTestActions			Test for defect INC095412 - Retrieving query results may corrupt heap.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					INC095412

 */

 void INC095412()

 	{

     TInt err = TheDb.Open(KTestDatabase4);

     TEST2(err, KErrNone);

     RSqlStatement stmt;

     err = stmt.Prepare(TheDb, _L("SELECT ObjId, Uri, InstanceOf, Flags, p1.PropertyId, p1.PropertyTypeId, p1.Value, p1.Source, p1.Confidence FROM Objects JOIN Properties p1 ON ObjId = p1.HostObjId WHERE  (  ( (NOT Flags%3) = ? AND (NOT Flags%11) = ? AND InstanceOf IN  ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ?  )  ) OR  ( (NOT Flags%3) = ? AND (NOT Flags%11) = ? AND InstanceOf IN  ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ?  )  ) OR  ( (NOT Flags%3) = ? AND (NOT Flags%11) = ? AND InstanceOf IN  ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ?  )  ) OR  ( (NOT Flags%3) = ? AND (NOT Flags%11) = ? AND InstanceOf IN  ( ? , ? , ? , ?  )  )  );"));

     TEST2(err, KErrNone);

     const TInt KPrmValues[] = {0, 0, 33, 40, 47, 45, 43, 42, 50, 39, 51, 44, 41, 46, 38, 48, 49, 0, 0, 26, 40, 53, 54, 57, 52, 39, 58, 56, 41, 38, 55, 0, 0, 26, 40, 53, 54, 57, 52, 39, 58, 56, 41, 38, 55, 0, 0, 38, 40, 39, 41};

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

     	{

     	err = stmt.BindInt(i, KPrmValues[i]);

     	TEST2(err, KErrNone);

     	}

     err = stmt.Next();

     TEST2(err, KSqlAtRow);

     TPtrC ptr;

     stmt.ColumnText(1, ptr); // May corrupt heap and panic the test application if the defect is not fixed!

     stmt.Close();

     TheDb.Close();

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3427

 @SYMTestCaseDesc		Test for DEF104242 - The SQL server fails to open database with default security policy only.

 						The test plays with C:[21212125]T_OneDefPolicy.db secure database, which was created by

 						an external tool and the database security policy table contains just a single record

 						with the default security policy. The default security policy is set to be 

 						TSecurityPolicy::EAlwaysPass. The test attempts to read from the database, modify the database

 						content, modify the database schema.

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF104242 - The SQL server fails to open database with default security policy only.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF104242

 */

 void DEF104242()

 	{

 	TInt err = TheDb.Open(_L("C:[21212125]T_OneDefPolicy.db"));

 	TEST2(err, KErrNone);

 	//Read

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("SELECT t1key, data from t1"));

 	TEST2(err, KErrNone);

 	while((err = stmt.Next()) == KSqlAtRow)

 		{

 		TheTest.Printf(_L("t1key=%d\r\n"), stmt.ColumnInt(0));

 		}

 	TEST2(err, KSqlAtEnd);

 	stmt.Close();

 	//Write

 	err = TheDb.Exec(_L("INSERT INTO t1(t1key) VALUES(12)"));

 	TEST2(err, 1);

 	//Schema

 	err = TheDb.Exec(_L("CREATE TABLE AAA(Id INTEGER)"));

 	TEST(err >= 0);

 	//Cleanup

 	TheDb.Close();

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3430

 @SYMTestCaseDesc		Test for DEF104437 - RSqlStatement::Next() panics the SQL server with KERN-EXEC 3.

 						The test attempts to execute 2 SELECT queries ("IN" and "IN + JOIN"). The table, on

 						which queries operate, has multi-column primary key. The right-hand side of the 

 						"IN" operator contains NULL.

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF104437 - RSqlStatement::Next() panics the SQL server with KERN-EXEC 3.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF104437

 */

 void DEF104437()

 	{

 	//Test case 1 - "IN" + "JOIN"

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	TInt err = TheDb.Create(KTestDatabase5);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE inmk(cls TEXT,sec INTEGER,inst INTEGER)"));

 	TEST(err >= 0);

 	err = TheDb.Exec(_L("INSERT INTO inmk VALUES ('ORD', 2751, 2750)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("CREATE TABLE clss(hrar TEXT,cls TEXT,PRIMARY KEY (hrar, cls))"));

 	TEST(err >= 0);

 	err = TheDb.Exec(_L("CREATE TABLE rels(prnt_inst INTEGER,chld_inst INTEGER)"));

 	TEST(err >= 0);

 	RSqlStatement stmt;

 	_LIT(KSelectSql,

 	"SELECT I.sec\

 	  FROM inmk I\

 	   LEFT JOIN\

 	     rels R ON R.prnt_inst = I.inst\

 	   LEFT JOIN\

 	      inmk UI ON UI.inst = R.chld_inst\

 	   LEFT JOIN\

 	     clss C1U ON C1U.cls = UI.cls AND C1U.hrar = 'STH'\

 	   LEFT JOIN\

 	     clss C10U ON C10U.hrar = c1u.hrar AND C10U.cls IN (C1U.cls)\

 	  WHERE I.sec = 2751;");

 	err = stmt.Prepare(TheDb, KSelectSql);

 	TEST2(err, KErrNone);

 	while((err = stmt.Next()) == KSqlAtRow)

 		{

 		TInt val = stmt.ColumnInt(0);

 		TEST2(val, 2751);

 		TheTest.Printf(_L("column value=%d\r\n"), val);

 		}

 	TEST2(err, KSqlAtEnd);

 	stmt.Close();

 	TheDb.Close();

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

 	//Test case 2 - "IN"

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	err = TheDb.Create(KTestDatabase5);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE b(y,z,PRIMARY KEY(y, z))"));

 	TEST(err >= 0);

 	err = stmt.Prepare(TheDb, _L("SELECT * FROM b WHERE y = NULL AND z IN ('hello')"));

 	TEST2(err, KErrNone);

 	while((err = stmt.Next()) == KSqlAtRow)

 		{

 		}

 	TEST2(err, KSqlAtEnd);

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3442

 @SYMTestCaseDesc		Test for DEF105259 - SQL, RSqlColumnReadStream's internal buffer may become invalid.

 						The test does the following steps:

 						1) Create a table: CREATE TABLE A(Name TEXT, Data BLOB);

 						2) Insert only one record in A, such that, the "Name" column length is less than 

 						   8 characters, the "Data" column length is 1K bytes.

 						3) Create RSqlStatement object with the following SQL statement: SELECT * FROM A

 						4) Call RSqlStatement::Next() to get the record

 						5) Create RSqlColumnReadStream for column 0 (the "Name" column)

 						6) Try to access the "Data" column value, without using a stream

 						7) Try to read the "Name" column using the stream

 						8) Compare the read "Name" column value vs. the original column value (at the moment 

 						   when the table record was stored)

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF105259 - SQL, RSqlColumnReadStream's internal buffer may become invalid.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF105259

 */

 void DEF105259L()

 	{

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	TInt err = TheDb.Create(KTestDatabase3);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

 	const TInt KBlobDataSize = 1024;

 	HBufC* recBuf = HBufC::New(KBlobDataSize * 2 + 100);

 	TEST(recBuf != NULL);

 	TPtr sql = recBuf->Des();

 	sql.Copy(_L("INSERT INTO A(Name,Data) VALUES('A12',x'"));

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

 		{

 		TBuf<2> tmp;

 		tmp.AppendFormat(_L("%02X"), i % 256);

 		sql.Append(tmp);

 		}

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

 	err = TheDb.Exec(sql);

 	TEST2(err, 1);

 	delete recBuf;

 	RSqlStatement stmt;

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

 	TEST2(err, KErrNone);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	RSqlColumnReadStream strm;

 	err = strm.ColumnText(stmt, 0);

 	TEST2(err, KErrNone);

 	TPtrC8 data;

 	err = stmt.ColumnBinary(1, data);

 	TEST2(err, KErrNone);

 	TBuf<10> name;

 	strm.ReadL(name, 3);

 	TEST(name == _L("A12"));

 	strm.Close();	

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3470

 @SYMTestCaseDesc		Test for DEF105681 - SQL, HReadOnlyBuf::ConstructL() sets a pointer to a local TPtr8 variable.

 						The test creates a database with a table: A(Name TEXT, Data BLOB). One record is inserted

 						in the table. Then the test creates a statement object with "SELECT * FROM A" sql statement.

 						The test moves the statement cursor on the record and attempts to access the BLOB column

 						using a stream. When the stream object is created, the test attempts to create an embedded

 						store object from the stream, using CEmbeddedStore::FromLC(strm) call. If the defect

 						is not fixed, the call will panic.

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF105681 - SQL, HReadOnlyBuf::ConstructL() sets a pointer to a local TPtr8 variable.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF105681

 */

 void DEF105681L()

 	{	

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	TInt err = TheDb.Create(KTestDatabase3);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

 	err = TheDb.Exec(_L("INSERT INTO A(Name,Data) VALUES('A12',x'0400000000')"));

 	TEST2(err, 1);

 	RSqlStatement stmt;

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

 	TEST2(err, KErrNone);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	RSqlColumnReadStream strm;

 	err = strm.ColumnBinary(stmt, 1);

 	TEST2(err, KErrNone);

 	CEmbeddedStore* store = CEmbeddedStore::FromLC(strm);

 	CleanupStack::PopAndDestroy(store);

 	strm.Close();	

 	stmt.Close();

 	//Testing with a NULL binary column value

 	err = TheDb.Exec(_L("INSERT INTO A(Name,Data) VALUES('BBB',NULL)"));

 	TEST2(err, 1);

 	err = stmt.Prepare(TheDb, _L("SELECT * FROM A WHERE Name='BBB'"));

 	TEST2(err, KErrNone);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	err = strm.ColumnBinary(stmt, 1);

 	TEST2(err, KErrNone);

 	store = NULL;

 	TRAP(err, store = CEmbeddedStore::FromL(strm));

 	TEST2(err, KErrEof);

 	delete store;

 	strm.Close();	

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3476

 @SYMTestCaseDesc		Test for DEF106391 - SQL server does not deallocate the already allocated memory.

 						The test is executed only on the Emulator, because its execution depends on the amount

 						of the available memory and the amount of free disk space - factors which cannot be easily 

 						resolved on target hardware.

 						The test creates a database with a table: T(Id INTEGER, Data BLOB). 

 						One record with a BLOB (either 0.79Mb or 0.9Mb) is inserted using RSqlDatabase::Exec().

 						Another record with a BLOB (either 1.58 or 1.8Mb) is inserted using RSqlStatement and BLOB parameter.

 						If the defect is not fixed, after the first INSERT the SQL server will not free occupied by

 						the statement memory. The available heap memory won't be enough for the execution of the second INSERT statement.

 						The second INSERT will fail with KErrNoMemory.

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF106391 - SQL server does not deallocate the already allocated memory.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF106391

 */

 void DEF106391()

 	{

 #if defined __WINS__ ||	defined __WINSCW__

 #ifndef SYMBIAN_USE_SQLITE_VERSION_3_6_4

     const TInt KBlobSize = 900 * 1024;

 #else

     const TInt KBlobSize = 790 * 1024;

 #endif    

 	_LIT8(KConfigStr, "encoding=UTF-8");

 	HBufC8* sqlBuf = HBufC8::New(KBlobSize * 2 + 200);//"+ 200" - for the SQL INSERT statement

 	TEST(sqlBuf != NULL);

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	//Step 1: insert a record with a very large BLOB column (using RSqlDatabase::Exec())

 	//        (the operation is rolled back because there may not be enough disk space)

 	TVolumeInfo volInfo;

 	TInt err = TheFs.Volume(volInfo);

 	TEST2(err, KErrNone);

 	TheTest.Printf(_L("INSERT#1, Volume size: %ldK  Free space: %ldK\r\n"), volInfo.iSize / 1024, volInfo.iFree / 1024);

 	TheTest.Printf(_L("Test BLOB size: %dK\r\n"), KBlobSize / 1024);

 	err = TheDb.Create(KTestDatabase5, &KConfigStr);

 	TEST2(err, KErrNone);

 	TSqlResourceProfiler profiler(TheDb);

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

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

 	TEST(err >= 0);

 	TPtr8 sql = sqlBuf->Des();

 	sql.Copy(_L8("BEGIN TRANSACTION;INSERT INTO T(Id,Data) VALUES(1, x'"));

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

 		{

 		sql.Append(_L8("A5"));

 		}

 	sql.Append(_L8("');"));	

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

 	err = TheDb.Exec(sql);

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("ROLLBACK TRANSACTION"));

 	TEST(err >= 0);

 	TBuf8<32> profilerRes8;

 	TBuf<32> profilerRes;

 	if(profiler.Query(TSqlResourceProfiler::ESqlCounterMaxAlloc, profilerRes8) == KErrNone)

 		{

 		profilerRes.Copy(profilerRes8);

 		TheTest.Printf(_L("RSqlDatabase::Exec(): <SQL server max alloc>;<SQLite max alloc>=%S\r\n"), &profilerRes);

 		}

 	//Step 2: insert a record with a very large BLOB column (using RSqlStatement::Exec())

 	//        (the operation is rolled back because there may not be enough disk space)

 	err = TheFs.Volume(volInfo);

 	TEST2(err, KErrNone);

 	TheTest.Printf(_L("INSERT#2, Volume size: %ldK  Free space: %ldK\r\n"), volInfo.iSize / 1024, volInfo.iFree / 1024);

 	TheTest.Printf(_L("Test BLOB size: %dK\r\n"), sql.Length() / 1024);

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

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("INSERT INTO T(Id, Data) VALUES(2, :V)"));

 	TEST2(err, KErrNone);

 	err = stmt.BindBinary(0, sql);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

 	err = stmt.Exec();

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("ROLLBACK TRANSACTION"));

 	TEST(err >= 0);

 	stmt.Close();

 	if(profiler.Query(TSqlResourceProfiler::ESqlCounterMaxAlloc, profilerRes8) == KErrNone)

 		{

 		profilerRes.Copy(profilerRes8);

 		TheTest.Printf(_L("RSqlStatement::Bind/Exec(): <SQL server max alloc>;<SQLite max alloc>=%S\r\n"), &profilerRes);

 		}

 	delete sqlBuf;

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

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 #endif// defined __WINS__ || defined __WINSCW__	

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3501

 @SYMTestCaseDesc		Test for DEF109025 - SQL, dangling long binary/text column value pointer

 						The test does the following steps:

 						1) Create a table: CREATE TABLE A(Name TEXT, Data BLOB);

 						2) Insert only one record in A, such that, the "Name" column length is less than 

 						   8 characters, the "Data" column length is 1K bytes.

 						3) Create RSqlStatement object with the following SQL statement: SELECT * FROM A

 						4) Call RSqlStatement::Next() to get the record

 						5) Allocate a 1024 bytes buffer (so, when the row buffer has to be reallocated, the system will be forced to 

 						   search another block of memory, because the current one is capped by the allocated 1024 bytes)

 						6) Get a pointer to the "name" column value

 						7) Get a pointer to the "data" column value

 						8) Check the "name" column value. If the defect still exists, the "name" pointer will point to a deleted 

 						   block of memory.

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF109025 - SQL, dangling long binary/text column value pointer.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF109025

 */

 void DEF109025()

 	{

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	TInt err = TheDb.Create(KTestDatabase3);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

 	const TInt KBlobDataSize = 1024;

 	HBufC* recBuf = HBufC::New(KBlobDataSize * 2 + 100);

 	TEST(recBuf != NULL);

 	TPtr sql = recBuf->Des();

 	sql.Copy(_L("INSERT INTO A(Name,Data) VALUES('A12',x'"));

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

 		{

 		TBuf<2> tmp;

 		tmp.AppendFormat(_L("%02X"), i % 256);

 		sql.Append(tmp);

 		}

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

 	err = TheDb.Exec(sql);

 	TEST2(err, 1);

 	delete recBuf;

 	RSqlStatement stmt;

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

 	TEST2(err, KErrNone);

 	err = stmt.Next();

 	TEST2(err, KSqlAtRow);

 	TUint8* mem = new TUint8[1024];	//This memory block will be allocated right after the row buffer,

 	TEST(mem != NULL);				//so the ColumnBinary() call will reallocate the row buffer somewhere else, not at the same address.

 	TPtrC name;

 	err = stmt.ColumnText(0, name);

 	TEST2(err, KErrNone);

 	TPtrC8 data;

 	err = stmt.ColumnBinary(1, data);

 	TEST2(err, KErrNone);

 	TEST(name == _L("A12"));

 	delete [] mem;

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-3546

 @SYMTestCaseDesc		Test for DEF109843 - SQL, RSQLStatement::BindBinary() is causing panic if empty descriptor is passed.

 						The test does the following steps:

 						1) Create a table: CREATE TABLE A(Id INTEGER, Data BLOB);

 						2) Create a RSqlStatement object stmt;

 						3) Prepare stmt with the following SQL statement:

 						INSERT INTO A(Id,Data) VALUES(:Val1,:Val2);

 						4) Set the Val2 field with an empty descriptor("") by using RSqlStatement::BindBinary();

 						5) Execute the statement;

 						6) If the defect still exist, stmt.BindBinary() will cause a panic;

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF109843 - SQL, RSQLStatement::BindBinary() is causing panic if empty descriptor is passed.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF109843

 */

 void DEF109843()

 	{

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	TInt err = TheDb.Create(KTestDatabase5);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("INSERT INTO A(Id,Data) VALUES(:Val1,:Val2)"));

 	TEST2(err, KErrNone);

 	TInt paramIndex;

 	paramIndex = stmt.ParameterIndex(_L(":Val1"));

 	TEST(paramIndex >= 0);

 	err = stmt.BindInt(paramIndex, 1);

 	TEST2(err, KErrNone);

 	paramIndex = stmt.ParameterIndex(_L(":Val2"));

 	TEST(paramIndex >= 0);

 	TPtrC8 emptyEntry (_L8(""));

 	err = stmt.BindBinary(paramIndex, emptyEntry);

 	TEST2(err, KErrNone);

 	err = stmt.Exec();

 	TEST(err >= 0);

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4005

 @SYMTestCaseDesc		Test for DEF114698 - SqlSrv.EXE::!SQL Server Insert/Update Error.

 						The test does the following steps:

 						1) DB3: 

 							CREATE TABLE A(Id INTEGER, Id1 INTEGER)

 							INSERT INTO A(Id,Id1) VALUES(2,3)

 						2) DB2:

 							CREATE TABLE B(Id INTEGER, Id1 INTEGER)

 							INSERT INTO B(Id,Id1) VALUES(2,3)

 						3) DB:

 							CREATE TABLE MAIN(Id INTEGER, Id1 INTEGER)

 							INSERT INTO MAIN(Id,Id1) VALUES(2,3)

 						4) Attach DB2 and DB3 to DB.

 						5) Execute:

 							INSERT INTO B SELECT * FROM B UNION ALL SELECT * FROM MAIN WHERE exists (select * FROM B WHERE B.Id = MAIN.Id);

 							UPDATE A SET Id= (SELECT Id1 FROM B WHERE Id=1) WHERE EXISTS ( SELECT MAIN.Id1 FROM MAIN WHERE MAIN.Id = A.Id1);

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF114698 - SqlSrv.EXE::!SQL Server Insert/Update Error.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF114698

 */

 void DEF114698()

 	{

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	(void)RSqlDatabase::Delete(KTestDatabase2);

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	TInt err = TheDb.Create(KTestDatabase5);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

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

 	TEST2(err, 1);

 	TheDb.Close();

 	err = TheDb.Create(KTestDatabase2);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

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

 	TEST2(err, 1);

 	TheDb.Close();

 	err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

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

 	TEST2(err, 1);

 	err = TheDb.Attach(KTestDatabase2, _L("db2"));

 	TEST2(err, KErrNone);

 	err = TheDb.Attach(KTestDatabase5, _L("db3"));

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("INSERT INTO B SELECT * FROM B UNION ALL SELECT * FROM MAIN WHERE exists (select * FROM B WHERE B.Id = MAIN.Id)"));

 	TEST2(err, 2);

 	err = TheDb.Exec(_L("UPDATE A SET Id= (SELECT Id1 FROM B WHERE Id=1) WHERE EXISTS ( SELECT MAIN.Id1 FROM MAIN WHERE MAIN.Id = A.Id1)"));

 	TEST2(err, 0);

 	err = TheDb.Detach(_L("db3"));

 	TEST2(err, KErrNone);

 	err = TheDb.Detach(_L("db2"));

 	TEST2(err, KErrNone);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase5);

 	(void)RSqlDatabase::Delete(KTestDatabase2);

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4009-0001

 @SYMTestCaseDesc		Test for DEF115556 SqlSrv.EXE::!SQL Server when preparing complex sql query.

 						The test does the following steps:

 						1) Create a database with two tables

 							CREATE TABLE A(Id INTEGER, Id1 INTEGER, F2 BLOB)

 							CREATE TABLE B(Id INTEGER, Id1 INTEGER, F2 BLOB)

 						2) Prepare the following statement

 							DELETE FROM A WHERE Id1 IN (SELECT Id1 FROM B WHERE Id IN (1,11) UNION SELECT * FROM B WHERE Id1=2 ORDER BY Id ASC LIMIT 1)

 						If the defect is not fixed, step (2) asserts in SQLITE.

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF115556 SqlSrv.EXE::!SQL Server when preparing complex sql query.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF115556

 */

 void DEF115556()

 	{

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	TInt err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

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

 	TEST(err >= 0);

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

 	TEST(err >= 0);

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, _L("DELETE FROM A WHERE Id1 IN (SELECT Id1 FROM B WHERE Id IN (1,11) UNION SELECT * FROM B WHERE Id1=2 ORDER BY Id ASC LIMIT 1)"));

 	TEST(err != KErrDied);

 	TPtrC errDescr = TheDb.LastErrorMessage();

 	RDebug::Print(_L("\"Stmt prepare\" %d error. Message:\"%S\"\r\n"), err, &errDescr);

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4012

 @SYMTestCaseDesc		Test for DEF115954: CSession Code = 2 executing SQL stmt in OOM loop.

 						It is an OOM test. In the loop, the test does the following steps:

 						1) Create a database. 

 						2) Set heap failure.

 						3) Open the database

 						4) Execute the statement which caused the panic before this defect is fixed.

 						5) Close the database.

 						If the defect is not fixed, step (5) will panic with CSession Code = 2.

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

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

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

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

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

 @SYMTestPriority		High

 @SYMTestActions			Test for DEF115954: CSession Code = 2 executing SQL stmt in OOM loop.

 @SYMTestExpectedResults Test program must not panic.

 @SYMDEF					DEF115954

 */

 void DEF115954()

 	{

 	TInt err = KErrNone;

 	TInt failingAllocationNo = 0;

 	TInt allocationNo = 0;

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

 	while(allocationNo < KDEF115954MaxAllocLimit)

  		{

 		TheTest.Printf(_L("%d    \r"), allocationNo);

   		RSqlDatabase::Delete(KTestDatabase1);

   		err = TheDb.Create(KTestDatabase1);

   		TEST(err == KErrNone);

   		TheDb.Close(); 

   		const TInt KDelayedDbHeapFailureMask = 0x1000;

   		TSqlResourceTester::SetDbHeapFailure(KDelayedDbHeapFailureMask, ++allocationNo);

   		err = TheDb.Open(KTestDatabase1);

   		TEST(err == KErrNone);

   		err = TheDb.Exec(_L("CREATE TABLE node(id INTEGER PRIMARY KEY,name TEXT);CREATE INDEX node_idx ON node(name);CREATE TABLE edge(orig INTEGER REFERENCES node,dest INTEGER REFERENCES node,PRIMARY KEY(orig, dest));CREATE INDEX edge_idx ON edge(dest,orig)"));

   		TheDb.Close();

   		if(err != KErrNoMemory)

 			{

 			TEST2(err, KErrNone);	

 			}

 		else

 			{

 			failingAllocationNo = allocationNo;

 			}

   		TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0);

   		}

 	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

 	TEST(err == KErrNone);

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4008

 @SYMTestCaseDesc		Test for DEF115567 - Critical SQLite defect that can cause database corruption during UPDATE/DELETE.

 						The test creates 2 tables with couple of records and a "BEFORE DELETE" trigger on the first table.

 						Then the test deletes 1 record from the first table and checks the record count in both tables.

 						In both cases the record count should not be 0.

 @SYMTestPriority		Critical

 @SYMTestActions			Test for DEF115567 - Critical SQLite defect that can cause database corruption during UPDATE/DELETE.

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF115567

 */

 void DEF115567L()

 	{

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	TInt err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE t3(a INTEGER, b INTEGER);CREATE TABLE t4(a INTEGER, b INTEGER)"));

 	TEST(err >= 0);

 	err = TheDb.Exec(_L("CREATE TRIGGER t3_t BEFORE DELETE ON t3 BEGIN DELETE FROM t4 WHERE t4.a = old.a;DELETE FROM t3 WHERE a = 2;END"));

 	TEST(err >= 0);

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

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO t3 VALUES(2,2)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO t3 VALUES(3,3)"));

 	TEST2(err, 1);

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

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("INSERT INTO t4 VALUES(3,3)"));

 	TEST2(err, 1);

 	err = TheDb.Exec(_L("DELETE FROM t3 WHERE a=1 OR a=2"));

 	TEST2(err, 1);

 	TSqlScalarFullSelectQuery query(TheDb);

 	TInt rowcnt = query.SelectIntL(_L("SELECT COUNT(*) FROM t3"));

 	TEST2(rowcnt, 1);

 	rowcnt = query.SelectIntL(_L("SELECT COUNT(*) FROM t4"));

 	TEST2(rowcnt, 1);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}	

 /**

 @SYMTestCaseID			SYSLIB-SQL-CT-4019

 @SYMTestCaseDesc		Test for DEF116397 Attaching a non-db file should return KSqlErrNotDb rather than KErrEof

 @SYMTestPriority		Medium

 @SYMTestActions			Test for DEF116397 - SQL, Attaching database returns KErrEof(-25).

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF116397

 */

 void DEF116397()

 	{

 	//Test error code opening a corrupt db file

 	TInt err = TheDb.Open(KCorruptDb);

 	TEST2(err, KSqlErrNotDb);

 	TheDb.Close();

 	//create a sql db file

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

 	err = TheDb.Exec(_L("CREATE TABLE t3(a INTEGER, b INTEGER);CREATE TABLE t4(a INTEGER, b INTEGER)"));

 	TEST(err >= 0);

 	TheDb.Close();

 	//open the db file

 	err=TheDb.Open(KTestDatabase1);

 	TEST2(err,KErrNone);

 	//try to attach a non db file

 	err=TheDb.Attach(KCorruptDb,_L("db2"));

 	TEST2(err,KSqlErrNotDb);

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase1);			

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-UT-4029

 @SYMTestCaseDesc		Test for DEF119403 - creates a databse, retrieves its Collation Dll Name and makes 

 						sure the Collation Dll Name doesn't contain the path 

 @SYMTestPriority		Medium

 @SYMTestActions			Test for DEF119403 Database re-index unnecessarily during open operation 

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF119403

 */

 void DEF119403L()

 	{

 	//create a sql db file

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	TInt err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

 	TFileName buf;

 	TSqlScalarFullSelectQuery query(TheDb);

 	//Get Collation Dll Name from SYMBIAN_SETTINGS

 	err = query.SelectTextL(_L8("SELECT CollationDllName FROM SYMBIAN_SETTINGS"), buf);

 	TEST2(err, KErrNone);

 	TParse parse;

 	parse.Set(buf, NULL, NULL);

 	//Check that the Collation Dll Name doesn't include the path

 	TEST(!parse.PathPresent());

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}

 // Helper function for DEF120237L()

 TInt ExecuteSelect(RSqlDatabase& aDatabase, const TDesC8& aSelectStatement)

 	{

 	RSqlStatement statement;

 	TInt err = statement.Prepare(aDatabase, aSelectStatement);

 	TEST2(err, KErrNone);

 	TInt ret;

 	TInt count = 0;

 	TheTest.Printf(_L("Results:\n"));

 	while((ret = statement.Next()) == KSqlAtRow)

 	    {  

 	    TPtrC coltext;

 	    err = statement.ColumnText(0, coltext);

 	    TEST2(err, KErrNone);

 	    RDebug::RawPrint(coltext);

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

 	    count++;

 	    }

 	TEST2(ret, KSqlAtEnd);

 	statement.Close();	

 	return count;

 	}

 /**

 @SYMTestCaseID			SYSLIB-SQL-CT-4031

 @SYMTestCaseDesc		Test for DEF120237 - Checks that When using SELECT together with 

                         the LIKE operator the right number of results are returned.

 @SYMTestPriority		Medium

 @SYMTestActions			1) Create a database and fill it with test data.

                         2) Execute a SELECT statement with the LIKE operator and the % wildcard

                         3) Check that the expected number of results are returned.

 @SYMTestExpectedResults The SELECT statements should return the expected number of results.

 @SYMDEF					DEF120237

 */

 void DEF120237L()

 	{

 	const TInt KSelectTest1ExpectedResults = 3;

 	const TInt KSelectTest2ExpectedResults = 3;

 	_LIT8(KCfgStr, "encoding=UTF-8");

 	_LIT8(KCreate, "CREATE TABLE A(Id INTEGER,Name TEXT collate nocase)"); //Adding "collate nocase" allows us to see defect

 	_LIT8(KIndex, "CREATE INDEX name_index on A (name)"); //Adding index allows us to see defect

 	_LIT8(KRecord1, "INSERT INTO A VALUES(1, '\"AAA')");

 	_LIT8(KRecord2, "INSERT INTO A VALUES(2, '\"AAB')");

 	_LIT8(KRecord3, "INSERT INTO A VALUES(3, '\"AAC')");

 	_LIT8(KRecord4, "INSERT INTO A VALUES(4, '&BAA')");

 	_LIT8(KRecord5, "INSERT INTO A VALUES(5, '%BAA')");

 	_LIT8(KRecord6, "INSERT INTO A VALUES(6, '''BAA')");

 	_LIT8(KRecord7, "INSERT INTO A VALUES(7, '''BAB')");

 	_LIT8(KRecord8, "INSERT INTO A VALUES(8, '''BAC')");

 	//Create database

 	RSqlDatabase database;

 	CleanupClosePushL(database);

 	(void*)database.Delete(KTestDatabase6);

 	User::LeaveIfError(database.Create(KTestDatabase6, &KCfgStr));

 	TInt err = database.Exec(KCreate);

 	TEST(err >= KErrNone);

 	err = database.Exec(KIndex);

 	TEST(err >= KErrNone);

 	//Insert Neccessary Data

 	err = database.Exec(KRecord1);

 	TEST2(err, 1);

 	err = database.Exec(KRecord2);

 	TEST2(err, 1);

 	err = database.Exec(KRecord3);

 	TEST2(err, 1);

 	err = database.Exec(KRecord4);

 	TEST2(err, 1);

 	err = database.Exec(KRecord5);

 	TEST2(err, 1);

 	err = database.Exec(KRecord6);

 	TEST2(err, 1);

 	err = database.Exec(KRecord7);

 	TEST2(err, 1);

 	err = database.Exec(KRecord8);

 	TEST2(err, 1);

 	//Case 1 when search criteria is "

 	//Defect: Select does not return result

 	_LIT8(KSelectTest1, "select name from A where name like '\"%'");

 	TInt numResults = ExecuteSelect(database, KSelectTest1);

 	TheTest.Printf(_L("Case 1 Results: %d\n"), numResults);

 	TEST2(numResults, KSelectTest1ExpectedResults);

 	//Case 2 when search criteria is '

 	//Defect: Select returns data beginning with & and % as well

 	_LIT8(KSelectTest2,"select name from A where name like '''%'");

 	numResults = ExecuteSelect(database, KSelectTest2);

 	TheTest.Printf(_L("Case 2 Results: %d\n"), numResults);

 	TEST2(numResults, KSelectTest2ExpectedResults);

 	CleanupStack::PopAndDestroy(1);

 	}

 /**

 @SYMTestCaseID			PDS-SQL-CT-4120

 @SYMTestCaseDesc		Test for DEF125881 - Checks that when a INSERT statement is executed

 						under a I/O failure simulation, the correct error code will be returned

 @SYMTestPriority		Medium

 @SYMTestActions			1) Create a database and fill it with test data.

                         2) Execute a INSERT statement under a I/O failure simulation

                         3) Check that the expected return error code is retruned

 @SYMTestExpectedResults The INSERT statement should return the correct error code under I/O failure

 @SYMDEF					DEF125881

 */

 void DEF125881L()

 	{

 	_LIT(KDbPath, "c:\\t_sqldefect-def125881.db");

 	_LIT(KSchema, "CREATE TABLE test(t TEXT);");

 	_LIT(KInsert, "INSERT INTO test (t) VALUES (\'mkldfmklmklmkldfmkldfmklm\

 												  klcdmklmkldsdklfjwoierthj\

 												  iofnkjwefniwenfwenfjiowen\

 												  mkldfmklmklmkldfmkldfmklm\

 												  klcdmklmkldsdklfjwoierthj\

 												  mkldfmklmklmkldfmkldfmklm\

 												  klcdmklmkldsdklfjwoierthj\

 												  iofnkjwefniwenfwenfjiowen\

 												  mkldfmklmklmkldfmkldfmklm\

 												  klcdmklmkldsdklfjwoierthj\

 												  iofnkjwefniwenfwenfjiowen\

 												  mkldfmklmklmkldfmkldfmklm\

 												  klcdmklmkldsdklfjwoierthj\

 												  iofnkjwefniwenfwenfjiowen\

 												  iofnkjwefniwenfwenfjiowen\

 												  fiwenfwejnfwinsdf2sdf4sdf\');");

 	_LIT(KLogFormat, "After %d operations: %d returned\n");

 	// Create file server session

 	RFs fsSession;

 	CleanupClosePushL(fsSession);

 	User::LeaveIfError(fsSession.Connect());

 	// Open a SQL DB, setup basic schema

 	RSqlDatabase sqlDb;

 	CleanupClosePushL(sqlDb);

 	TRAPD(createErr, sqlDb.OpenL(KDbPath));

 	if (createErr != KErrNone)

 		{

 		sqlDb.CreateL(KDbPath);

 		User::LeaveIfError(sqlDb.Exec(KSchema));

 		}	

 	// Create a SQL statement

 	RSqlStatement stmnt;

 	TInt err = stmnt.Prepare(sqlDb, KInsert);

 	TEST2(err,KErrNone);

 	// Begin test

 	TInt fsError = KErrGeneral;

 	TInt count = 0;

 	const TInt KMaxOps = 300;

 	TSqlResourceProfiler pr(sqlDb);

 	pr.Start(TSqlResourceProfiler::ESqlCounterOsCallDetails);

 	pr.Reset(TSqlResourceProfiler::ESqlCounterOsCallDetails);

 	while (fsError != 1 && count <= KMaxOps)

 		{

 		// Setup for KErrGeneral failure

 		fsSession.SetErrorCondition(KErrGeneral, count);

 		// Database operation

 		fsError = stmnt.Exec();

 		stmnt.Reset();

 		// Test for KErrGeneral

 		TheTest.Printf(KLogFormat, count, fsError);

 		TEST( (fsError == KErrGeneral) || (fsError == 1) || (fsError == KSqlErrIO));

 		// Increment fail-after count

 		++count;

 		}

 	fsSession.SetErrorCondition(KErrNone);

 	pr.Stop(TSqlResourceProfiler::ESqlCounterOsCallDetails);

 	stmnt.Close();

 	CleanupStack::PopAndDestroy(2); // fsSession, sqlDb

 	(void)RSqlDatabase::Delete(KDbPath);

 	}

 /**

 @SYMTestCaseID			PDS-SQL-CT-4128

 @SYMTestCaseDesc		Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.

 						When executing a pragma which deosn't return any results (e.g performing "PRAGMA index_list"

 						on a table with no index. The client panics when RSqlStatement::Next() is called. 

 						This test checks the client does not panic in this case

 @SYMTestPriority		High

 @SYMTestActions			DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases

 @SYMTestExpectedResults Test must not fail

 @SYMDEF					DEF129581

 */

 void DEF129581()

 	{

 	_LIT8(KPragma, "Pragma index_list(T)");

 	_LIT8(KCreateTable, "CREATE TABLE T (A INTEGER)");

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	//create a sql db file and make sure no index is added to it

 	TInt err = TheDb.Create(KTestDatabase1);

 	TEST2(err, KErrNone);

 	//create a table

 	err = TheDb.Exec(KCreateTable);

 	TEST(err >= KErrNone);

 	RSqlStatement stmt;

 	//Executes a "Pragam index_list.." statement

 	err = stmt.Prepare(TheDb, KPragma);

 	TEST2(err, KErrNone);

 	//Calls RSqlStatement::Next() to make sure the client does not panic.

 	err = stmt.Next();

 	TEST2(err, KSqlAtEnd);

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase1);

 	}

 /**

 @SYMTestCaseID          PDS-SQL-CT-4153

 @SYMTestCaseDesc        Test for DEF143047: SQL, default "max parameter count" value, compatibility problem.

                         This test case proves that an SQL statement with more than 1000 parameters can be prepared 

                         successfully. The default value of the SQLITE_MAX_VARIABLE_NUMBER macro is 999. 

                         Changed to 32767 with this defect fix.

 @SYMTestPriority        High

 @SYMTestActions         DEF143047: SQL, default "max parameter count" value, compatibility problem

 @SYMTestExpectedResults Test must not fail

 @SYMDEF                 DEF143047

 */

 void DEF143047()

     {

     (void)RSqlDatabase::Delete(KTestDatabase1);

     TInt err = TheDb.Create(KTestDatabase1);

     TEST2(err, KErrNone);

     _LIT8(KCreateTable, "CREATE TABLE T(A INTEGER)");

     err = TheDb.Exec(KCreateTable);

     TEST(err >= KErrNone);

     const TInt KPrmCount = 1200;

     HBufC8* buf = HBufC8::New(KPrmCount * 2 + 200);

     TEST(buf != NULL);

     TPtr8 sql = buf->Des();

     sql.Copy(_L8("SELECT * FROM T WHERE A IN(?"));

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

         {

         sql.Append(_L8(",?"));

         }

     sql.Append(_L8(")"));

     RSqlStatement stmt;

     err = stmt.Prepare(TheDb,sql);

     if(err != KErrNone)

         {

         TPtrC errdes = TheDb.LastErrorMessage();

         TheTest.Printf(_L("RSqlStatement::Prepare() failed. Err %d, ErrMsg: \"%S\".\r\n"), err, &errdes);

         }

     TEST2(err, KErrNone);

     stmt.Close();

     delete buf;

     TheDb.Close();

     (void)RSqlDatabase::Delete(KTestDatabase1);

     }

 /**

 @SYMTestCaseID          PDS-SQL-UT-4157

 @SYMTestCaseDesc        Test for PDEF143461  Calling CSqlSrvDatabase::LastErrorMessage() does not panic with the descriptor alignment error

 @SYMTestPriority        Normal

 @SYMTestActions         Test for PDEF143461  - CSqlSrvDatabase::LastErrorMessage() alignment problem.

                         This tests the following SQLite Error messages to make sure it doesn't panic:

                         1)library routine called out of sequence

                         2)out of memory

 @SYMTestExpectedResults Test must not fail

 @SYMDEF                 PDEF143461 

 */

 void PDEF143461L()

     {

     (void) RSqlDatabase::Delete(KTestDatabase6);

     //Create and setup the database file

     RSqlDatabase db;

     TInt err =0;

     err = db.Create(KTestDatabase6);

     TEST2(err, KErrNone);

     err = db.Exec(_L("CREATE TABLE t(num INTEGER)"));

     TEST2(err, 1);

     err = db.Exec(_L("INSERT INTO t VALUES(1)"));

     TEST2(err, 1);

     err = db.Exec(_L("INSERT INTO t VALUES(2)"));

     TEST2(err, 1);

     //Purposely commit an error so LastErrorMessage can be called 

     RSqlStatement stmt;

     err = stmt.Prepare(db, _L("DELETE FROM t WHERE ROWID=?"));

     TEST2(err, KErrNone);

     err = stmt.BindInt(0, 1);

     TEST2(err, KErrNone);        

     err = stmt.Exec();

     TEST2(err, 1);

     //Should have reset stmt here

     err = stmt.BindInt(0, 2);

     TEST2(err, KErrNone); 

     err = stmt.Exec();

     TEST2(err, KSqlErrMisuse);

     //Test "library routine called out of sequence" error message 

     //If the defect is not fixed then it will panic here   

     TPtrC errMsg = db.LastErrorMessage();

     RDebug::Print(_L("errMsg=%S\r\n"), &errMsg);

     stmt.Close();

     db.Close();

     TInt allocationNo = 0;

     //The mask allows the out of memory simulation of the SQL Server to be delayed until the database is opened

     const TInt KDelayedDbHeapFailureMask = 0x1000;

     do

         {

         TSqlResourceTester::SetDbHeapFailure(RHeap::EDeterministic |KDelayedDbHeapFailureMask, ++allocationNo);

         err = db.Open(KTestDatabase6);

         TEST2(err, KErrNone);

         err = db.Exec(_L("INSERT INTO t VALUES(3)"));

         TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0);

         TheTest.Printf(_L("%d    \r"), allocationNo);

         //Test "out of memory" error message, if the defect is not fixed then it will panic here   

         TPtrC errMsg = db.LastErrorMessage();

         RDebug::Print(_L("errMsg=%S\r\n"), &errMsg);

         db.Close();

         }

     while (err == KErrNoMemory);

     TEST2(err, 1);

     }

 /**

 @SYMTestCaseID          PDS-SQL-CT-4166

 @SYMTestCaseDesc        Tests for DEF144027: SQL Open returns error if the reported and actual file size are different

 @SYMTestPriority        Medium

 @SYMTestActions         1) Create a simple database and close it (this will automatically delete the journal file

                         2) Create a 15 bytes garbage journal file which is just less than the minimum file size allowed.

                         3) Reopen the database and checks that the open operation does not fail even thou we've used a 

                         garbage journal file which is too small

 @SYMTestExpectedResults The RSqlDatabase::Open operation should not fail

 @SYMDEF                 DEF144027

                         DEF144238

 */

 void DEF144027()

     {

     (void) RSqlDatabase::Delete(KTestDatabase7);

     (void) TheFs.Delete(KTestDatabase7Journal);

     TInt err = TheDb.Create(KTestDatabase7);

     TEST2(err, KErrNone);

     err = TheDb.Exec(_L("CREATE TABLE t1(NUM INTEGER)"));

     TEST2(err, 1);

     err = TheDb.Exec(_L("INSERT INTO t1(NUM) VALUES (1)"));

     TEST2(err, 1);

     TheDb.Close();

     //Created a garbage 15 bytes journal file 

     RFile file;

     err = file.Create(TheFs, KTestDatabase7Journal, EFileWrite);

     TEST2(err, KErrNone);

     _LIT8(KJournalJunkData, "A123456789B1234");//15 bytes

     err = file.Write(0, KJournalJunkData);

     TEST2(err, KErrNone);

     file.Flush();

     file.Close();

     //Here we check the open operation does not return an error, 

     //even though there is a journal file less than 16 bytes

     err = TheDb.Open(KTestDatabase7);

     TEST2(err, KErrNone);

     TheDb.Close();

     }

 /**

 Test defect where calling RSQLStatement::DeclaredColumnType() on a table which contains long (> 20 characters) column type 

 names results in a USER 11 panic.

 This test should pass because these are valid SQL column types 

 */

 void LongColumnTypeTest()

 	{

 	(void)RSqlDatabase::Delete(KTestDatabase3);

 	TInt err = TheDb.Create(KTestDatabase3);

 	TEST2(err, KErrNone);

 	_LIT8(KCreateStmt, "CREATE TABLE t(a CHARACTER VARYING(100000), b NCHAR VARYING(100000), c NATIONAL CHARACTER(100000), d NATIONAL CHARACTER VARYING(100000))");

 	err = TheDb.Exec(KCreateStmt);

 	TEST(err >= 0);

 	//Select all columns (SELECT *)

 	_LIT(KSelectStmt, "SELECT * FROM t");

 	RSqlStatement stmt;

 	err = stmt.Prepare(TheDb, KSelectStmt);

 	TEST2(err, KErrNone);

 	TSqlColumnType colType;

 	err = stmt.DeclaredColumnType(0, colType);

 	TEST2(err,KErrNone);

 	TEST2(colType, ESqlText);

 	err = stmt.DeclaredColumnType(1, colType);

 	TEST2(err,KErrNone);

 	TEST2(colType, ESqlText);

 	err = stmt.DeclaredColumnType(2, colType);

 	TEST2(err,KErrNone);

 	TEST2(colType, ESqlText);

 	err = stmt.DeclaredColumnType(3, colType);

 	TEST2(err,KErrNone);

 	TEST2(colType, ESqlText);

 	stmt.Close();

 	TheDb.Close();

 	(void)RSqlDatabase::Delete(KTestDatabase3); 

 	}

 void DoTestsL()

 	{

 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1763 \"SQL against a detached db\" test "));

 	SqlDetachedDbTest();	

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4034 Corrupted db file (file length too short)"));

 	CorruptDbFileTest();	

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4035 Attempt to attach a file which name cannot be parsed"));

 	AttachBadDbFileNameTest();	

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4036 Attempt to attach a secure database. The client cannot pass the security checks"));

 	AttachSecureDbTest();	

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4032 INC091579 - SQL Panic 7 when streaming BLOB fields"));

 	INC091579L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4033 INC091580 - SQL returns bogus pointer when too much text in field..."));

 	INC091580L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1815 Testing KSqlErrFull error code "));

 	SqlErrFullTest();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1816-0001 INC094870 - [SQL] Database became corrupted and cannot be opened "));

 	INC094870L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1817-0001 INC095412: [SQL] Retrieving query results may corrupt heap "));

  	INC095412();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3427 DEF104242 - The SQL server fails to open database with default security policy only "));

 	DEF104242();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3430 DEF104437 - RSqlStatement::Next() panics the SQL server with KERN-EXEC 3 "));

 	DEF104437();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3442 DEF105259 - SQL, RSqlColumnReadStream's internal buffer may become invalid "));

 	DEF105259L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3470 DEF105681 - SQL, HReadOnlyBuf::ConstructL() sets a pointer to a local TPtr8 variable "));

 	DEF105681L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3476 DEF106391 SQL server does not deallocate the already allocated memory "));

 	DEF106391();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3501 DEF109025 SQL, dangling long binary/text column value pointer "));

 	DEF109025();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3546 DEF109843 SQL, RSQLStatement::BindBinary() is causing panic if empty descriptor is passed "));

 	DEF109843();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4005 DEF114698: SqlSrv.EXE::!SQL Server Insert/Update Error "));

 	DEF114698();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4008 DEF115567 Critical SQLite defect that can cause database corruption during UPDATE/DELETE "));

 	DEF115567L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4009-0001 DEF115556: SqlSrv.EXE::!SQL Server when preparing complex sql query "));

 	DEF115556();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4012 DEF115954: CSession Code = 2 executing SQL stmt in OOM loop ")); 

 	DEF115954();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-4019 DEF116397: SQL, Attaching database returns KErrEof(-25) "));

 	DEF116397();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4029 DEF119403: Database re-index unnecessarily during open operation"));

 	DEF119403L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-4031 DEF120237: SQL, SQLITE3.3.17, \"collate nocase\", wrong results."));

 	DEF120237L();

 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4120 DEF125881: RSqlDatabase::Exec() returns KErrAlreadyExists in I/O failure use cases."));

 	DEF125881L();

     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4128 DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases."));

     DEF129581();

     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4153 DEF143047: SQL, default \"max parameter count\" value, compatibility problem."));

     DEF143047();

     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4157 PDEF143461 : CSqlSrvDatabase::LastErrorMessage() alignment problem"));

     PDEF143461L();

     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4166 DEF144027: SQL Open returns error if the reported and actual file size are different"));

     DEF144027();

     TheTest.Next(_L("RSQLStatement::DeclaredColumnType() causes USER 11 panic when table contains long column type strings"));

     LongColumnTypeTest();

 	}

 TInt E32Main()

 	{

 	TheTest.Title();

 	CTrapCleanup* tc = CTrapCleanup::New();

 	__UHEAP_MARK;

 	CreateTestEnv();

 	DeleteTestFiles();

 	TInt err = RSqlDatabase::Copy(KCorruptDbZ, KCorruptDb);	

 	TEST2(err, KErrNone);

 	TRAP(err, DoTestsL());

 	DeleteTestFiles();

 	TheFs.SetErrorCondition(KErrNone);

 	TheFs.Close();

 	TEST2(err, KErrNone);

 	__UHEAP_MARKEND;

 	TheTest.End();

 	TheTest.Close();

 	delete tc;

 	User::Heap().Check();

 	return KErrNone;

 	}