// 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);