// Copyright (c) 1998-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 <s32file.h>

 #include <e32test.h>

 #include <e32math.h>

 #ifndef __TOOLS2__	// we aren't interested in timings for tools2

 #include <e32svr.h>

 #include <hal.h>

 #endif

 #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_BENCH.CRC");

 #else

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

 #endif

 #endif

 // MSVC++ up to 5.0 has problems with expanding inline functions

 // This disables the mad warnings for the whole project

 #if defined(NDEBUG) && defined(__VC32__) && _MSC_VER<=1100

 #pragma warning(disable : 4710)			// function not expanded. MSVC 5.0 is stupid

 #endif

 #ifndef __TOOLS2__

 class TTimer

 	{

 public:

 	void Start();

 	TReal Stop() const;

 private:

 	TUint iTicks;

 	};

 #endif

 LOCAL_D RTest test(_L("T_BENCH"));

 LOCAL_D CTrapCleanup* TheTrapCleanup;

 LOCAL_D RDbNamedDatabase TheDatabase;

 LOCAL_D RDbView TheView;

 LOCAL_D RFs TheFs;

 const TInt KTestCleanupStack=0x20;

 //T_BENCH file shall not be deleted at the end of the test! It will be used by T_COMP test.

 #ifdef __TOOLS2__

 const TPtrC KTestDatabase=_L(".\\dbms-tst\\T_BENCH.DB");

 #else

 const TPtrC KTestDatabase=_L("C:\\dbms-tst\\T_BENCH.DB");

 #endif

 const TPtrC KTableName=_S("Test");

 const TPtrC KColCluster=_S("Cluster");

 const TPtrC KColXcluster=_S("xCluster");

 const TPtrC KColRandom=_S("Random");

 const TPtrC KColXrandom=_S("xRandom");

 const TInt KRecords=2000;

 #ifndef __TOOLS2__

 static TTimer TheTimer;

 void TTimer::Start()

 	{

 	iTicks=User::FastCounter();

 	}

 TReal TTimer::Stop() const

 	{

 	TUint ticks = User::FastCounter() - iTicks;

 	TInt freq = 0;

 	test(HAL::Get(HAL::EFastCounterFrequency, freq) == KErrNone);

 	const TInt KMicroSecIn1Sec = 1000000;

 	const TInt KMsIn1Sec = 1000;

 	double v = ((double)ticks * KMicroSecIn1Sec) / (double)freq; TInt v2 = (TInt)v;

 	return v2 / KMsIn1Sec;

 	}

 #endif

 LOCAL_C void CloseDatabase()

 	{

 	TheDatabase.Close();

 	TheCrcChecker.GenerateCrcL(KTestDatabase);

 	}

 /**

 Create the database: keep the code 050 compatible

 @SYMTestCaseID          SYSLIB-DBMS-CT-0577

 @SYMTestCaseDesc        Benchmark Tests. Creation of a local Database test

 @SYMTestPriority        Medium

 @SYMTestActions        	Attempt to test RDbNamedDatabase::CreateTable(),RDbNamedDatabase::CreateIndex(),

 						RDbNamedDatabase::Compact(),RDbView::Prepare() functions 

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void CreateDatabase()

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0577 "));

 	User::LeaveIfError(TheDatabase.Replace(TheFs,KTestDatabase));

 	CDbColSet& set=*CDbColSet::NewLC();

 	TDbCol col(KColCluster,EDbColInt32);

 	col.iAttributes=col.ENotNull;

 	set.AddL(col);

 	col.iName=KColXcluster;

 	set.AddL(col);

 	col.iName=KColRandom;

 	set.AddL(col);

 	col.iName=KColXrandom;

 	set.AddL(col);

 	TInt r=TheDatabase.CreateTable(KTableName,set);

 	test (r==KErrNone);

 	CleanupStack::PopAndDestroy();

 #ifndef __TOOLS2__

 	TheTimer.Start();

 #endif

 	r=TheView.Prepare(TheDatabase,_L("select * from test"),TheView.EInsertOnly);

 	TheDatabase.Begin();

 	test (r==KErrNone);

 	TInt jj=0;

 	for (TInt ii=0;ii<KRecords;++ii)

 		{

 		TheView.InsertL();

 		jj=(jj+23);

 		if (jj>=KRecords)

 			jj-=KRecords;

 		TheView.SetColL(1,ii);

 		TheView.SetColL(2,ii);

 		TheView.SetColL(3,jj);

 		TheView.SetColL(4,jj);

 		TheView.PutL();

 		}

 	r=TheDatabase.Commit();

 	test (r==KErrNone);

 	TheView.Close();

 #ifndef __TOOLS2__

 	test.Printf(_L("Build table: %7.1f ms\n"),TheTimer.Stop());

 	TheTimer.Start();

 #endif

 	CDbKey& key=*CDbKey::NewLC();

 	key.AddL(KColXcluster);

 	key.MakeUnique();

 	r=TheDatabase.CreateIndex(KColXcluster,KTableName,key);

 	test (r==KErrNone);

 #ifndef __TOOLS2__

 	test.Printf(_L("Cluster index: %7.1f ms\n"),TheTimer.Stop());

 	TheTimer.Start();

 #endif

 	key.Clear();

 	key.AddL(KColXrandom);

 	r=TheDatabase.CreateIndex(KColXrandom,KTableName,key);

 	test (r==KErrNone);

 	CleanupStack::PopAndDestroy();

 #ifndef __TOOLS2__

 	test.Printf(_L("Random index: %7.1f ms\n"),TheTimer.Stop());

 	TheTimer.Start();

 #endif

 	r = TheDatabase.Compact();

 #ifndef __TOOLS2__

 	test.Printf(_L("Compact: %7.1f ms\n"),TheTimer.Stop());

 #endif

 	test (r == KErrNone);

 	}

 LOCAL_C TReal Evaluate(const TDesC& aSql)

 	{

 	TInt m=1;

 	for (;;)

 		{

 #ifndef __TOOLS2__

 		TheTimer.Start();

 #endif

 		for (TInt ii=0;ii<m;++ii)

 			{

 			TInt r=TheView.Prepare(TheDatabase,aSql,KDbUnlimitedWindow,TheView.EReadOnly);

 			if (r<0)

 				return r;

 			r=TheView.EvaluateAll();

 			test (r==KErrNone);

 			TheView.Close();

 			}

 #ifndef __TOOLS2__

 		TReal t=TheTimer.Stop();

 		if (t>=100.0)

 			return t/m;

 		m*=4;

 #else

 		// We aren't interested in timings for tools2.

 		return(1.0/m); // is this right?

 #endif

 		}

 	}

 struct TTest

 	{

 	const TText* iName;

 	const TText* iQuery;

 	};

 const TTest KQuery[]=

 	{

 	{_S("project"),_S("select cluster,xcluster,random,xrandom from test")},

 	{_S("restrict 1"),_S("select * from test where cluster=0")},

 	{_S("restrict 2"),_S("select * from test where xrandom=0")},

 	{_S("restrict 3"),_S("select * from test where xcluster<500 and xrandom <500")},

 	{_S("order 1"),_S("select * from test order by xrandom")},

 	{_S("order 2"),_S("select * from test order by cluster")},

 	{_S("all 1"),_S("select * from test where random<500 order by xrandom")},

 	{_S("all 2"),_S("select * from test where xcluster<500 order by xrandom")},

 	{_S("all 3"),_S("select * from test where xcluster<500 order by xcluster")},

 	{_S("all 4"),_S("select * from test where xcluster<500 and xrandom<200 order by xcluster")}

 	};

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0578

 @SYMTestCaseDesc        Benchmark Test.Querying a local Database Test

 @SYMTestPriority        Medium

 @SYMTestActions        	Evaluate SELECT queries on the created database

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void Queries()

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0578 "));

 	for (TUint ii=0;ii<sizeof(KQuery)/sizeof(KQuery[0]);++ii)

 		{

 		test.Printf(_L("%15s: "),KQuery[ii].iName);

 		TReal t=Evaluate(TPtrC(KQuery[ii].iQuery));

 		if (t<0.0)

 			test.Printf(_L("-\n"));

 		else

 			test.Printf(_L("%7.1f ms\n"),t);

 		}

 	}

 //

 // Benchmark tests

 //

 LOCAL_C void BenchTest()

 	{

 	CreateDatabase();

 	Queries();

 	CloseDatabase();

 	}

 //

 // Prepare the test directory.

 //

 LOCAL_C void setupTestDirectory()

     {

 	TInt r=TheFs.Connect();

 	test(r==KErrNone);

 //

 #if 0

 	TDriveList drives;

 	TheFs.DriveList(drives);

 	if (drives[EDriveK] == KDriveAbsent)

 		{

 		TInt r = TheFs.AddFileSystem(_L("ELFFS"));

 		test (r == KErrNone);

 		r = TheFs.MountFileSystem(_L("Lffs"),EDriveK);

 		if (r == KErrCorrupt || r == KErrNotReady) 

 			{

 			RFormat format;

 			TInt    count;

 			r = format.Open(TheFs, _L("K:\\"), EHighDensity, count);

 			test (r == KErrNone);

 			while (count)

 				format.Next(count);

 			format.Close();

     		}

 		else

 			test (r == KErrNone);

 		}

 #endif

 //

 	r=TheFs.MkDir(KTestDatabase);

 	test(r==KErrNone || r==KErrAlreadyExists);

 	}

 //

 // Initialise the cleanup stack.

 //

 LOCAL_C void setupCleanup()

     {

 	TheTrapCleanup=CTrapCleanup::New();

 	test(TheTrapCleanup!=NULL);

 	TRAPD(r,\

 		{\

 		for (TInt i=KTestCleanupStack;i>0;i--)\

 			CleanupStack::PushL((TAny*)0);\

 		CleanupStack::Pop(KTestCleanupStack);\

 		});

 	test(r==KErrNone);

 	}

 //

 // entry point

 //

 GLDEF_C TInt E32Main()

     {

 	test.Title();

 	setupTestDirectory();

 	setupCleanup();

 	__UHEAP_MARK;

 	test.Start(_L("Benchmarking..."));

 	TRAPD(r,BenchTest();)

 	test(r==KErrNone);

 #ifndef __linux__

 	TInt err;

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

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

 #endif // TOOLS2

 #endif // linux

 	test.End();

 	__UHEAP_MARKEND;

 	delete TheTrapCleanup;

 	//T_BENCH.DB cannot be deleted here, because it is used by T_COMP test!

 	TheFs.Close();

 	test.Close();

 	return 0;

     }