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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <d32dbms.h>

#include <e32math.h>

#include <e32test.h>

#include <f32file.h>

#include <s32buf.h>

LOCAL_D RTest 			TheTest (_L ("t_dbdefect"));

LOCAL_D CTrapCleanup*	TheTrapCleanup = NULL;

LOCAL_D RSemaphore 		TheWaitToStartSem;

LOCAL_D RSemaphore 		TheWaitForThreadsReadySem;

LOCAL_D RFs 			TheFs;

LOCAL_D RDbs			TheDbs1, TheDbs2;

LOCAL_D RDbNamedDatabase TheDb1, TheDb2;

_LIT (KName,			"ConnectTestThread_");

_LIT (KStart,			"Starting thread %x.\n");

_LIT (KConnect,			"Thread %x: Waiting to connect...\n");

_LIT (KConSuccess,		"Thread %x: Connection succeeded.\n");

_LIT (KConFailed,		"Thread %x: Connection failed. Error %d.\n");

_LIT (KStatus,			"Status of thread %x is %d.\n");

_LIT(KTable, 			"TABLE");

_LIT(KColName,			"Fld");

_LIT(KCol2Name, 		"Fld2");

_LIT(KDbName,			"C:\\DBMS-TST\\TESTDB22.DB");

_LIT(KSQLInsert1, 		"INSERT INTO TABLE (Fld, Fld2) VALUES ('ACDC\\','BLAH')");

_LIT(KSQLInsert2, 		"INSERT INTO TABLE   (Fld) VALUES ('ABCDEFGH')");

_LIT(KSQLInsert3, 		"INSERT INTO TABLE   (Fld) VALUES ('A?CDEFGH')");

_LIT(KSQLInsert4, 		"INSERT INTO TABLE   (Fld) VALUES ('A?*?CDEFGH')");

_LIT(KSQLInsert5, 		"INSERT INTO TABLE   (Fld) VALUES ('A*CDEFGH')");

_LIT(KSQLInsert6, 		"INSERT INTO TABLE   (Fld, Fld2) VALUES ('ADCDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOP','ADCB')");

_LIT(KSQLInsert7, 		"INSERT INTO TABLE   (Fld) VALUES ('XZD\\FZX')");

_LIT(KSqlRequestGranularity, "SELECT Fld FROM test WHERE (Fld LIKE '1' AND Fld LIKE '2') AND Fld LIKE '3'  AND Fld LIKE '4'  AND Fld LIKE '5'  AND Fld LIKE '6'");

_LIT(KText16Name, 		"text16");

_LIT(KTableName, 		"test");

_LIT(KIndexName, 		"test_index");

_LIT(KMaxStringFormat, 	"%0256d");

void TestCleanup()

	{

	TheDb2.Close();

	TheDb1.Close();

	TheDbs2.Close();

	TheDbs1.Close();

	(void)TheFs.Delete(KDbName);

	TheFs.Close();

	}

//-----------------------------------------------------------------------------

//

// Test macros and functions.

//

//-----------------------------------------------------------------------------

// If (!aValue) then the test will be panicked, the test data files will be

// deleted.

LOCAL_C void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		TestCleanup();

		TheTest(EFalse, aLine);

		}

	}

// If (aValue != aExpected) then the test will be panicked, the test data files

// will be deleted.

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

	{

	if(aValue != aExpected)

		{

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

		TestCleanup();

		TheTest(EFalse, aLine);

		}

	}

//Use these to test conditions.

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

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

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

struct TTest

	{

	const TText* result;

	const TText* query;

	};

const TTest KQuery[]=

	{

	{_S("ACDC\\"),_S("SELECT Fld FROM TABLE WHERE  Fld LIKE 'ACDC\\' AND Fld2 LIKE '*BL*'")},

	{_S("A*CDEFGH"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A\\*C*' ESCAPE '\\'")},

	{_S("A?CDEFGH"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A\\?C*' ESCAPE '\\'")},

	{_S("A?*?CDEFGH"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A\\?\\*\\?C*' ESCAPE '\\'")},

	{_S("ADCDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOP"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*1234*'")},

	{_S("BLAH"),_S("SELECT Fld2 FROM TABLE WHERE  Fld LIKE '*AC*' AND Fld2 LIKE '?LA?'")},

	{_S("BLAH"),_S("SELECT Fld2 FROM TABLE WHERE  Fld LIKE 'NOTINTABLE' OR Fld2 LIKE '?LA?'")},

	{_S("ADCDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOP"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*ADC*' AND Fld2 LIKE 'ADC?'")},

	{_S("A*CDEFGH"),_S("SELECT Fld FROM TABLE WHERE Fld LIKE '*\\*C*' ESCAPE '\\'")},

	{_S("XZD\\FZX"),_S("SELECT Fld FROM TABLE WHERE Fld LIKE '*D\\\\*' ESCAPE '\\'")}

	};

const TTest KBadQuery[]=

	{

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE 'A?C' ESCAPE '\\'")},

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE 'A*C' ESCAPE '\\'")},

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '?A\\?C' ESCAPE '\\'")},

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '?A\\?C?' ESCAPE '\\'")},

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A\\??\\?C*' ESCAPE '\\'")},

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A*\\*C*' ESCAPE '\\'")},

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE 'ABC' ESCAPE '\\'")},

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE 'ABC*' ESCAPE '\\'")},

	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*ABC' ESCAPE '\\'")}

	};

const TInt KNumQueries = 10;

const TInt KNumBadQueries = 9;

const TInt KThreadCount	= 3;

const TInt KOneSecond 	= 1000000;

const TInt KDbNameLen   = 255;

const TInt KMaxColName = 32;

static void DoDbmsConnectThreadSubFunctionL (TInt aThreadNumber)

	{

	// The session

	RDbs TheDbSession;

	CleanupClosePushL (TheDbSession);

	RDebug::Print (KStart (), aThreadNumber);

	RDebug::Print (KConnect (), aThreadNumber);

 	// Signal the main thread to continue

 	TheWaitForThreadsReadySem.Signal (1);

	// Wait until we are signalled

	TheWaitToStartSem.Wait ();

	// Connect to Dbms

	TInt r = TheDbSession.Connect ();

	if (r == KErrNone)

		{

		RDebug::Print (KConSuccess (), aThreadNumber);

		TheDbSession.Close ();

		}

	else

		{

		RDebug::Print (KConFailed (), aThreadNumber, r);

		User::Leave (r);

		}

	CleanupStack::PopAndDestroy (1); // session

	}

static TInt DoDbmsConnectThread (TAny* aThreadNumber)

	{

	__UHEAP_MARK;

	CTrapCleanup* trapCleanup = CTrapCleanup::New ();

	__ASSERT_ALWAYS (trapCleanup!=NULL, User::Invariant ());

	TInt* threadNumber = static_cast <TInt*> (aThreadNumber);

	TRAPD (err, DoDbmsConnectThreadSubFunctionL (*threadNumber));

	delete trapCleanup;

	__UHEAP_MARKEND;

	return err;

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0644

@SYMTestCaseDesc        Test for defect no 44697

@SYMTestPriority        Medium

@SYMTestActions         Test for defect fixes

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void Defect_DEF44697L ()

	{

	TheTest.Next (_L (" @SYMTestCaseID:SYSLIB-DBMS-CT-0644 Defect_DEF44697L "));

	__UHEAP_MARK;

  	// find out the number of open handles

	TInt startProcessHandleCount;

	TInt startThreadHandleCount;

	RThread ().HandleCount (startProcessHandleCount, startThreadHandleCount);

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

	// The Test Begins...

 	// Create semaphores

 	::CleanupClosePushL (::TheWaitForThreadsReadySem);

 	User::LeaveIfError (::TheWaitForThreadsReadySem.CreateLocal (0));

 	::CleanupClosePushL (::TheWaitToStartSem);

 	User::LeaveIfError (::TheWaitToStartSem.CreateLocal (0));

 	// Create the threads.

 	RThread createTestThread_1;

 	RThread createTestThread_2;

 	RThread createTestThread_3;

 	TBuf<100> thread_name;

	TInt KThreadNumber1 = 1;

	TInt KThreadNumber2 = 2;

	TInt KThreadNumber3 = 3;

 	// Create the first test thread______________________________

	thread_name = KName ();

	thread_name.AppendNum (KThreadNumber1);

 	User::LeaveIfError (

 		createTestThread_1.Create (thread_name,

								   (TThreadFunction) DoDbmsConnectThread,

								   KDefaultStackSize,

								   KMinHeapSize,

								   KMinHeapSize,

								   &KThreadNumber1));

 	// Default priority of Main thread is EPriorityNormal

 	createTestThread_1.SetPriority(EPriorityMore);

 	TheTest.Printf (_L ("%S thread started\n"), &thread_name);

 	// Request notification when the thread dies.

 	TRequestStatus threadStatus_1;

 	createTestThread_1.Logon (threadStatus_1);

	//___________________________________________________________

 	// Create the second test thread______________________________

	thread_name = KName ();

	thread_name.AppendNum (KThreadNumber2);

 	User::LeaveIfError (

 		createTestThread_2.Create (thread_name,

								   (TThreadFunction) DoDbmsConnectThread,

								   KDefaultStackSize,

								   KMinHeapSize,

								   KMinHeapSize,

								   &KThreadNumber2));

  	// Default priority of Main thread is EPriorityNormal

 	createTestThread_2.SetPriority(EPriorityMore);

 	TheTest.Printf (_L ("%S thread started\n"), &thread_name);

 	// Request notification when the tread dies.

 	TRequestStatus threadStatus_2;

 	createTestThread_2.Logon (threadStatus_2);

	//___________________________________________________________

 	// Create the third test thread______________________________

	thread_name = KName ();

	thread_name.AppendNum (KThreadNumber3);

 	User::LeaveIfError (

 		createTestThread_3.Create (thread_name,

								   (TThreadFunction) DoDbmsConnectThread,

								   KDefaultStackSize,

								   KMinHeapSize,

								   KMinHeapSize,

								   &KThreadNumber3));

  	// Default priority of Main thread is EPriorityNormal

 	createTestThread_3.SetPriority(EPriorityMore);

 	TheTest.Printf (_L ("%S thread started\n"), &thread_name);

 	// Request notification when the tread dies.

 	TRequestStatus threadStatus_3;

 	createTestThread_3.Logon (threadStatus_3);

	//___________________________________________________________

	TheTest (threadStatus_1.Int () == KRequestPending);

	TheTest (threadStatus_2.Int () == KRequestPending);

	TheTest (threadStatus_3.Int () == KRequestPending);

 	// Make threads eligible for execution

 	createTestThread_1.Resume ();

 	createTestThread_2.Resume ();

 	createTestThread_3.Resume ();

	// The way this works is that the main thread blocks until all

	// the test threads are ready (semaphore 1) and then signals them

	// (semaphore 2).

	//

	// 1: Main thread Waits for ALL test threads to become ready.

	// 2: Main thread Signals ALL test threads to run.

	//

	// 1: Test thread Signals Main thread

	// 2: Test thread Waits for Main thread

	//

	// There is still a slight race condition between the

	// test thread signalling (semaphore 1) and then waiting

	// (semaphore 2) which is why we use both higher priority test

	// threads and a timer.

	//

	// The problems come with the way Time slicing works due to

	// other threads of higher priority being run.

	//

	// Higher priority: Ensures the test thread runs before the

	// the main thread.

	//

	// Timer: Safeguards when multiple core processors are being used.

	//

	// The Higher priority fixes the problem on single core processors

	// and multiple cores processors (SMP) where each core can run a

	// thread.

	//

	// It should also ensure that if the system is so busy that it

	// affects the test thread execution, the test thread will still

	// get to the Wait state before the Main thread can Signal.

	//

	// However, on multiple cores the Main thread may run at the same

	// time as the test thread, so we need to make sure that when the

	// test thread Signals it can acheive its Wait state before the

	// Main thread Signals. For example, if the timer has elapsed on the

	// Main thread and the sytem is busy, the test thread should still

	// run before the Main thread due to it higher priority.

	//

	// We also have to think about things like priority inheritance

	// where a thread that has a handle on a Mutex inherits the same

	// priority as a thread Waiting on it. This shouldn't happen for

	// Semaphores as there is no one handle, i.e. no critical section.

	//

	// This higher priority inheritance will take affect when a low

	// priority thread that has a handle on the Mutex blocks because of

	// another medium priority running thread. So in effect a high

	// priority thread Waiting on this Mutex is also blocked.

	//

	// It is also worth noting that on EKA1 emulator, scheduling is

	// performed by windows. On EKA2 emulator scheduling is performed

	// by Symbian so that it is the same as hardware.

	TheWaitForThreadsReadySem.Wait();

	TheWaitForThreadsReadySem.Wait();

	TheWaitForThreadsReadySem.Wait();

  	// Sleep for a while to allow threads to block on the semaphore

  	User::After (KOneSecond<<2); // 4 seconds

 	// Signal all the threads to continue

 	TheWaitToStartSem.Signal (KThreadCount);

 	// Wait for all threads to complete, don't care on the order.

	User::WaitForRequest (threadStatus_1);

	User::WaitForRequest (threadStatus_2);

	User::WaitForRequest (threadStatus_3);

	TheTest.Printf (KStatus, KThreadNumber1, threadStatus_1.Int ());

	TheTest.Printf (KStatus, KThreadNumber2, threadStatus_2.Int ());

	TheTest.Printf (KStatus, KThreadNumber3, threadStatus_3.Int ());

	TheTest (threadStatus_1.Int () == KErrNone);

	TheTest (threadStatus_2.Int () == KErrNone);

	TheTest (threadStatus_3.Int () == KErrNone);

	CleanupStack::PopAndDestroy (&::TheWaitToStartSem);

	CleanupStack::PopAndDestroy (&::TheWaitForThreadsReadySem);

	// The Test Ends...

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

	// check that no handles have leaked

	TInt endProcessHandleCount;

	TInt endThreadHandleCount;

	RThread ().HandleCount (endProcessHandleCount, endThreadHandleCount);

	TheTest (startThreadHandleCount == endThreadHandleCount);

	__UHEAP_MARKEND;

	}

// Test for LIKE Predicate for EDbColLongText16

LOCAL_C void LikePredicateDbColLongText16TestL()

 	{

 	TheTest.Next (_L ("LikePredicateDbColLongText16TestL"));

 	//Creating database

	RFs fsSession;

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

    CleanupClosePushL(fsSession);

	RDbNamedDatabase database;

	User::LeaveIfError(database.Replace(fsSession, KDbName));

	CleanupClosePushL(database);

	//Create table

	CDbColSet* columns= CDbColSet::NewLC();

	TDbCol name(KColName,EDbColLongText16,KDbNameLen);

	name.iAttributes = TDbCol::ENotNull;

	TDbCol name2(KCol2Name,EDbColLongText16,KDbNameLen);

	columns->AddL(name);

	columns->AddL(name2);

   	User::LeaveIfError (database.CreateTable (KTable, *columns));

	CleanupStack::PopAndDestroy(); // columns

    // Insert values into table

    TInt error =	database.Execute(KSQLInsert1);

    TheTest(error>=0);

    error =database.Execute(KSQLInsert2);

    TheTest(error>=0);

    error =database.Execute(KSQLInsert3);

    TheTest(error>=0);

	error =	database.Execute(KSQLInsert4);

	TheTest(error>=0);

	error =	database.Execute(KSQLInsert5);

	TheTest(error>=0);

	error = database.Execute(KSQLInsert6);

	TheTest(error>=0);

	error = database.Execute(KSQLInsert7);

	TheTest(error>=0);

	TheTest.Next(_L("Test for valid LIKE predicate queries"));

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

		{

		RDebug::Print(_L("Executing statement: %s \n"),(KQuery[i].query));

		RDbView view;

		view.Prepare(database, TDbQuery(TPtrC(KQuery[i].query), EDbCompareFolded), view.EReadOnly);

		view.EvaluateAll();

		view.FirstL();

		typedef TBuf<256> TScriptLine;

		TInt count =0;

		while (view.AtRow())

			{

			view.GetL();

			count++;

			RDbColReadStream rd;

			rd.OpenLC(view,1);

			TScriptLine text;

			rd.ReadL(text,view.ColLength(1));

			CleanupStack::PopAndDestroy();

			RDebug::Print(_L("Expected result: %s Actual Result: %S\n"),(KQuery[i].result),&text);

			TInt err = text.Compare(TPtrC(KQuery[i].result));

			TheTest(err ==0);

			view.NextL();

			}

		view.Close();

		}

	// test for illegal statements, check they return KErrArgument

	TheTest.Next(_L("Test that illegal queries return KErrArgument"));

	for(TInt j =0;j<KNumBadQueries;++j)

		{

		RDebug::Print(_L("Executing illegal statement: %s \n"),(KBadQuery[j].query));

		RDbView view;

		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KBadQuery[j].query), EDbCompareFolded), view.EReadOnly);

		TheTest(prepErr==KErrArgument);

		view.Close();

		}

    CleanupStack::PopAndDestroy(&database); // database

    CleanupStack::PopAndDestroy(&fsSession); // fsSession

 	}

 //  for LIKE Predicate for EDbColLongText8

LOCAL_C void LikePredicateDbColLongText8TestL()

 	{

	TheTest.Next (_L ("LikePredicate DbColLongText8 TestL"));

 	//Creating database

	RFs      fsSession;

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

    CleanupClosePushL(fsSession);

	RDbNamedDatabase database;

	User::LeaveIfError(database.Replace(fsSession, KDbName));

	CleanupClosePushL(database);

	//Create table

	CDbColSet* columns= CDbColSet::NewLC();

	TDbCol name(KColName,EDbColLongText8,KDbNameLen);

	name.iAttributes = TDbCol::ENotNull;

	TDbCol name2(KCol2Name,EDbColLongText8,KDbNameLen);

	columns->AddL(name);

	columns->AddL(name2);

	User::LeaveIfError (database.CreateTable (KTable, *columns));

	CleanupStack::PopAndDestroy(); // columns

	// Insert values into the table

 	TInt error =	database.Execute(KSQLInsert1);

    TheTest(error>=0);

    error =database.Execute(KSQLInsert2);

    TheTest(error>=0);

    error =database.Execute(KSQLInsert3);

    TheTest(error>=0);

	error =	database.Execute(KSQLInsert4);

	TheTest(error>=0);

	error =	database.Execute(KSQLInsert5);

	TheTest(error>=0);

	error = database.Execute(KSQLInsert6);

	TheTest(error>=0);

	error = database.Execute(KSQLInsert7);

	TheTest(error>=0);

	TheTest.Next(_L("Test for valid LIKE predicate queries"));

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

		{

		RDebug::Print(_L("Executing statement: %s \n"),(KQuery[i].query));

		RDbView view;

		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KQuery[i].query), EDbCompareFolded), view.EReadOnly);

		TheTest(prepErr>=0);

		TInt evErr = view.EvaluateAll();

		TheTest(evErr==0);

		TBuf8<256> result;

		TBuf8<256> colname;

		result.Copy(TPtrC(KQuery[i].result));

		view.FirstL();

		while (view.AtRow())

			{

			view.GetL();

			RDbColReadStream rd;

			rd.OpenLC(view,1);

			rd.ReadL(colname,view.ColLength(1));

			CleanupStack::PopAndDestroy();

			RDebug::Print(_L("Expected result: %S Actual Result: %S\n"),&result,&colname);

			TInt err = colname.CompareF(result);

			TheTest(err ==0);

			view.NextL();

			}

		view.Close();

		}

		// test for illegal statements, check they return KErrArgument

	TheTest.Next(_L("Test that illegal queries return KErrArgument"));

	for(TInt j =0;j<KNumBadQueries;++j)

		{

		RDebug::Print(_L("Executing illegal statement: %s \n"),(KBadQuery[j].query));

		RDbView view;

		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KBadQuery[j].query), EDbCompareFolded), view.EReadOnly);

		TheTest(prepErr==KErrArgument);

		view.Close();

		}

   	CleanupStack::PopAndDestroy(&database); // database

    CleanupStack::PopAndDestroy(&fsSession); // fsSession

 	}

// Test for LIKE Predicate for EDbColText

LOCAL_C void LikePredicateDbColTextTestL()

 	{

 	TheTest.Next (_L ("LikePredicate DbColText TestL"));

 	//Creating database

	RFs      fsSession;

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

    CleanupClosePushL(fsSession);

	RDbNamedDatabase database;

	User::LeaveIfError(database.Replace(fsSession, KDbName));

	CleanupClosePushL(database);

	//Create table

	CDbColSet* columns= CDbColSet::NewLC();

	TDbCol name(KColName,EDbColText,KDbNameLen);

	name.iAttributes = TDbCol::ENotNull;

	TDbCol name2(KCol2Name,EDbColText,KDbNameLen);

	columns->AddL(name);

	columns->AddL(name2);

	User::LeaveIfError (database.CreateTable (KTable, *columns));

	CleanupStack::PopAndDestroy(); // columns

 	// Insert values into the table

    TInt error =	database.Execute(KSQLInsert1);

    TheTest(error>=0);

    error =database.Execute(KSQLInsert2);

    TheTest(error>=0);

    error =database.Execute(KSQLInsert3);

    TheTest(error>=0);

	error =	database.Execute(KSQLInsert4);

	TheTest(error>=0);

	error =	database.Execute(KSQLInsert5);

	TheTest(error>=0);

	error = database.Execute(KSQLInsert6);

	TheTest(error>=0);

	error = database.Execute(KSQLInsert7);

	TheTest(error>=0);

	TheTest.Next(_L("Test for valid LIKE predicate queries"));

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

		{

		RDebug::Print(_L("Executing statement: %s \n"),(KQuery[i].query));

		RDbView view;

		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KQuery[i].query), EDbCompareFolded), view.EReadOnly);

		if(TPtrC(KQuery[i].result).Length() == 0)

			{

			TheTest(prepErr != KErrNone);

			continue;

			}

		view.EvaluateAll();

		TBufC<256> colname;

		TBufC<256> res;

		view.FirstL();

		while (view.AtRow())

			{

			view.GetL();

			colname = view.ColDes(1);

			res= KQuery[i].result;

			RDebug::Print(_L("Expected result: %s Actual Result: %S\n"),(KQuery[i].result),&colname);

			TInt err =	colname.Compare(TPtrC(KQuery[i].result));

			TheTest(err ==0);

			view.NextL();

			}

		view.Close();

		}

	// test for illegal statements, check they return KErrArgument

	TheTest.Next(_L("Test that illegal queries return KErrArgument"));

	for(TInt j =0;j<KNumBadQueries;++j)

		{

		RDebug::Print(_L("Executing illegal statement: %s \n"),(KBadQuery[j].query));

		RDbView view;

		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KBadQuery[j].query), EDbCompareFolded), view.EReadOnly);

		TheTest(prepErr==KErrArgument);

		view.Close();

		}

    CleanupStack::PopAndDestroy(&database); // database

    CleanupStack::PopAndDestroy(&fsSession); // fsSession

    }

 /**

@SYMTestCaseID 			SYSLIB-DBMS-UT-1592

@SYMTestCaseDesc     	Testing limited-ESCAPE-clause

@SYMTestPriority     	High

@SYMTestActions      	Execute DBMS query with ESCAPE-clause

@SYMTestExpectedResults The test should not fail.

@SYMDEF INC076370

*/

LOCAL_C void Defect_INC076370L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-1592 Defect INC076370 "));

	LikePredicateDbColTextTestL(); //EDbColText

	LikePredicateDbColLongText16TestL(); //EDbColLongText16

	LikePredicateDbColLongText8TestL();	//EDbColLongText8

	}

 /**

@SYMTestCaseID 			SYSLIB-DBMS-UT-1667

@SYMTestCaseDesc     	Testing RdbRowSet::DeleteL() with EDbColLongText16 type columns

@SYMTestPriority     	High

@SYMTestActions      	Create a table with a EDbColLongText16 type column and then use

						RdbRowSet::DeleteL() to delete the current row.

@SYMTestExpectedResults The test should not fail.

@SYMDEF INC083027

*/

LOCAL_C void Defect_INC083027L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-1667 Defect INC083027 "));

	RFs fs;

	CleanupClosePushL(fs);

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

	// create database

	RDbNamedDatabase database;

	CleanupClosePushL(database);

	User::LeaveIfError(database.Replace(fs, _L("c:\\test.db")));

	CDbColSet* columns = CDbColSet::NewLC();

	const TInt maxTextLength = 256;

	TDbCol text16Col(KText16Name, EDbColLongText16, maxTextLength);

	columns->AddL(text16Col);

	TBuf<KMaxColName> targetColName;

	targetColName = KText16Name;

	// create table

	User::LeaveIfError(database.CreateTable(KTableName, *columns));

	//create index

	CDbKey* key = CDbKey::NewLC();

	TInt keyLength = 122;

	TDbKeyCol keyCol(targetColName, keyLength);

	key->AddL(keyCol);

	User::LeaveIfError(database.CreateIndex(KIndexName, KTableName, *key));

	CleanupStack::PopAndDestroy(2);		// key and columns

	//insert rows

	HBufC* sqlQueryBuf = HBufC::NewLC(512);

	TPtr sqlQuery(sqlQueryBuf->Des());

	_LIT(KSQLInsertFormat, "SELECT %S FROM %S");

	sqlQuery.Format(KSQLInsertFormat, &targetColName, &KTableName);

	RDbView insertview;

	User::LeaveIfError(insertview.Prepare(database, TDbQuery(sqlQuery), RDbView::EInsertOnly));

	HBufC* tmpBuf = HBufC::NewLC(maxTextLength);

	TPtr maxString(tmpBuf->Des());

	maxString.Format(KMaxStringFormat, 0);

	insertview.InsertL();

	insertview.SetColL(1, maxString);

	insertview.PutL();

	insertview.Close();

	//delete the row

	RDbView deleteview;

	User::LeaveIfError(deleteview.Prepare(database, TDbQuery(sqlQuery), RDbView::EUpdatable));

	User::LeaveIfError(deleteview.EvaluateAll());

	while (deleteview.NextL())

		{

		deleteview.GetL();

		TRAPD(err , deleteview.DeleteL());

		TheTest(err==KErrNone);

		}

	deleteview.Close();

	CleanupStack::PopAndDestroy(2);  // tmpBuf, sqlQueryBuf

    CleanupStack::PopAndDestroy(&database); // database

    CleanupStack::PopAndDestroy(&fs); // fs

	}

 /**

@SYMTestCaseID          SYSLIB-DBMS-UT-1894

@SYMTestCaseDesc        Testing memory handling in CSqlMultiNode::Concatenate()

@SYMTestPriority        Medium

@SYMTestActions         Execute a special request to a database which will trigger CSqlMultiNode::Concatenate(), and the size of one of the SQL nodes will be divisible by the CSqlMultiNode granularity

@SYMTestExpectedResults The test should not fail or panic.

@SYMDEF INC093657

*/

LOCAL_C void Defect_INC093657L ()

   {

   TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-1894 Defect INC093657 "));

   RFs fs;

   CleanupClosePushL(fs);

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

   // create database

   RDbNamedDatabase database;

   CleanupClosePushL(database);

   User::LeaveIfError(database.Replace(fs, _L("c:\\test.db")));

   CDbColSet* columns = CDbColSet::NewLC();

   const TInt maxTextLength = 256;

   TDbCol column(KColName, EDbColLongText16, maxTextLength);

   columns->AddL(column);

   // create table

   User::LeaveIfError(database.CreateTable(KTableName, *columns));

   CleanupStack::PopAndDestroy();  // columns

   //execute a pointless request that is intended to detect subtle memory corruptions in CSqlMultiNode::Concatenate

   RDbView view;

   TInt err = view.Prepare(database, TDbQuery(KSqlRequestGranularity));

   TheTest(err==KErrNone);

   view.Close();

   database.Destroy();

   CleanupStack::PopAndDestroy(&database); // database

   CleanupStack::PopAndDestroy(&fs); // fs

   }

/**

@SYMTestCaseID			SYSLIB-DBMS-UT-3467

@SYMTestCaseDesc		Test for DEF105615 "DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory".

						The test creates a table with 3 coluumns and a multi-column key (3 columns). The column

						names length is such that when RDbRowSet::ColSetL() is called for retrieving the column

						names, the CDbColSet array data member will make just a single memory allocation, where

						all TDbCol elements will be stored. Then the test repeats 100 times, the following statements:

							<retrieve a colset>;

							<create a copy of colset's last TDbCol element using TDbCol's copy constructor>;

							<create a copy of colset's last TDbCol element using TDbCol's "=" operator>;

						If the test uses the compiler generated TDbCol's copy constructor and "=" operator,

						the test crashes at some iteration, because an invalid memory region is accessed and

						the crash is: KERN-EXEC 3.

						The same test is repeated for TDbKeyCol's copy constructor and "=" operator.

@SYMTestPriority		High

@SYMTestActions			Test for DEF105615 "DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory".

@SYMTestExpectedResults The test must not fail

@SYMREQ					DEF105615

*/

void DEF105615L()

	{

   	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3467 DEF105615 DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory"));

	RFs fs;

	TInt err = fs.Connect();

	TheTest(err == KErrNone);

	RDbNamedDatabase db;

	err = db.Replace(fs, KDbName);

	TheTest(err == KErrNone);

	const TInt KColCnt = 3;

	err = db.Execute(_L("CREATE TABLE A(A1234567890 INTEGER, B1234567890 INTEGER, C12345 INTEGER)"));

	TheTest(err == KErrNone);

	err = db.Execute(_L("CREATE INDEX I1 ON A(A1234567890, B1234567890, C12345)"));

	TheTest(err == KErrNone);

	RDbTable tbl;

	err = tbl.Open(db, _L("A"));

	TheTest(err == KErrNone);

	//It is very hard to reproduce the problem, because the memory region after the memory, occupied by

	//CDbColSet's array, may be valid. That is the reason the test is repeated in a loop KTestCnt times,

	//where every  ColSetL() call will allocate a new block of memory for its array and at some point TDbCol's

	//copy constructor and "=" operator may try to access an invalid memory area, if the compiler generated

	//ones are used.

	const TInt KTestCnt = 100;

	TInt i;

	CDbColSet* colset[KTestCnt];

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

		{

		TRAP(err, colset[i] = tbl.ColSetL());

		TheTest(err == KErrNone);

		TDbCol lastCol = (*colset[i])[KColCnt];		//copy constructor

		lastCol = (*colset[i])[KColCnt];			//"=" operator

		}

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

		{

		delete colset[i];

		}

	tbl.Close();

	//The same test is repeated for TDbKeyCol's copy constructor and "=" operator

	CDbKey* key[KTestCnt];

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

		{

		TRAP(err, key[i] = db.KeyL(_L("I1"), _L("A")));

		TheTest(err == KErrNone);

		TDbKeyCol lastKeyCol = (*key[i])[KColCnt - 1];	//copy constructor

		lastKeyCol = (*key[i])[KColCnt - 1];			//"=" operator

		}

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

		{

		delete key[i];

		}

	db.Close();

	err = fs.Delete(KDbName);

	TheTest(err == KErrNone);

	fs.Close();

	}

/**

@SYMTestCaseID			SYSLIB-DBMS-UT-3469

@SYMTestCaseDesc		Test for DEF105615 "DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory".

						The test creates TDbCol and TDbKeyCol objects, creates their copies using copy constructors

						and "=" operators and checks that the copies were constructed correctly,

@SYMTestPriority		High

@SYMTestActions			Test for DEF105615 "DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory".

@SYMTestExpectedResults The test must not fail

@SYMREQ					DEF105615

*/

void DEF105615_2()

	{

   	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3469 DEF105615 DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory - 2 "));

   	const TDbColType KColType = EDbColText16;

   	const TInt KMaxColLen = 73;

   	const TInt KColAttributes = TDbCol::ENotNull;

   	_LIT(KColName, "Name");

   	TDbCol srcDbCol(KColName, EDbColText16, KMaxColLen);

   	srcDbCol.iAttributes = KColAttributes;

	//TDbCol - copy constructor

   	TDbCol dbColCopy1(srcDbCol);

   	TheTest(dbColCopy1.iType == srcDbCol.iType && dbColCopy1.iType == KColType);

   	TheTest(dbColCopy1.iMaxLength == srcDbCol.iMaxLength && dbColCopy1.iMaxLength == KMaxColLen);

   	TheTest(dbColCopy1.iAttributes == srcDbCol.iAttributes && dbColCopy1.iAttributes == KColAttributes);

   	TheTest(dbColCopy1.iName == srcDbCol.iName && dbColCopy1.iName == KColName);

	//TDbCol - "=" operator

   	TDbCol dbColCopy2;

   	dbColCopy2 = srcDbCol;

   	TheTest(dbColCopy2.iType == srcDbCol.iType && dbColCopy2.iType == KColType);

   	TheTest(dbColCopy2.iMaxLength == srcDbCol.iMaxLength && dbColCopy2.iMaxLength == KMaxColLen);

   	TheTest(dbColCopy2.iAttributes == srcDbCol.iAttributes && dbColCopy2.iAttributes == KColAttributes);

   	TheTest(dbColCopy2.iName == srcDbCol.iName && dbColCopy2.iName == KColName);

	//TDbCol - self assignment

	srcDbCol = srcDbCol;

   	TheTest(srcDbCol.iType == KColType);

   	TheTest(srcDbCol.iMaxLength == KMaxColLen);

   	TheTest(srcDbCol.iAttributes == KColAttributes);

   	TheTest(srcDbCol.iName == KColName);

   	const TInt KKeyLen = 29;

   	const TDbKeyCol::TOrder KKeyOrder = TDbKeyCol::EDesc;

   	_LIT(KKeyName, "Name22");

   	TDbKeyCol srcDbKeyCol(KKeyName, KKeyLen, KKeyOrder);

	//TDbKeyCol - copy constructor

   	TDbKeyCol dbKeyColCopy1(srcDbKeyCol);

   	TheTest(dbKeyColCopy1.iOrder == srcDbKeyCol.iOrder && dbKeyColCopy1.iOrder == KKeyOrder);

   	TheTest(dbKeyColCopy1.iLength == srcDbKeyCol.iLength && dbKeyColCopy1.iLength == KKeyLen);

   	TheTest(dbKeyColCopy1.iName == srcDbKeyCol.iName && dbKeyColCopy1.iName == KKeyName);

	//TDbKeyCol - "=" operator

   	TDbKeyCol dbKeyColCopy2;

   	dbKeyColCopy2 = srcDbKeyCol;

   	TheTest(dbKeyColCopy2.iOrder == srcDbKeyCol.iOrder && dbKeyColCopy2.iOrder == KKeyOrder);

   	TheTest(dbKeyColCopy2.iLength == srcDbKeyCol.iLength && dbKeyColCopy2.iLength == KKeyLen);

   	TheTest(dbKeyColCopy2.iName == srcDbKeyCol.iName && dbKeyColCopy2.iName == KKeyName);

	//TDbKeyCol - self assignment

	srcDbKeyCol = srcDbKeyCol;

   	TheTest(srcDbKeyCol.iOrder == KKeyOrder);

   	TheTest(srcDbKeyCol.iLength == KKeyLen);

   	TheTest(srcDbKeyCol.iName == KKeyName);

   	}

/**

@SYMTestCaseID          SYSLIB-DBMS-UT-3413

@SYMTestCaseDesc        Testing that "incremental update" operations running in one connection does not

						interfere with database operations executed from a second connection

@SYMTestPriority        High

@SYMTestActions         Create a test database with one table and insert some records there (> 100).

						Create 2 database connections.

						Open that database from connection 1 and execute an incremental update operation

						in a transaction. At the same time try to open and close the same table from

						connection 2, mixing these operations with the RDbUpdate::Next() calls from

						connection 1. So the call pattern should be:

						@code

						RDbUpdate dbUpdate;

						....

						while((err = dbUpdate.Next()) > 0)		//from "Conenction 1"

							{

							RDbTable tbl;

							err = tbl.Open(TheDb2, _L("A"));	//from "Conenction 2"

							...

							}

						@endcode