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

#include <s32mem.h>

#include <hal.h>

static RTest TheTest(_L("t_dbperf3"));

static CTrapCleanup* 	TheTrapCleanup;

static RFs				TheFs;

static RDbs 			TheDbs;

static RDbNamedDatabase TheDatabase;

static RDbRowSet 		TheRowSet, TheRowSet2;

static RFile 			TheTestFile;

static TFileName 		TheDatabaseFileName;

#define COUNT_OF(array) (sizeof(array)/sizeof(array[0]))

const TInt KTrackRecordCount = 200;

const TInt KCategoryRecordCount = 50;

const TInt KStatsRecordCount = 50;

const TInt KTestBlobSize = 4096;

//_LIT(KCreateTrackTable, "CREATE TABLE TRACKS (id INTEGER, marked_2_play INTEGER, category_id INTEGER, artist_last_name CHAR(15) NOT NULL,artist_first_name CHAR(15) NOT NULL, title CHAR(16) NOT NULL,download_site CHAR(30) NOT NULL,band_name CHAR(20) NOT NULL,origin CHAR(16),autostart INTEGER, init_volume INTEGER, music_file LONG VARCHAR)");

_LIT(KCreateTrackIndex, "CREATE INDEX IDX1 ON TRACKS(id,marked_2_play,category_id)");

_LIT(KCreateTrackTable, "CREATE TABLE TRACKS (id INTEGER, marked_2_play INTEGER, category_id INTEGER, artist_last_name CHAR(15) NOT NULL,artist_first_name CHAR(15) NOT NULL, title CHAR(16) NOT NULL,download_site CHAR(30) NOT NULL,band_name CHAR(20) NOT NULL,origin CHAR(16),autostart INTEGER, init_volume INTEGER)");

_LIT(KCreateTrackTable2, "CREATE TABLE TRACKS2 (id INTEGER, music_file LONG VARCHAR)");

//_LIT(KCreateTrackIndex2, "CREATE INDEX IDX4 ON TRACKS2(id)");

//_LIT(KTrackTable,"TRACKS");

_LIT(KId,"id");

_LIT(KLastName,"artist_last_name");

_LIT(KFirstName,"artist_first_name");

_LIT(KTitle,"title");

_LIT(KDownloadSite,"download_site");

_LIT(KBandName,"band_name");

_LIT(KOrigin,"origin");

_LIT(KAutoStart,"autostart");

_LIT(KInitVolume,"init_volume");

_LIT(KMarked2Play,"marked_2_play");

_LIT(KCategoryId,"category_id");

_LIT(KMusicFile,"music_file");

//category Table LITS

_LIT(KCreateCategoryTable, "CREATE TABLE CATEGORY (category_id INTEGER,category_name CHAR(20),genre INTEGER)");

_LIT(KCreateCategoryIndex, "CREATE INDEX IDX2 ON CATEGORY(category_id)");

//_LIT(KCategoryTable,"CATEGORY");

//KCategoryId defined for category table	

_LIT(KCategoryName,"category_name");

_LIT(KGenre,"genre");

//STATS Table LITS

_LIT(KCreatestatsTable, "CREATE TABLE STATS (category_id INTEGER, no_of_tracks INTEGER, no_autostart INTEGER,no_manualstart INTEGER,no_marked_2_play INTEGER, no_unmarked_2_play INTEGER, size_of_musicfiles INTEGER)");

_LIT(KCreatestatsIndex, "CREATE UNIQUE INDEX IDX3 ON STATS(category_id)");

//_LIT(KStatsTable,"STATS");

//KCategoryId defined for category table

_LIT(KNoOfTracks,"no_of_tracks");

_LIT(KNoMarked2Play,"no_marked_2_play");

_LIT(KNoUnmarked2Play,"no_unmarked_2_play");

_LIT(KNoAutostart,"no_autostart");

_LIT(KNoManualStart,"no_manualstart");

_LIT(KSizeOfMusicFiles,"size_of_musicfiles");

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

static TInt TheCounterFreq = -10000000;

const TInt KMicroSecIn1Sec = 1000000;

TUint32 CalcTickDiff(TUint32 aStartTicks, TUint32 aEndTicks)

	{

	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

	if(diffTicks < 0)

		{

		diffTicks = KMaxTUint32 + diffTicks + 1;

		}

	return (TUint32)diffTicks;

	}

//Prints aFastCount parameter (converted to us)

void PrintFcDiffAsUs(const TDesC& aFormatStr, TUint32 aFastCount)

	{

	double v = ((double)aFastCount * KMicroSecIn1Sec) / (double)TheCounterFreq;

	TInt v2 = (TInt)v;

	TheTest.Printf(aFormatStr, v2);

	}

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

//Delete "aFullName" file.

static void DeleteFile(const TDesC& aFullName)

	{

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		TEntry entry;

		if(fsSession.Entry(aFullName, entry) == KErrNone)

			{

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

			if(err != KErrNone) 

				{

				TheTest.Printf(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

				}

			err = fsSession.Delete(aFullName);

			if(err != KErrNone) 

				{

				TheTest.Printf(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

				}

			}

		fsSession.Close();

		}

	else

		{

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

		}

	}

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

static void CloseAll()

	{

	TheRowSet2.Close();

	TheRowSet.Close();

	TheDatabase.Close();

	TheDbs.Close();

	TheFs.Close();

	}

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

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

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

		{

		CloseAll();

		DeleteFile(TheDatabaseFileName);

		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)

		{

		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		CloseAll();

		DeleteFile(TheDatabaseFileName);

		TheTest(EFalse, aLine);

		}

	}

//Use these to test conditions.

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

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

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

void PrintFileSize()

	{

	RDbDatabase::TSize s = TheDatabase.Size();

	TheTest.Printf(_L("####FileSize: %d\r\n"), s.iSize);

	}

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

void FillRandomData(TDes& aData, TInt64 aSeed)

	{

	aData.Zero();

	for (TInt i=0; i<aData.MaxLength(); ++i)

		{

		// add next character (we stick to lowercase alphabet for now)

		aData.Append(TChar(Math::FRand(aSeed)*25 + 'a'));	

		}

	}

void FillRandomData(TDes& aData)

	{

	// get random seed

	TTime time;

	time.UniversalTime();

	TInt64 seed = time.Int64();

	// do the filling

	FillRandomData(aData, seed);

	}

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

void CreateDatabase()

	{

	TInt err = TheDatabase.Replace(TheFs, TheDatabaseFileName);

	TEST2(err, KErrNone);

	TheDatabase.Close();

	err = TheDbs.Connect();

	TEST2(err, KErrNone);

	err = TheDatabase.Open(TheDbs, TheDatabaseFileName);

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(KCreateTrackTable);

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(KCreateTrackIndex);

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(KCreateTrackTable2);

	TEST2(err, KErrNone);

	//err = TheDatabase.Execute(KCreateTrackIndex2);

	//TEST2(err, KErrNone);

	err = TheDatabase.Execute(KCreateCategoryTable);

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(KCreateCategoryIndex);

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(KCreatestatsTable);

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(KCreatestatsIndex);

	TEST2(err, KErrNone);

	//err = TheDatabase.Compact();

	//TEST2(err, KErrNone);

	}

void InsertTrackTableL()

	{	

	HBufC* randomDataBuf = HBufC::NewLC(KTestBlobSize);

	TPtr randomData(randomDataBuf->Des());

	FillRandomData(randomData);

	RDbView view;

	TInt err = view.Prepare(TheDatabase, _L("select * from TRACKS"), view.EInsertOnly);

	TEST2(err, KErrNone);

	TheRowSet = view;	

	CDbColSet* colSet = TheRowSet.ColSetL();

	const TInt KIdIdx = colSet->ColNo(KId);

	const TInt KLastNameIdx = colSet->ColNo(KLastName);

	const TInt KFirstNameIdx = colSet->ColNo(KFirstName);

	const TInt KTitleIdx = colSet->ColNo(KTitle);

	const TInt KDownloadSiteIdx = colSet->ColNo(KDownloadSite);

	const TInt KBandNameIdx = colSet->ColNo(KBandName);

	const TInt KOriginIdx = colSet->ColNo(KOrigin);

	const TInt KAutoStartIdx = colSet->ColNo(KAutoStart);

	const TInt KInitVolumeIdx = colSet->ColNo(KInitVolume);

	const TInt KMarkedToPlayIdx = colSet->ColNo(KMarked2Play);

	const TInt KCategoryIdIdx = colSet->ColNo(KCategoryId);

	//const TInt KMusicFileIdx = colSet->ColNo(KMusicFile);

	delete colSet;

	colSet = NULL;

	err = TheDatabase.Begin();

	TEST2(err, KErrNone);

	for (TInt ii=1;ii<=KTrackRecordCount;++ii)

		{

		TheRowSet.InsertL();

		TheRowSet.SetColL(KIdIdx, ii);

		TheRowSet.SetColL(KLastNameIdx, _L("Dummy"));

		TheRowSet.SetColL(KFirstNameIdx,_L("Dummy"));

		TheRowSet.SetColL(KTitleIdx,_L("Dummy"));

		TheRowSet.SetColL(KDownloadSiteIdx,_L("Dummy"));

		TheRowSet.SetColL(KBandNameIdx,_L("Dummy"));

		TheRowSet.SetColL(KOriginIdx,_L("Dummy"));

		TheRowSet.SetColL(KAutoStartIdx,(ii%2));

		TheRowSet.SetColL(KInitVolumeIdx,(ii%2));

		TheRowSet.SetColL(KMarkedToPlayIdx,(ii%2));

		TheRowSet.SetColL(KCategoryIdIdx,(ii%KCategoryRecordCount));

		//RDbColWriteStream musicfile;

		//musicfile.OpenLC(TheRowSet, KMusicFileIdx);

		//musicfile.WriteL(randomData,KTestBlobSize);

		//musicfile.CommitL();

		//CleanupStack::PopAndDestroy(&musicfile);

		TheRowSet.PutL();

		}

	err = TheDatabase.Commit();

	TEST2(err, KErrNone);

	//err = TheDatabase.Compact();

	//TEST2(err, KErrNone);

	TheRowSet.Close();	

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

	err = view.Prepare(TheDatabase, _L("select * from TRACKS2"), view.EInsertOnly);

	TEST2(err, KErrNone);

	TheRowSet = view;	

	colSet = TheRowSet.ColSetL();

	const TInt KIdIdx2 = colSet->ColNo(KId);

	const TInt KMusicFileIdx2 = colSet->ColNo(KMusicFile);

	delete colSet;

	err = TheDatabase.Begin();

	TEST2(err, KErrNone);

	for (TInt ii=1;ii<=KTrackRecordCount;++ii)

		{

		TheRowSet.InsertL();

		TheRowSet.SetColL(KIdIdx2, ii);

		RDbColWriteStream musicfile;

		musicfile.OpenLC(TheRowSet, KMusicFileIdx2);

		musicfile.WriteL(randomData,KTestBlobSize);

		musicfile.CommitL();

		CleanupStack::PopAndDestroy(&musicfile);

		TheRowSet.PutL();

		}

	err = TheDatabase.Commit();

	TEST2(err, KErrNone);

	//err = TheDatabase.Compact();

	//TEST2(err, KErrNone);

	TheRowSet.Close();	

	CleanupStack::PopAndDestroy(randomDataBuf);

	}

void InsertCategoryTableL()

	{

	RDbView view;

	TInt err = view.Prepare(TheDatabase, _L("select * from CATEGORY"), view.EInsertOnly);

	TEST2(err, KErrNone);

	TheRowSet = view;	

	CDbColSet* colSet = TheRowSet.ColSetL();

	const TInt KCategoryIdIdx = colSet->ColNo(KCategoryId);

	const TInt KCategoryNameIdx = colSet->ColNo(KCategoryName);

	const TInt KGenreIdx = colSet->ColNo(KGenre);

	delete colSet;

	err = TheDatabase.Begin();

	TEST2(err, KErrNone);

	for (TInt ii=1;ii<=KCategoryRecordCount;++ii)

		{

		TheRowSet.InsertL();

		TheRowSet.SetColL(KCategoryIdIdx, ii);

		TheRowSet.SetColL(KCategoryNameIdx, _L("History"));

		TheRowSet.SetColL(KGenreIdx,(ii*500));

		TheRowSet.PutL();

		}

	err = TheDatabase.Commit();

	TEST2(err, KErrNone);

	//err = TheDatabase.Compact();

	//TEST2(err, KErrNone);

	TheRowSet.Close();	

	}

void InsertStatsTableL()

	{

	RDbView view;

	TInt err = view.Prepare(TheDatabase, _L("select * from STATS"), view.EInsertOnly);

	TEST2(err, KErrNone);

	TheRowSet = view;	

	CDbColSet* colSet = TheRowSet.ColSetL();

	const TInt KCategoryIdIdx = colSet->ColNo(KCategoryId);

	const TInt KTrackCntIdx = colSet->ColNo(KNoOfTracks);

	const TInt KMarkedToPlayCntIdx = colSet->ColNo(KNoMarked2Play);

	const TInt KUnmarkedToPlayCntIdx = colSet->ColNo(KNoUnmarked2Play);

	const TInt KAutoStartCntIdx = colSet->ColNo(KNoAutostart);

	const TInt KManualStartCntIdx = colSet->ColNo(KNoManualStart);

	const TInt KSizeMusicFilesIdx = colSet->ColNo(KSizeOfMusicFiles);

	delete colSet;

	TInt default_Stat = 0;

	err = TheDatabase.Begin();

	TEST2(err, KErrNone);

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

		{

		TheRowSet.InsertL();

		TheRowSet.SetColL(KCategoryIdIdx, ii);

		TheRowSet.SetColL(KTrackCntIdx,default_Stat);

		TheRowSet.SetColL(KMarkedToPlayCntIdx,default_Stat);

		TheRowSet.SetColL(KUnmarkedToPlayCntIdx,default_Stat);

		TheRowSet.SetColL(KAutoStartCntIdx,default_Stat);

		TheRowSet.SetColL(KManualStartCntIdx,default_Stat);

		TheRowSet.SetColL(KSizeMusicFilesIdx,default_Stat);

		TheRowSet.PutL();

		}

	err = TheDatabase.Commit();

	TEST2(err, KErrNone);

	//err = TheDatabase.Compact();

	//TEST2(err, KErrNone);

	TheRowSet.Close();	

	}

void FillDatabaseL()

	{

	InsertTrackTableL();

	InsertCategoryTableL();	

	InsertStatsTableL();

	}

void DestroyDatabase()

	{

	TheRowSet.Close();

	TheDatabase.Close();

	TheDbs.Close();

	TInt err = TheFs.Delete(TheDatabaseFileName);

	TEST2(err, KErrNone);

	}

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

void GetFastCounterFrequency()

	{

	TEST2(HAL::Get(HAL::EFastCounterFrequency, TheCounterFreq), KErrNone);

	TheTest.Printf(_L("Counter frequency=%d\r\n"), TheCounterFreq);

	}

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

void SelectTracksL(TInt aCount, RArray<TInt>& aTracks)

	{

	TUint32 fc = User::FastCounter();

	RDbView view;

	TUint32 fc2 = User::FastCounter();

	TInt err = view.Prepare(TheDatabase, _L("select id from TRACKS"), view.EReadOnly);

	TEST2(err, KErrNone);

	PrintFcDiffAsUs(_L("###\"Prepare()\",time=%d us\r\n"), CalcTickDiff(fc2, User::FastCounter()));

	fc2 = User::FastCounter();

	err = view.EvaluateAll();

	TEST2(err, KErrNone);

	PrintFcDiffAsUs(_L("###\"EvaluateAll()\",time=%d us\r\n"), CalcTickDiff(fc2, User::FastCounter()));

	TheRowSet = view;

	TUint32 diff1 = 0, diff2 = 0;

	TInt count = 0;	

	while(count < aCount)

		{

		fc2 = User::FastCounter();

		if(!TheRowSet.NextL())

			{

			break;	

			}

		diff1 += CalcTickDiff(fc2, User::FastCounter());	

		fc2 = User::FastCounter();

		TheRowSet.GetL();

		diff2 += CalcTickDiff(fc2, User::FastCounter());	

		aTracks.Append(TheRowSet.ColInt(1));

		++count;

		}

	TEST2(count, aCount);

	PrintFcDiffAsUs(_L("###\"Total NextL()\",time=%d us\r\n"), diff1);

	PrintFcDiffAsUs(_L("###\"Total GetL()\",time=%d us\r\n"), diff2);

	fc2 = User::FastCounter();

	TheRowSet.Close();	

	PrintFcDiffAsUs(_L("###\"Close()\",time=%d us\r\n"), CalcTickDiff(fc2, User::FastCounter()));

	PrintFcDiffAsUs(_L("###\"SELECT FROM TRACKS\",time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));

	}

/** 

@SYMTestCaseID          PDS-DBMS-UT-4009

@SYMTestCaseDesc        DBMS performance tests.

@SYMTestPriority        High

@SYMTestActions        	The test opens the test database and:

						- selects the ids of the tracks to be deleted and collects them into an array;

						- deletes the recods with matching track ids from TRACK table;

						- deletes the recods with matching track ids from TRACK2 table;

						The execution times are printed out.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ7141

*/

void DeleteTracksL()

	{

	TheTest.Printf(_L("Record count: %d\r\n"), KTrackRecordCount);

	RArray<TInt> tracks;

	tracks.ReserveL(KTrackRecordCount);

	CleanupClosePushL(tracks);

	SelectTracksL(KTrackRecordCount, tracks);

	//

	_LIT(KDeleteSql, "DELETE FROM tracks  WHERE id>=%d AND id<=%d");

	TBuf<100> sql;

	sql.Format(KDeleteSql, tracks[0], tracks[tracks.Count() - 1]);

	TUint32 fc2 = User::FastCounter();

	TInt err = TheDatabase.Begin();

	TEST2(err, KErrNone);

	TUint32 fc = User::FastCounter();

	TInt rc = TheDatabase.Execute(sql);

	PrintFcDiffAsUs(_L("###\"DELETE FROM TRACKS\",time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));

	TEST2(rc, KTrackRecordCount);

	TheTest.Printf(_L("Deleted record count: %d\r\n"), rc);

	sql.Replace(12, 6, _L("TRACKS2"));

	fc = User::FastCounter();

	rc = TheDatabase.Execute(sql);

	PrintFcDiffAsUs(_L("###\"DELETE FROM TRACKS2\",time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));

	TEST2(rc, KTrackRecordCount);

	TheTest.Printf(_L("Deleted record count: %d\r\n"), rc);

	err = TheDatabase.Commit();

	TEST2(err, KErrNone);

	PrintFcDiffAsUs(_L("###Total \"DELETE FROM TRACKS\",time=%d us\r\n"), CalcTickDiff(fc2, User::FastCounter()));

	CleanupStack::PopAndDestroy(&tracks);

	}

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

//This test checks how RDbDatabase::Commit() works if there are some active RDbRowSet objects - 

//read-only and updatable. The expectation is that the Commit() call won't fail, the RDbRowSet objects

//retain their pre-commit positions.

void CommitTestL()

	{

	//Create 2 test tables, insert some records in the first table

	TheDatabase.Close();

	TInt err = TheDatabase.Replace(TheFs, TheDatabaseFileName);

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(_L("CREATE TABLE AA1(Id INTEGER)"));

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(_L("CREATE TABLE AA2(Id INTEGER)"));

	TEST2(err, KErrNone);

	err = TheDatabase.Execute(_L("INSERT INTO AA1(Id) VALUES(1)"));

	TEST2(err, 1);

	err = TheDatabase.Execute(_L("INSERT INTO AA1(Id) VALUES(2)"));

	TEST2(err, 1);

	err = TheDatabase.Execute(_L("INSERT INTO AA1(Id) VALUES(3)"));

	TEST2(err, 1);

	//Begin transaction

	err = TheDatabase.Begin();

	TEST2(err, KErrNone);

	//Prepare read-only view and call FirstL() (TheRowSet object)

	RDbView view;

	err = view.Prepare(TheDatabase, _L("select * from AA1"), RDbRowSet::EReadOnly);

	TEST2(err, KErrNone);

	TheRowSet = view;

	err = view.EvaluateAll();	//DBMS can use FirstL() without the EvaluateAll() call in this case

	TEST2(err, KErrNone);

	TBool rc = TheRowSet.FirstL();

	TEST(rc);

	//Prepare updatable view and call NextL() (TheRowSet2 object)

	err = view.Prepare(TheDatabase, _L("select * from AA1"), RDbRowSet::EUpdatable);

	TEST2(err, KErrNone);

	TheRowSet2 = view;

	err = view.EvaluateAll();	//DBMS can use NextL() without the EvaluateAll() call in this case

	TEST2(err, KErrNone);

	rc = TheRowSet2.FirstL();

	TEST(rc);

	rc = TheRowSet2.NextL();

	TEST(rc);

	//Execute one INSERT statement

	err = TheDatabase.Execute(_L("INSERT INTO AA2(Id) VALUES(1)"));

	TEST2(err, 1);

	//Commit transaction

	err = TheDatabase.Commit();

	TEST2(err, KErrNone);

	//Check the retrieved by TheRowSet record 

	TheRowSet.GetL();

	TEST2(TheRowSet.ColInt(1), 1);

	//Check the retrieved by TheRowSet2 record 

	TheRowSet2.GetL();

	TEST2(TheRowSet2.ColInt(1), 2);

	//Cleanup

	TheRowSet2.Close();

	TheRowSet.Close();

	TheDatabase.Close();

	}

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

void DoTestL()

	{

	TheTest.Start(_L("Get fast counter frequency"));

	GetFastCounterFrequency();

	TheTest.Next(_L("Create&Fill test database"));

	CreateDatabase();

	FillDatabaseL();

	TheTest.Next(_L(" @SYMTestCaseID:PDS-DBMS-UT-4009 Delete tracks"));

	DeleteTracksL();

	TheTest.Next(_L("Commit() test (not a performance test)"));

	CommitTestL();

	}

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

//Usage: "t_dbperf3 [<drive letter>:]"

TInt E32Main()

    {

	TheTest.Title();

	TheTrapCleanup = CTrapCleanup::New();

	TEST(TheTrapCleanup != NULL);

	//Construct test database file name

	_LIT(KTestDatabase, "c:\\dbms-tst\\t_dbperf3.db");

	TFileName fname;

	User::CommandLine(fname);

	TParse parse;

	parse.Set(fname, &KTestDatabase, 0);

	const TDesC& dbFilePath = parse.FullName();

	TheDatabaseFileName.Copy(dbFilePath);

	TheTest.Printf(_L("Test database: %S\r\n"), &TheDatabaseFileName);

	__UHEAP_MARK;

	TInt err = TheFs.Connect();

	TEST2(err, KErrNone);

	err = TheFs.MkDir(TheDatabaseFileName);

	TheTest.Printf(_L("MkDir(): err=%d\r\n"), err);

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

	DeleteFile(TheDatabaseFileName);

	TRAP(err, DoTestL());

	TEST2(err, KErrNone);

	CloseAll();

	DeleteFile(TheDatabaseFileName);

	__UHEAP_MARKEND;

	TheTest.End();

	TheTest.Close();

	delete TheTrapCleanup;

	return KErrNone;

    }