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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // Testing DBMS ordering and searching functionality when the key field is unicode string.

 // The idea is to verify that collation level 0 is used when doing string based searching 

 // and collation level > 0 is used when doing string based ordering.

 // 

 //

 #include <e32test.h>

 #include <f32file.h>

 #include <d32dbms.h>

 #include "crccheck.h"

 #undef __UHEAP_MARK

 #define __UHEAP_MARK

 #undef __UHEAP_MARKEND

 #define __UHEAP_MARKEND

 LOCAL_D TDBMS_CRCChecks TheCrcChecker;

 #ifndef __linux__ //No CRC test on LINUX

 #ifdef __TOOLS2__

 const TPtrC	KCrcRecord=_L("\\epoc32\\winscw\\c\\dbms-tst\\T_DBMSSTRCOMP.CRC");

 #else

 const TPtrC	KCrcRecord=_L("C:\\dbms-tst\\T_DBMSSTRCOMP.CRC");

 #endif

 #endif

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

 //Globals

 #ifdef __TOOLS2__

 const TPtrC KTestDatabase = _L(".\\dbms-tst\\T_DbmsStrComp.db");

 #else

 const TPtrC KTestDatabase = _L("c:\\dbms-tst\\T_DbmsStrComp.db");

 #endif

 const TUint             KExitDelay = 6 * 1000000;//6 seconds

 static RTest			TheTest(_L("T_DbmsStrComp test"));

 static RFs				TheFs;

 static RDbNamedDatabase TheDb;

 static RDbs				TheDbSession;

 //Test table defs

 _LIT(KTestTableName1, "TABLE1");//EDbColText16 key field

 _LIT(KTestTableName2, "TABLE2");//EDbColLongText16 key field

 struct TColDef

 	{

 	const TText*	iName;

 	TDbColType		iType;

 	TInt			iAttributes;

 	};

 static TColDef const KColDefs1[]=

 	{

 		{_S("ID"), EDbColText16, 0},

 		{_S("DATA"), EDbColUint32, 0},

 		{0}

 	};

 static TColDef const KColDefs2[]=

 	{

 		{_S("ID"), EDbColLongText16, 0},

 		{_S("DATA"), EDbColUint32, 0},

 		{0}

 	};

 //Test strings

 const TInt KTestStrLen = 3; //The length of test strings

 typedef TBuf16<KTestStrLen> TNameBuf;

 //Test strings array - using upper and lower case - which will force the DBMS server to make

 //different decisions depending on what is the current case: ordering or searching.

 const TNameBuf KTestStr[] = 

 	{

 	_L16("aaa"),

 	_L16("aAa"),

 	_L16("bbB"),

 	_L16("BbB")

 	};

 const TInt KTestStrCnt = sizeof(KTestStr) / sizeof(KTestStr[0]);

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

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

 //Destroy test environment - global functions

 //Deletes "aFullName" file.

 static TInt DeleteDataFile(const TDesC& aFullName)

 	{

 	RFs fsSession;

 	TInt err = fsSession.Connect();

 	if(err == KErrNone)

 		{

 		TEntry entry;

 		err = fsSession.Entry(aFullName, entry);

 		if(err == KErrNone)

 			{

 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

 			if(err != KErrNone) 

 				{

 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

 				}

 			err = fsSession.Delete(aFullName);

 			if(err != KErrNone) 

 				{

 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

 				}

 			}

 		fsSession.Close();

 		}

 	else

 		{

 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

 		}

 	return err;

 	}

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

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

 //Tests macros and functions.

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

 static void Check(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		::DeleteDataFile(KTestDatabase);

 		TheTest(EFalse, aLine);

 		}

 	}

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

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

 	{

 	if(aValue != aExpected)

 		{

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

 		::DeleteDataFile(KTestDatabase);

 		TheTest(EFalse, aLine);

 		}

 	}

 //Use these to test conditions.

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

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

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

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

 //Global functions

 //Prepares the test directory.

 //TheFs.Connect() has to be called already.

 static void SetupTestDirectory()

     {

 	TInt err = TheFs.MkDir(KTestDatabase);

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

 	}

 //Leaves with info message printed out

 static void Leave(TInt aError, TInt aLine)

 	{

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

 	User::Leave(aError);

 	}

 //Leaves if aError < 0 with info message printed out

 static void LeaveIfError(TInt aError, TInt aLine)

 	{

 	if(aError < KErrNone)

 		{

 		::Leave(aError, aLine);

 		}

 	}

 //Use LEAVE() macro instead of User::Leave() and LEAVE_IF_ERROR() macro instead of

 //User::LeaveIfError(). They will print the line number, where the "leave" was called.

 #define LEAVE(aError) ::Leave(aError, __LINE__)

 #define LEAVE_IF_ERROR(aError) ::LeaveIfError(aError, __LINE__)

 //Creates the test DBMS session

 static void CreateTestDbSession()

 	{

 #ifndef __TOOLS2__

 	RDebug::Print(_L("Create DBMS session\n"));

 	TInt err = TheDbSession.Connect();

 	TEST2(err, KErrNone);

 #endif

 	}

 //Creates the test database

 //TheDbSession instance has to be connected already.

 //TheFs.Connect() has to be called already.

 static void CreateTestDatabase(RDbs& aDbs, RDbNamedDatabase& aDb)

 	{

 	RDebug::Print(_L("Create test database\n"));

 	TInt err = aDb.Replace(TheFs, KTestDatabase);

 	TEST2(err, KErrNone);

 	TheDb.Close();

 	err = aDb.Open(aDbs, KTestDatabase);

 	TEST2(err, KErrNone);

 	}

 //Creates test table

 static void DoCreateTestTableL(RDbNamedDatabase& aDb, const TDesC& aTblName, const TColDef aColDefs[])

 	{

 	CDbColSet* colSet = CDbColSet::NewLC();

 	for(const TColDef* colDef=aColDefs;colDef->iName;++colDef)

 		{

 		TDbCol col(TPtrC(colDef->iName), colDef->iType);

 		col.iAttributes = colDef->iAttributes;

 		colSet->AddL(col);

 		}

 	TEST2(aDb.CreateTable(aTblName, *colSet), KErrNone);

 	CleanupStack::PopAndDestroy(colSet);

 	}

 //Creates test tables

 static void CreateTestTablesL(RDbNamedDatabase& aDb)

 	{

 	RDebug::Print(_L("Create test tables\n"));

 	::DoCreateTestTableL(aDb, KTestTableName1, KColDefs1);

 	::DoCreateTestTableL(aDb, KTestTableName2, KColDefs2);

 	}

 //Gets the value of the string field, which type may be EDbColText16 or EDbColLongText16

 void GetStrFieldValue(RDbRowSet& aTbl, const TDesC& aTblName, TDes& aStrFldVal)

 	{

 	if(aTblName.CompareF(KTestTableName1) == 0)

 		{

 		aStrFldVal = aTbl.ColDes16(1);

 		}

 	else

 		{

 		RDbColReadStream blob;

 		blob.OpenLC(aTbl, 1);

 		blob.ReadL(aStrFldVal, aTbl.ColLength(1));

 		CleanupStack::PopAndDestroy();

 		}

 	}

 //Prints all table records

 static TInt PrintRecordsL(RDbRowSet& aTbl, const TDesC& aTblName)

 	{

 	RDebug::Print(_L("Table: %S\n"), &aTblName);

     aTbl.FirstL();

 	TInt rec = 0;

     while(aTbl.AtRow())

         {

         aTbl.GetL();

 		TNameBuf strFldVal;

 		::GetStrFieldValue(aTbl, aTblName, strFldVal);

 		TUint32 v = aTbl.ColUint32(2);

 		RDebug::Print(_L("   Record %d, Str: %S, Val: %d\n"), ++rec, &strFldVal, v);

         aTbl.NextL(); 

         }

 	return rec;

 	}

 //Checks if the records order (based on a string key field comparison) matches the order of the

 //strings in aTestStrArray

 static void AssertRecordsOrder(RDbRowSet& aTbl, const TDesC& aTblName, const RArray<TNameBuf>& aTestStrArray)

 	{

     aTbl.FirstL();

 	TInt rec = 0;

     while(aTbl.AtRow())

         {

         aTbl.GetL();

 		TNameBuf strFldVal;

 		::GetStrFieldValue(aTbl, aTblName, strFldVal);

 		TEST(aTestStrArray[rec] == strFldVal);

 		++rec;

         aTbl.NextL(); 

         }

 	}

 //Adds test data to the specified table. Make sure that the records are not in

 //order (assuming that the first field will be the key).

 static void AddTestDataL(RDbNamedDatabase& aDb, const TDesC& aTblName)

 	{

 	RDbTable tbl;

 	CleanupClosePushL(tbl);

 	TEST2(tbl.Open(aDb, aTblName, RDbRowSet::EUpdatable), KErrNone);

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

 		{

 		tbl.InsertL();

 		tbl.SetColL(1, KTestStr[KTestStrCnt - i - 1]);

 		tbl.SetColL(2, i + 1);

 		tbl.PutL();

 		}

 	TEST(tbl.CountL() == KTestStrCnt);

 	(void)::PrintRecordsL(tbl, aTblName);

 	CleanupStack::PopAndDestroy(&tbl);

 	}

 //Adds the test data to test tables

 static void AddTestDataL(RDbNamedDatabase& aDb)

 	{

 	RDebug::Print(_L("Add data to test tables\n"));

 	::AddTestDataL(aDb, KTestTableName1);

 	::AddTestDataL(aDb, KTestTableName2);

 	}

 //Init test environment

 static void InitEnvL()

 	{

 	::CreateTestDbSession();

     //Create test database and tables. Add some test data to them.

 	::CreateTestDatabase(TheDbSession, TheDb);

 	::CreateTestTablesL(TheDb);

 	::AddTestDataL(TheDb);

 	}

 //String comparison function, used in FillStrArraySorted() function.

 static TInt CompareC(const TNameBuf& aName1, const TNameBuf& aName2)

     {

     return aName1.CompareC(aName2);

     }

 //Inserts all test string into an ordered array - aTestStrArray

 static void FillStrArraySortedL(RArray<TNameBuf>& aTestStrArray)

 	{

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

 		{

     	User::LeaveIfError(aTestStrArray.InsertInOrder(KTestStr[i], TLinearOrder<TNameBuf>(CompareC)));

 		}

 	}

 static void CreateIndexL(RDbNamedDatabase& aDb, const TDesC& aTblName, const TDesC& aColumnName)

 	{

 	RDebug::Print(_L("Create index. Table: %S, column: %S\n"), &aTblName, &aColumnName);

 	CDbKey* key = CDbKey::NewLC();

 	key->AddL(aColumnName);

 	key->MakeUnique();

 	key->SetComparison(EDbCompareCollated);

 	LEAVE_IF_ERROR(aDb.CreateIndex(aColumnName, aTblName, *key));

 	CleanupStack::PopAndDestroy(key);

 	}

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

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

 //Test cases

 //Test case 1. Check SELECT statement with ORDER BY clause when the key field is a string.

 static void OrderByTestL(RDbNamedDatabase& aDb, const TDesC& aTblName, const RArray<TNameBuf>& aTestStrArray)

 	{

     RDbView view;

     CleanupClosePushL(view);

     TBuf<128> sqlStmt;

     sqlStmt.Append(_L("SELECT ID, DATA FROM "));

     sqlStmt.Append(aTblName);

     sqlStmt.Append(_L(" ORDER BY ID"));

     User::LeaveIfError(view.Prepare(aDb, TDbQuery(sqlStmt, EDbCompareCollated), TDbWindow::EUnlimited));

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

 	(void)::PrintRecordsL(view, aTblName);

 	::AssertRecordsOrder(view, aTblName, aTestStrArray);

     CleanupStack::PopAndDestroy(&view);

 	}

 //Test case 2. Check SELECT statement with LIKE keyword when the key field is a string.

 static void LikeTestL(RDbNamedDatabase& aDb, const TDesC& aTblName)

 	{

     RDbView view;

     CleanupClosePushL(view);

     TBuf<128> sqlStmt;

     sqlStmt.Append(_L("SELECT ID, DATA FROM "));

     sqlStmt.Append(aTblName);

     sqlStmt.Append(_L(" WHERE ID LIKE 'B*'"));

     User::LeaveIfError(view.Prepare(aDb, TDbQuery(sqlStmt, EDbCompareCollated), TDbWindow::EUnlimited));

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

 	TInt cnt = ::PrintRecordsL(view, aTblName);

 	TEST(cnt == 2);

     CleanupStack::PopAndDestroy(&view);

 	}

 //Test case 3. Check SELECT statement with LIKE & ORDER BY keywords when the key field is a string.

 static void LikeOrderTestL(RDbNamedDatabase& aDb, const TDesC& aTblName, const RArray<TNameBuf>& aTestStrArray)

 	{

     RDbView view;

     CleanupClosePushL(view);

     TBuf<128> sqlStmt;

     sqlStmt.Append(_L("SELECT ID, DATA FROM "));

     sqlStmt.Append(aTblName);

     sqlStmt.Append(_L(" WHERE ID LIKE 'B*' ORDER BY ID"));

     User::LeaveIfError(view.Prepare(aDb, TDbQuery(sqlStmt, EDbCompareCollated), TDbWindow::EUnlimited));

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

 	TInt cnt = ::PrintRecordsL(view, aTblName);

 	TEST(cnt == 2);

 	::AssertRecordsOrder(view, aTblName, aTestStrArray);

     CleanupStack::PopAndDestroy(&view);

 	}

 //Test case 4. Indexed table. The index is a string field.

 static void IndexTestL(RDbNamedDatabase& aDb, const TDesC& aTblName, const RArray<TNameBuf>& aTestStrArray)

 	{

 	_LIT(KIdxName, "ID");

 	::CreateIndexL(aDb, aTblName, KIdxName);

 	RDbTable tbl;

 	CleanupClosePushL(tbl);

 	TEST2(tbl.Open(aDb, aTblName, RDbRowSet::EReadOnly), KErrNone);

 	TEST2(tbl.SetIndex(KIdxName), KErrNone);

 	(void)::PrintRecordsL(tbl, aTblName);

 	::AssertRecordsOrder(tbl, aTblName, aTestStrArray);

     CleanupStack::PopAndDestroy(&tbl);

 	}

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

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

 //The main test function.

 //Call your new test functions from here

 static void RunTestsL()

 	{

 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-LEGACY-DBMSSTRCOMP-0001 Init test environment "));

 	::InitEnvL();

     RArray<TNameBuf> testStrArray;

     CleanupClosePushL(testStrArray);

 	::FillStrArraySortedL(testStrArray);

 	TheTest.Next(_L("SELECT, ORDER BY, EDbColText16"));

 	::OrderByTestL(TheDb, KTestTableName1, testStrArray);

 	TheTest.Next(_L("SELECT, ORDER BY, EDbColLongText16"));

 	::OrderByTestL(TheDb, KTestTableName2, testStrArray);

 	TheTest.Next(_L("SELECT, LIKE, EDbColText16"));

 	::LikeTestL(TheDb, KTestTableName1);

 	TheTest.Next(_L("SELECT, LIKE, EDbColLongText16"));

 	::LikeTestL(TheDb, KTestTableName2);

     RArray<TNameBuf> testStrArray2;

     CleanupClosePushL(testStrArray2);

     testStrArray2.AppendL(testStrArray[2]);//"bbB"

     testStrArray2.AppendL(testStrArray[3]);//"BbB"

 	TheTest.Next(_L("SELECT, LIKE, ORDER BY, EDbColText16"));

 	::LikeOrderTestL(TheDb, KTestTableName1, testStrArray2);

 	TheTest.Next(_L("SELECT, LIKE, ORDER BY, EDbColLongText16"));

 	::LikeOrderTestL(TheDb, KTestTableName2, testStrArray2);

 	TheTest.Next(_L("Index, EDbColText16"));

 	::IndexTestL(TheDb, KTestTableName1, testStrArray);

 // Not possible to create a key with EDbColLongText16

 //	TheTest.Next(_L("Index, EDbColLongText16"));

 //	::IndexTestL(TheDb, KTestTableName2, testStrArray);

 	//Add tests here!

     CleanupStack::PopAndDestroy(&testStrArray2);

     CleanupStack::PopAndDestroy(&testStrArray);

 	}

 TInt E32Main()

 	{

 	TheTest.Title();

 	__UHEAP_MARK;

 	CTrapCleanup* trapCleanup = CTrapCleanup::New();

 	TEST(trapCleanup != NULL);

 	TInt err = TheFs.Connect();

 	TEST2(err, KErrNone);

 	::SetupTestDirectory();

 	::DeleteDataFile(KTestDatabase);

 	TRAP(err, ::RunTestsL());

 	TheDb.Close();

 #ifndef __TOOLS2__

 	TheDbSession.Close();

 #endif

 	TheFs.Close();

 	TEST2(err, KErrNone);

 #ifndef __linux__

 	TRAP(err, TheCrcChecker.GenerateCrcL(KTestDatabase));

 	TEST(err==KErrNone);

 #ifndef __TOOLS2__

 	TRAPD(lc, err = TheCrcChecker.DumpCrcRecordsL(KCrcRecord));

 	TEST(err==KErrNone);

 	TEST(lc==KErrNone);

 #else

 	TRAPD(lc, err = TheCrcChecker.ValidateCrcRecordsL(KCrcRecord));

 	TPtrC errmsg;

 	TheCrcChecker.ErrorReportL(err, errmsg);

 	RDebug::Print(errmsg);

 	TheTest(err==KErrNone || err==TDBMS_CRCChecks::ECrcCheckOk);

 #endif

 #endif

 	::DeleteDataFile(KTestDatabase);

 	TheTest.Printf(_L("Wait DBMS server shutdown...\n"));

 	User::After(KExitDelay);

 	TheTest.End();

 	TheTest.Close();

 	delete trapCleanup;

 	__UHEAP_MARKEND;

 	return 0;

 	}