diff -r 000000000000 -r a41df078684a kerneltest/f32test/bench/t_fsysbm.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/bench/t_fsysbm.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1376 @@
+// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "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:
+// f32test/bench/t_fsysbm.cpp
+//
+//
+
+#define __E32TEST_EXTENSION__
+
+#include <f32file.h>
+#include <e32test.h>
+#include <hal.h>
+#include <e32math.h>
+#include "t_server.h"
+#include "../../e32test/mmu/d_sharedchunk.h"
+
+#define SYMBIAN_TEST_EXTENDED_BUFFER_SIZES	// test using a greater number of buffer sizes
+//#define SYMBIAN_TEST_COPY					// read from one drive and write to another
+
+
+GLDEF_D RTest test(_L("File System Benchmarks"));
+
+static const TUint K1K = 1024;								// 1K
+static const TUint K1M = 1024 * 1024;						// 1M
+static const TUint K2M = 2 * K1M;						    // 2M
+
+#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+const TInt64 KGb  	= 1 << 30;
+const TInt64 K3GB   = 3 * KGb;
+const TInt64 K4GB   = 4 * KGb;
+#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+
+#if defined(__WINS__)
+LOCAL_D TInt KMaxFileSize = 256 * K1K;						// 256K
+//LOCAL_D TInt KMaxFileSize = K1M;							// 1M
+#else
+//LOCAL_D TInt KMaxFileSize = 256 * K1K;					// 256K
+//LOCAL_D TInt KMaxFileSize = K1M;							// 1M
+LOCAL_D TInt KMaxFileSize = K2M;							// 2M
+#endif
+
+const TTimeIntervalMicroSeconds32 KFloatingPointTestTime = 10000000;	// 10 seconds
+LOCAL_D const TInt KHeapSize = 0x4000;
+
+LOCAL_D TPtr8 DataBuf(NULL, KMaxFileSize,KMaxFileSize);
+LOCAL_D HBufC8* DataBufH = NULL;
+
+LOCAL_D RSharedChunkLdd Ldd;
+LOCAL_D RChunk TheChunk;
+LOCAL_D TInt PageSize;
+const TUint ChunkSize = KMaxFileSize;
+
+
+LOCAL_D RFile File, File2;
+LOCAL_D TChar gDriveToTest2;
+
+// if enabled, Read and Write operations are not boundary aligned.
+LOCAL_D TBool gMisalignedReadWrites = EFalse;
+
+// read & write caching enabled flags - may be overriden by +/-r +/-w command line switches
+LOCAL_D TBool gReadCachingOn  = EFalse;
+LOCAL_D TBool gWriteCachingOn = EFalse;
+
+// if enabled, timings are for write AND flush
+LOCAL_D TBool gFlushAfterWrite = ETrue;
+
+// if enabled, contiguous shared memory is used for Data buffer
+LOCAL_D TBool gSharedMemory = EFalse;
+
+// if enabled, fragmented shared memory is used for Data buffer
+LOCAL_D TBool gFragSharedMemory = EFalse;
+
+LOCAL_D TInt gFastCounterFreq;
+
+
+
+LOCAL_C void RecursiveRmDir(const TDesC& aDes)
+//
+// Delete directory contents recursively
+//
+	{
+	CDir* pD;
+	TFileName n=aDes;
+	n.Append(_L("*"));
+	TInt r=TheFs.GetDir(n,KEntryAttMaskSupported,EDirsLast,pD);
+	if (r==KErrNotFound || r==KErrPathNotFound)
+		return;
+	test(r==KErrNone);
+	TInt count=pD->Count();
+	TInt i=0;
+	while (i<count)
+		{
+		const TEntry& e=(*pD)[i++];
+		if (e.IsDir())
+			{
+			TFileName dirName;
+			dirName.Format(_L("%S%S\\"),&aDes,&e.iName);
+			RecursiveRmDir(dirName);
+			}
+		else
+			{
+			TFileName fileName;
+			fileName.Format(_L("%S%S"),&aDes,&e.iName);
+			r=TheFs.Delete(fileName);
+			test(r==KErrNone);
+			}
+		}
+	delete pD;
+	r=TheFs.RmDir(aDes);
+	test(r==KErrNone);
+	}
+
+
+void LOCAL_C ClearSessionDirectory()
+//
+// Delete the contents of F32-TST
+//
+	{
+	TParse sessionPath;
+	TInt r=TheFs.Parse(_L("\\F32-TST\\"),_L(""),sessionPath);
+	test(r==KErrNone);
+	RecursiveRmDir(sessionPath.FullName());
+	r=TheFs.MkDir(sessionPath.FullName());
+	test(r==KErrNone);
+	}
+
+
+LOCAL_C void DoTestFileRead(TInt aBlockSize, TInt aFileSize = KMaxFileSize, TBool aReRead = EFalse)
+//
+// Do Read Test
+//
+	{
+	// Create test data
+//	test.Printf(_L("Creating test file..."));
+	TInt writeBlockLen = aFileSize > DataBuf.MaxSize() ? DataBuf.MaxSize() : aFileSize;
+	DataBuf.SetLength(writeBlockLen);
+#if defined(_DEBUG)
+	for (TInt m = 0; m < DataBuf.Length(); m++)
+		DataBuf[m] = TText8(m % 256);
+#endif
+	// To allow this test to run on a non-preq914 branch :
+	enum {EFileWriteDirectIO = 0x00001000};
+	TInt r = File.Create(TheFs, _L("READTEST"), EFileStream | EFileWriteDirectIO);
+	test(r == KErrNone);
+	TInt count = aFileSize / DataBuf.Length();
+	while (count--)
+		File.Write(DataBuf);
+//	test.Printf(_L("done\n"));
+	File.Close();
+
+	enum {EFileReadBuffered = 0x00002000, EFileReadDirectIO = 0x00004000};
+	r = File.Open(TheFs, _L("READTEST"), EFileStream | (gReadCachingOn ? EFileReadBuffered : EFileReadDirectIO));
+	test(r == KErrNone);
+
+//	const TInt maxReadCount = aFileSize / aBlockSize;
+	TUint functionCalls = 0;
+
+#if defined SYMBIAN_TEST_COPY
+	// To allow this test to run on a non-preq914 branch :
+	enum {EFileWriteDirectIO = 0x00001000};
+	TInt r = File2.Replace(TheFs, _L("WRITETEST"), EFileStream | EFileWriteDirectIO);
+	test(r == KErrNone);
+#endif
+
+	TTime startTime(0);
+	TTime endTime(0);
+
+	// we stop after the entire file has been read or after 10 seconds, whichever happens sooner
+	RTimer timer;
+	timer.CreateLocal();
+	TRequestStatus reqStat;
+
+
+	TUint initTicks = 0;
+	TUint finalTicks = 0;
+
+	// if aReRead file is set, then read file twice
+	for (TInt n=0; n<(aReRead?2:1); n++)
+		{
+		functionCalls = 0;
+
+		const TInt readLen = (aReRead && n == 0) ? writeBlockLen : aBlockSize;
+		const TInt maxReadCount = aFileSize / readLen;
+
+		TInt pos = 0;
+		File.Seek(ESeekStart, pos);
+
+		timer.After(reqStat, 10000000); // After 10 secs
+		startTime.HomeTime();
+		initTicks = User::FastCounter();
+
+		for (TInt i = 0; i<maxReadCount && reqStat==KRequestPending; i++)
+			{
+//			test.Printf(_L("Read %d\n"),i);
+//			for (TInt a = 0; a < 512; a++)
+//				test.Printf(_L("%d"),DataBuf[a]);
+
+			TInt r = File.Read(DataBuf, readLen);
+			test (r == KErrNone);
+
+			if (DataBuf.Length() == 0)
+				break;
+
+#if defined SYMBIAN_TEST_COPY
+			r = File2.Write(DataBuf, readLen);
+			test (r == KErrNone);
+#endif
+			functionCalls++;
+
+#if defined(_DEBUG)
+//			for (TInt a = 0; a < 512; a++)
+//				test.Printf(_L("%d"),DataBuf[a]);
+
+			for (TInt j = 0; j < DataBuf.Size(); j++)
+				test(DataBuf[j] == (j + i * readLen) % 256);
+#endif
+
+			}
+
+		finalTicks = User::FastCounter();
+		endTime.HomeTime();
+		timer.Cancel();
+		}
+
+	TInt dataTransferred = functionCalls * aBlockSize;
+
+//	TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(startTime);
+	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;
+
+	TReal transferRate =
+		TReal32(dataTransferred) /
+		TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
+	test.Printf(_L("Read %7d bytes in %7d byte blocks:\t%11.3f KBytes/s (%d microsecs)\n"),
+		dataTransferred, aBlockSize, transferRate, endTime.MicroSecondsFrom(startTime).Int64());
+
+
+	timer.Close();
+#if defined SYMBIAN_TEST_COPY
+	File2.Close();
+#endif
+
+	File.Close();
+	r = TheFs.Delete(_L("READTEST"));
+	test(r == KErrNone);
+	return;
+	}
+
+
+LOCAL_C void TestFileRead(TInt aFileSize = KMaxFileSize, TBool aMisalignedReadWrites = EFalse, TBool aReRead = EFalse)
+//
+// Benchmark read method
+//
+	{
+	ClearSessionDirectory();
+	test.Next(_L("Benchmark read method"));
+
+	_LIT(KLitReadOnce,"Read-once");
+	_LIT(KLitReRead,"Re-read");
+	test.Printf(_L("FileSize %d, MisalignedReadWrites %d %S\n"), aFileSize, aMisalignedReadWrites, aReRead ? &KLitReRead : &KLitReadOnce);
+	TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;
+
+#if defined (SYMBIAN_TEST_EXTENDED_BUFFER_SIZES)
+	DoTestFileRead(1+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(2+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(4+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(8+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(16+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(32+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(64+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(128+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(256+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(512+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(2 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(4 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(8 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(16 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(32 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(64 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(128 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(256 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(512 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(1024 * 1024+misalignedOffset, aFileSize, aReRead);
+#else
+	DoTestFileRead(16+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(512+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(4096+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(32768+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(64 * 1024+misalignedOffset, aFileSize, aReRead);
+	DoTestFileRead(K1M+misalignedOffset, aFileSize, aReRead);
+#endif
+
+	}
+
+
+LOCAL_C TInt FloatingPointLoop(TAny* funcCount)
+	{
+	TUint& count = *(TUint*) funcCount;
+	TReal eq = KPi;
+
+	FOREVER
+		{
+		eq *= eq;
+		count++;
+		}
+
+	}
+
+
+LOCAL_C void DoTestFileReadCPU(TInt aBlockSize)
+//
+// Benchmark CPU utilisation for Read method
+//
+// Read operations are performed for 10 seconds whilst a second thread executes floating point calculations
+// The higher the number of calculations the less amount of CPU time has been used by the Read method.
+//
+	{
+	enum {EFileReadBuffered = 0x00002000, EFileReadDirectIO = 0x00004000};
+	TInt r = File.Open(TheFs, _L("READCPUTEST"), EFileStream | (gReadCachingOn ? EFileReadBuffered : EFileReadDirectIO));
+	test(r == KErrNone);
+
+	TInt pos = 0;
+
+	TUint functionCalls = 0;
+	TUint fltPntCalls = 0;
+	RThread fltPntThrd;
+
+	TBuf<6> buf = _L("Floaty");
+	fltPntThrd.Create(buf, FloatingPointLoop, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*) &fltPntCalls);
+
+	RTimer timer;
+	timer.CreateLocal();
+	TRequestStatus reqStat;
+
+	TUint initTicks = 0;
+	TUint finalTicks = 0;
+
+	timer.After(reqStat, KFloatingPointTestTime); // After 10 secs
+	initTicks = User::FastCounter();
+
+	// up the priority of this thread so that we only run the floating point thread when this thread is idle
+	RThread				thisThread;
+	thisThread.SetPriority(EPriorityMuchMore);
+
+	TRequestStatus req;
+	fltPntThrd.Logon(req);
+
+	fltPntThrd.Resume();
+
+	for (TInt i = 0; reqStat==KRequestPending; i++)
+		{
+		TInt r = File.Read(pos, DataBuf, aBlockSize);
+		test (r == KErrNone);
+
+		pos += aBlockSize;
+		if (pos > KMaxFileSize-aBlockSize)
+			pos = 0;
+
+		functionCalls++;
+		}
+
+	TUint fltPntCallsFinal = fltPntCalls;
+	fltPntThrd.Kill(KErrNone);
+
+	finalTicks = User::FastCounter();
+
+	fltPntThrd.Close();
+	User::WaitForRequest(req);
+
+	TInt dataTransferred = functionCalls * aBlockSize;
+
+	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;
+
+	TReal transferRate =  TReal32(dataTransferred) /
+						 TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
+
+	test.Printf(_L("Read %7d bytes in %7d byte blocks:\t%11.3f KBytes/s; %d Flt Calcs\n"),
+				    dataTransferred, aBlockSize, transferRate, fltPntCallsFinal);
+
+	timer.Close();
+
+	File.Close();
+
+	return;
+	}
+
+
+LOCAL_C void TestFileReadCPU(TBool aMisalignedReadWrites = EFalse)
+//
+// Benchmark CPU utilisation for Read method
+//
+	{
+	ClearSessionDirectory();
+	test.Next(_L("Benchmark Read method CPU Utilisation"));
+
+	test.Printf(_L("MisalignedReadWrites %d\n"), aMisalignedReadWrites);
+	TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;
+
+	// Create test data
+	test.Printf(_L("Creating test file..."));
+	DataBuf.SetLength(KMaxFileSize);
+
+	TInt r = File.Create(TheFs, _L("READCPUTEST"), EFileStream | EFileWriteDirectIO);
+	test(r == KErrNone);
+
+	File.Write(DataBuf);
+
+	test.Printf(_L("done\n"));
+	File.Close();
+
+	DoTestFileReadCPU(1+misalignedOffset);
+	DoTestFileReadCPU(2+misalignedOffset);
+	DoTestFileReadCPU(4+misalignedOffset);
+	DoTestFileReadCPU(8+misalignedOffset);
+	DoTestFileReadCPU(16+misalignedOffset);
+	DoTestFileReadCPU(32+misalignedOffset);
+	DoTestFileReadCPU(64+misalignedOffset);
+	DoTestFileReadCPU(128+misalignedOffset);
+	DoTestFileReadCPU(256+misalignedOffset);
+	DoTestFileReadCPU(512+misalignedOffset);
+	DoTestFileReadCPU(1024+misalignedOffset);
+	DoTestFileReadCPU(2 * 1024+misalignedOffset);
+	DoTestFileReadCPU(4 * 1024+misalignedOffset);
+	DoTestFileReadCPU(8 * 1024+misalignedOffset);
+	DoTestFileReadCPU(16 * 1024+misalignedOffset);
+	DoTestFileReadCPU(32 * 1024+misalignedOffset);
+	DoTestFileReadCPU(64 * 1024+misalignedOffset);
+	DoTestFileReadCPU(128 * 1024+misalignedOffset);
+	DoTestFileReadCPU(256 * 1024+misalignedOffset);
+	DoTestFileReadCPU(512 * 1024+misalignedOffset);
+	DoTestFileReadCPU(K1M+misalignedOffset);
+
+
+	r = TheFs.Delete(_L("READCPUTEST"));
+	test(r == KErrNone);
+	}
+
+
+LOCAL_C void DoTestFileWrite(TInt aBlockSize, TInt aFileSize = KMaxFileSize, TBool aUpdate = EFalse)
+//
+// Do Write benchmark
+//
+	{
+	DataBuf.SetLength(aBlockSize);
+	const TInt maxWriteCount = aFileSize / aBlockSize;
+
+	TFileName testDir(_L("?:\\F32-TST\\"));
+	testDir[0] = (TText) gDriveToTest;
+	TInt r = TheFs.MkDir(testDir);
+	test(r == KErrNone || r == KErrAlreadyExists);
+
+	TFileName fileName;
+	enum {EFileWriteDirectIO = 0x00001000, EFileWriteBuffered = 0x00000800};
+	r = File.Temp(TheFs, testDir, fileName, EFileWrite | (gWriteCachingOn ? EFileWriteBuffered : EFileWriteDirectIO));
+	test(r == KErrNone);
+
+	if (aUpdate)
+		{
+		TInt r = File.SetSize(aFileSize);
+		test(r == KErrNone);
+		}
+
+	TUint functionCalls = 0;
+
+	TTime startTime;
+	TTime endTime;
+	TUint initTicks = 0;
+	TUint finalTicks = 0;
+
+
+	// we stop after the entire file has been written or after 10 seconds, whichever happens sooner
+	RTimer timer;
+	timer.CreateLocal();
+	TRequestStatus reqStat;
+
+	TInt pos = 0;
+	File.Seek(ESeekStart, pos);
+
+	timer.After(reqStat, 10000000); // After 10 secs
+
+	startTime.HomeTime();
+	initTicks = User::FastCounter();
+
+	for (TInt i = 0 ; i<maxWriteCount && reqStat==KRequestPending; i++)
+		{
+		File.Write(pos, DataBuf, aBlockSize);
+
+		pos += aBlockSize;
+		if (pos > KMaxFileSize-aBlockSize)
+			pos = 0;
+
+		functionCalls++;
+		}
+
+	if (gFlushAfterWrite)
+		{
+		r = File.Flush();
+		test_KErrNone(r)
+		}
+
+	// write file once only
+	finalTicks = User::FastCounter();
+	endTime.HomeTime();
+//	TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(startTime);
+	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;
+
+	TInt dataTransferred = functionCalls * aBlockSize;
+	TReal transferRate =
+		TReal32(dataTransferred) /
+		TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
+	test.Printf(_L("Write %7d bytes in %7d byte blocks:\t%11.3f KBytes/s (%d microsecs)\n"),
+		dataTransferred, aBlockSize, transferRate, endTime.MicroSecondsFrom(startTime).Int64());
+
+	timer.Close();
+
+	File.Close();
+	r = TheFs.Delete(fileName);
+	test_KErrNone(r)
+
+	return;
+	}
+
+
+LOCAL_C void TestFileWrite(TInt aFileSize = KMaxFileSize, TBool aMisalignedReadWrites = EFalse, TBool aUpdate = EFalse)
+//
+// Benchmark write method
+//
+	{
+	ClearSessionDirectory();
+	test.Next(_L("Benchmark write method"));
+
+	_LIT(KLitUpdate,"update");
+	_LIT(KLitAppend,"append");
+	test.Printf(_L("FileSize %d %S MisalignedReadWrites %d\n"), aFileSize, aUpdate? &KLitUpdate : &KLitAppend, aMisalignedReadWrites);
+
+	TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;
+
+#if defined (SYMBIAN_TEST_EXTENDED_BUFFER_SIZES)
+	DoTestFileWrite(1+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(2+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(4+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(8+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(16+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(32+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(64+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(128+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(256+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(512+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(2 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(4 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(8 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(16 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(32 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(64 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(128 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(256 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(512 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(1024 * 1024+misalignedOffset, aFileSize, aUpdate);
+#else
+	DoTestFileWrite(16+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(512+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(4096+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(32768+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(64 * 1024+misalignedOffset, aFileSize, aUpdate);
+	DoTestFileWrite(K1M+misalignedOffset, aFileSize, aUpdate);
+#endif
+	}
+
+
+
+LOCAL_C void DoTestFileWriteCPU(TInt aBlockSize)
+//
+// Benchmark CPU utilisation for Write method
+//
+// Write operations are performed for 10 seconds whilst a second thread executes floating point calculations
+// The higher the number of calculations the less amount of CPU time has been used by the Write method.
+//
+	{
+	DataBuf.SetLength(aBlockSize);
+
+	TFileName testDir(_L("?:\\F32-TST\\"));
+	testDir[0] = (TText) gDriveToTest;
+	TInt r = TheFs.MkDir(testDir);
+	test(r == KErrNone || r == KErrAlreadyExists);
+
+	TFileName fileName;
+	enum {EFileWriteDirectIO = 0x00001000, EFileWriteBuffered = 0x00000800};
+	r = File.Temp(TheFs, testDir, fileName, EFileWrite | (gWriteCachingOn ? EFileWriteBuffered : EFileWriteDirectIO));
+	test(r == KErrNone);
+
+	TUint functionCalls = 0;
+	TUint fltPntCalls = 0;
+	RThread fltPntThrd;
+
+	TBuf<6> buf = _L("Floaty");
+	fltPntThrd.Create(buf, FloatingPointLoop, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*) &fltPntCalls);
+
+	TUint initTicks = 0;
+	TUint finalTicks = 0;
+
+	// up the priority of this thread so that we only run the floating point thread when this thread is idle
+	RThread				thisThread;
+	thisThread.SetPriority(EPriorityMuchMore);
+
+	TRequestStatus req;
+	fltPntThrd.Logon(req);
+
+	RTimer timer;
+	timer.CreateLocal();
+	TRequestStatus reqStat;
+
+	TInt pos = 0;
+	File.Seek(ESeekStart, pos);
+
+	timer.After(reqStat, KFloatingPointTestTime);
+	initTicks = User::FastCounter();
+
+	fltPntThrd.Resume();
+
+	for (TInt i = 0 ; reqStat==KRequestPending; i++)
+		{
+		File.Write(DataBuf, aBlockSize);
+		functionCalls++;
+		}
+	TUint fltPntCallsFinal = fltPntCalls;
+
+	fltPntThrd.Kill(KErrNone);
+
+	finalTicks = User::FastCounter();
+
+	fltPntThrd.Close();
+	User::WaitForRequest(req);
+
+	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;
+
+	TInt dataTransferred = functionCalls * aBlockSize;
+	TReal transferRate =  TReal32(dataTransferred) /
+						 TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
+
+	test.Printf(_L("Write %7d bytes in %7d byte blocks:\t%11.3f KBytes/s; %d Flt Calcs\n"),
+				    dataTransferred, aBlockSize, transferRate, fltPntCallsFinal);
+
+	timer.Close();
+
+	File.Close();
+	r = TheFs.Delete(fileName);
+	test_KErrNone(r)
+
+	return;
+	}
+
+
+LOCAL_C void TestFileWriteCPU(TBool aMisalignedReadWrites = EFalse)
+//
+// Benchmark CPU utilisation for Write method
+//
+	{
+	ClearSessionDirectory();
+	test.Next(_L("Benchmark Write method CPU Utilisation"));
+
+	test.Printf(_L("MisalignedReadWrites %d\n"), aMisalignedReadWrites);
+	TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;
+
+	DoTestFileWriteCPU(1+misalignedOffset);
+	DoTestFileWriteCPU(2+misalignedOffset);
+	DoTestFileWriteCPU(4+misalignedOffset);
+	DoTestFileWriteCPU(8+misalignedOffset);
+	DoTestFileWriteCPU(16+misalignedOffset);
+	DoTestFileWriteCPU(32+misalignedOffset);
+	DoTestFileWriteCPU(64+misalignedOffset);
+	DoTestFileWriteCPU(128+misalignedOffset);
+	DoTestFileWriteCPU(256+misalignedOffset);
+	DoTestFileWriteCPU(512+misalignedOffset);
+	DoTestFileWriteCPU(1024+misalignedOffset);
+	DoTestFileWriteCPU(2 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(4 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(8 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(16 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(32 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(64 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(128 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(256 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(512 * 1024+misalignedOffset);
+	DoTestFileWriteCPU(K1M+misalignedOffset);
+	}
+
+
+LOCAL_C void TestFileSeek()
+//
+// Benchmark file seek method
+//
+	{
+	ClearSessionDirectory();
+	test.Next(_L("RFile::Seek method"));
+	TInt increment=1789; // random number > cluster size
+	TInt count=0;
+	TInt pos=0;
+
+	// Create test file
+	TBuf8<1024> testdata(1024);
+	RFile f;
+	TInt r=f.Create(TheFs,_L("SEEKTEST"),EFileStream);
+	test(r==KErrNone);
+	count=64;
+	while (count--)
+		f.Write(testdata);
+	TInt fileSize=count*testdata.MaxLength();
+
+	pos=0;
+	count=0;
+	RTimer timer;
+	timer.CreateLocal();
+	TRequestStatus reqStat;
+	timer.After(reqStat,10000000); // After 10 secs
+	while(reqStat==KRequestPending)
+		{
+		TInt dum=(pos+=increment)%fileSize;
+		f.Seek(ESeekStart,dum);
+		count++;
+		}
+	test.Printf(_L("RFile::Seek operations in 10 secs == %d\n"),count);
+	timer.Close();
+
+	f.Close();
+	TheFs.Delete(_L("SEEKTEST"));
+	}
+
+#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+
+LOCAL_C void CreateManyLargFiles(TInt aNumber)
+//
+// Make a directory with aNumber entries
+//
+	{
+	RFile64 f;
+	TInt maxEntry=aNumber;
+
+	test.Printf(_L("Create a directory with %d entries\n"),aNumber);
+
+	TFileName sessionPath;
+	TInt r=TheFs.SessionPath(sessionPath);
+	test(r==KErrNone);
+	r=TheFs.MkDir(_L("\\F32-TST\\"));
+	test((r==KErrNone)||(r==KErrAlreadyExists));
+	r=TheFs.MkDir(_L("\\F32-TST\\BENCH_DELETE\\"));
+	test((r==KErrNone)||(r==KErrAlreadyExists));
+	TBuf8<8> WriteData =_L8("Wibbleuy");
+	for (TInt i=0;i<maxEntry;i++)
+		{
+		TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+		baseName.AppendNum(i);
+		r=f.Replace(TheFs,baseName,EFileWrite);
+		test(r==KErrNone);
+		r = f.SetSize(K3GB);
+		test(r==KErrNone);
+		r=f.Write((K3GB-30),WriteData);
+		test(r==KErrNone);
+		f.Flush();
+		f.Close();
+		}
+
+	test.Printf(_L("Test all entries have been created successfully\n"));
+	TBuf8<8> ReadData;
+	TInt64 Size=0;
+	for (TInt j=0;j<=maxEntry;j++)
+		{
+		TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+		baseName.AppendNum(j);
+
+		TInt r=f.Open(TheFs,baseName,EFileRead);
+		if (r!=KErrNone)
+			{
+			test(r==KErrNotFound && j==maxEntry);
+			return;
+			}
+		ReadData.FillZ();
+		r=f.Read((K3GB-30),ReadData);
+		test(r==KErrNone);
+		test(f.Size(Size)==KErrNone);
+		test(K3GB == Size);
+		test(ReadData==WriteData);
+		f.Close();
+		}
+	}
+
+
+LOCAL_C void TestLargeFileDelete()
+//
+// This test require MMC/SD card size >=4GB-2 in size
+//
+	{
+	ClearSessionDirectory();
+	test.Next(_L("Benchmark delete large file"));
+
+	TInt64 total=0;
+
+	TInt cycles=1;
+
+	TInt i=0;
+
+	//check Disk space and decide how many files to create
+	TVolumeInfo volInfo;
+    TInt r;
+
+    r = TheFs.Volume(volInfo);
+    test(r == KErrNone);
+
+	TInt numberOfFiles = (TUint)(volInfo.iFree/(K4GB -2));
+	test.Printf(_L("Number of large files =%d \n"),numberOfFiles);
+
+	if(numberOfFiles<=0)
+		{
+		test.Printf(_L("Large File delete is skipped \n"));
+		return;
+		}
+
+	for (; i<cycles; i++)
+		{
+	//	Create many files
+		CreateManyLargFiles(numberOfFiles);
+
+		test.Next(_L("Time the delete"));
+	//	Now delete them and time it
+		TTime startTime;
+		startTime.HomeTime();
+
+		for (TInt index=0;index<numberOfFiles;index++)
+			{
+			TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+			baseName.AppendNum(index);
+
+			TInt r=TheFs.Delete(baseName);
+			test(r==KErrNone);
+			}
+
+		TTime endTime;
+		endTime.HomeTime();
+		TTimeIntervalMicroSeconds timeTaken;
+		timeTaken=endTime.MicroSecondsFrom(startTime);
+		TInt64 time=timeTaken.Int64();
+		total+=time;
+		}
+//	We deleted cycles*numberOfFiles files in total microseconds
+	TInt64 fileDeleteTime=total/(numberOfFiles*cycles);
+	test.Next(_L("Benchmarked RFs::Delete()"));
+	test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);
+
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	total=0;
+
+	cycles=1;
+	i=0;
+	for (; i<cycles; i++)
+		{
+	//	Create many files
+		CreateManyLargFiles(numberOfFiles);
+
+		test.Next(_L("Time the delete"));
+	//	Now delete them and time it
+		TTime startTime;
+		startTime.HomeTime();
+
+		for (TInt index=0;index<numberOfFiles;index++)
+			{
+			TInt r=fMan->Delete(_L("\\F32-TST\\BENCH_DELETE\\FILE*"));
+			test(r==KErrNone || r==KErrNotFound);
+			}
+
+		TTime endTime;
+		endTime.HomeTime();
+		TTimeIntervalMicroSeconds timeTaken;
+		timeTaken=endTime.MicroSecondsFrom(startTime);
+		TInt64 time=timeTaken.Int64();
+		total+=time;
+		}
+//	We deleted cycles*numberOfFiles files in total microseconds
+	fileDeleteTime=total/(numberOfFiles*cycles);
+	test.Next(_L("Benchmarked CFileMan::Delete()"));
+	test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);
+
+	delete fMan;
+}
+
+#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+
+
+LOCAL_C void CreateManyFiles(TInt aNumber)
+//
+// Make a directory with aNumber entries
+//
+	{
+	RFile f;
+	TInt maxEntry=aNumber;
+
+	test.Printf(_L("Create a directory with %d entries\n"),aNumber);
+
+	TFileName sessionPath;
+	TInt r=TheFs.SessionPath(sessionPath);
+	test(r==KErrNone);
+	r=TheFs.MkDir(_L("\\F32-TST\\"));
+	test((r==KErrNone)||(r==KErrAlreadyExists));
+	r=TheFs.MkDir(_L("\\F32-TST\\BENCH_DELETE\\"));
+	test((r==KErrNone)||(r==KErrAlreadyExists));
+
+	for (TInt i=0;i<maxEntry;i++)
+		{
+		TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+		baseName.AppendNum(i);
+		r=f.Replace(TheFs,baseName,EFileRead);
+		test(r==KErrNone);
+		r=f.Write(_L8("Wibble"));
+		test(r==KErrNone);
+		f.Close();
+		}
+
+	test.Printf(_L("Test all entries have been created successfully\n"));
+	for (TInt j=0;j<=maxEntry;j++)
+		{
+		TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+		baseName.AppendNum(j);
+		TInt r=f.Open(TheFs,baseName,EFileRead);
+		if (r!=KErrNone)
+			{
+			test(r==KErrNotFound && j==maxEntry);
+			return;
+			}
+		TBuf8<16> data;
+		r=f.Read(data);
+		test(r==KErrNone);
+		test(data==_L8("Wibble"));
+		f.Close();
+		}
+	}
+
+
+LOCAL_C void TestFileDelete()
+//
+//
+//
+	{
+	ClearSessionDirectory();
+	test.Next(_L("Benchmark delete"));
+
+	TInt64 total=0;
+	TInt numberOfFiles=100;
+	TInt cycles=1;
+
+	TInt i=0;
+	for (; i<cycles; i++)
+		{
+	//	Create many files
+		CreateManyFiles(numberOfFiles);
+
+		test.Next(_L("Time the delete"));
+	//	Now delete them and time it
+		TTime startTime;
+		startTime.HomeTime();
+
+		for (TInt index=0;index<numberOfFiles;index++)
+			{
+			TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+			baseName.AppendNum(index);
+
+			TInt r=TheFs.Delete(baseName);
+			test(r==KErrNone);
+			}
+
+		TTime endTime;
+		endTime.HomeTime();
+		TTimeIntervalMicroSeconds timeTaken;
+		timeTaken=endTime.MicroSecondsFrom(startTime);
+		TInt64 time=timeTaken.Int64();
+		total+=time;
+		}
+//	We deleted cycles*numberOfFiles files in total microseconds
+	TInt64 fileDeleteTime=total/(numberOfFiles*cycles);
+	test.Next(_L("Benchmarked RFs::Delete()"));
+	test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);
+
+	CFileMan* fMan=CFileMan::NewL(TheFs);
+	total=0;
+	numberOfFiles=100;
+	cycles=1;
+	i=0;
+	for (; i<cycles; i++)
+		{
+	//	Create many files
+		CreateManyFiles(numberOfFiles);
+
+		test.Next(_L("Time the delete"));
+	//	Now delete them and time it
+		TTime startTime;
+		startTime.HomeTime();
+
+		for (TInt index=0;index<numberOfFiles;index++)
+			{
+			TInt r=fMan->Delete(_L("\\F32-TST\\BENCH_DELETE\\FILE*"));
+			test(r==KErrNone || r==KErrNotFound);
+			}
+
+		TTime endTime;
+		endTime.HomeTime();
+		TTimeIntervalMicroSeconds timeTaken;
+		timeTaken=endTime.MicroSecondsFrom(startTime);
+		TInt64 time=timeTaken.Int64();
+		total+=time;
+		}
+//	We deleted cycles*numberOfFiles files in total microseconds
+	fileDeleteTime=total/(numberOfFiles*cycles);
+	test.Next(_L("Benchmarked CFileMan::Delete()"));
+	test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);
+
+	delete fMan;
+}
+
+
+/*
+TInt maxDirEntry=200;
+LOCAL_C void TestDirRead()
+//
+// Benchmark directory read method
+//
+	{
+
+	ClearSessionDirectory();
+	test.Next(_L("Benchmark directory read method"));
+// Create one test entry
+	RFile f;
+	f.Create(TheFs,_L("ONE.XXX"),EFileStream);
+	f.Close();
+	TTime start;
+	start.HomeTime();
+	TInt i=0;
+	for (i=0;i<maxDirEntry;i++)
+		{
+		CDir* dirPtr;
+		TheFs.GetDir(_L("*"),KEntryAttMaskSupported,ESortByName,dirPtr);
+		delete dirPtr;
+		}
+	TTime end;
+	end.HomeTime();
+	DirReadOne=end.MicroSecondsFrom(start);
+// Create lost of test entries
+	for (i=0;i<maxDirEntry;i++)
+		{
+		TBuf<12> baseName(_L("MANY"));
+		baseName.AppendNum(i,EHex);
+		baseName.Append(_L(".TXT"));
+		RFile f;
+		f.Create(TheFs,baseName,EFileStream);
+		f.Close();
+		}
+	start.HomeTime();
+	CDir* dirPtr;
+	TheFs.GetDir(_L("*"),KEntryAttMaskSupported,ESortByName,dirPtr);
+	delete dirPtr;
+	end.HomeTime();
+	DirReadMany=end.MicroSecondsFrom(start);
+// Select one entry from lots
+	start.HomeTime();
+	TheFs.GetDir(_L("*.XXX"),KEntryAttMaskSupported,ESortByName,dirPtr);
+	end.HomeTime();
+	test(dirPtr->Count()==1);
+	delete dirPtr;
+	DirMatchOne=end.MicroSecondsFrom(start);
+	}
+
+
+void LOCAL_C PrintDirResults()
+//
+// Print results of Directory Benchmark
+//
+	{
+	test.Printf(_L("\nBenchmark: Dir Results\n"));
+	test.Printf(_L("Read one entry %d times = %d ms\n"),maxDirEntry,DirReadOne.Int64().GetTInt()/1000);
+	test.Printf(_L("Read %d entries = %d ms\n"),maxDirEntry,DirReadMany.Int64().GetTInt()/1000);
+	test.Printf(_L("Match 1 entry from %d entries = %d ms\n"),maxDirEntry,DirMatchOne.Int64().GetTInt()/1000);
+	test.Printf(_L("Press Enter to continue\n\n"));
+	test.Getch();
+	}
+*/
+
+
+LOCAL_C void TestMkDir()
+	{
+	test.Next(_L("Benchmark MkDir"));
+	ClearSessionDirectory();
+
+	TTime startTime;
+	TTime endTime;
+	TTimeIntervalMicroSeconds timeTaken(0);
+	startTime.HomeTime();
+
+	const TInt KNumDirEntries = 100;
+	for (TInt n=0; n<KNumDirEntries; n++)
+		{
+		TFileName dirName = _L("\\F32-TST\\DIR_");
+		dirName.AppendNum(n);
+		dirName.Append(_L("\\"));
+		TInt r = TheFs.MkDir(dirName);
+		test(r == KErrNone);
+		}
+
+	endTime.HomeTime();
+	timeTaken=endTime.MicroSecondsFrom(startTime);
+	TInt timeTakenInMs = I64LOW(timeTaken.Int64() / 1000);
+	test.Printf(_L("Time taken to create %d entries = %d ms\n"), KNumDirEntries, timeTakenInMs);
+	}
+
+
+// Allocate Data Buffers for Read/Write Tests
+void AllocateBuffers()
+	{
+	test.Printf(_L("Allocate Buffers -"));
+
+	if (gFragSharedMemory || gSharedMemory)
+		{
+		test.Printf(_L("Shared Memory\n"));
+
+		RLoader l;
+		test(l.Connect()==KErrNone);
+		test(l.CancelLazyDllUnload()==KErrNone);
+		l.Close();
+
+		test.Printf(_L("Initialise\n"));
+		TInt r = UserHal::PageSizeInBytes(PageSize);
+		test(r==KErrNone);
+
+		test.Printf(_L("Loading test driver\n"));
+		r = User::LoadLogicalDevice(KSharedChunkLddName);
+		test(r==KErrNone || r==KErrAlreadyExists);
+
+		test.Printf(_L("Opening channel\n"));
+		r = Ldd.Open();
+		test(r==KErrNone);
+
+		test.Printf(_L("Create chunk\n"));
+
+		TUint aCreateFlags = EMultiple|EOwnsMemory;
+	    TCommitType aCommitType = EContiguous;
+
+	    TUint TotalChunkSize = ChunkSize;  // rounded to nearest Page Size
+
+		TUint ChunkAttribs = TotalChunkSize|aCreateFlags;
+		r = Ldd.CreateChunk(ChunkAttribs);
+		test(r==KErrNone);
+
+		if (gSharedMemory)
+			{
+		    test.Printf(_L("Commit Contigouos Memory\n"));
+		    r = Ldd.CommitMemory(aCommitType,TotalChunkSize);
+			test(r==KErrNone);
+			}
+		else
+			{
+			test.Printf(_L("Commit Fragmented Memory\n"));
+
+			// Allocate Pages in reverse order to maximise memory fragmentation
+			TUint i = ChunkSize;
+			do
+				{
+				i-=PageSize;
+				test.Printf(_L("Commit %d\n"), i);
+				r = Ldd.CommitMemory(aCommitType|i,PageSize);
+				test(r==KErrNone);
+				}while (i>0);
+/*
+			for (TInt i = (ChunkSize-PageSize); i>=0; )
+				{
+				test.Printf(_L("Commit %d\n"), i);
+				r = Ldd.CommitMemory(aCommitType|i,PageSize);
+				test(r==KErrNone);
+				i-=PageSize;
+				}
+*/
+			}
+
+		test.Printf(_L("\nOpen user handle\n"));
+		r = Ldd.GetChunkHandle(TheChunk);
+		test(r==KErrNone);
+
+		DataBuf.Set(TheChunk.Base(),KMaxFileSize, KMaxFileSize);
+		}
+	else
+		{
+		test.Printf(_L("Heap Memory\n"));
+		DataBufH = HBufC8::New(KMaxFileSize);
+		test(DataBufH != NULL);
+
+		DataBuf.Set(DataBufH->Des());
+		}
+	}
+
+
+void DeAllocateBuffers()
+	{
+	test.Printf(_L("DeAllocate Buffers -"));
+
+	if (gFragSharedMemory || gSharedMemory)
+	{
+		test.Printf(_L("Shared Memory\n"));
+		test.Printf(_L("Close user chunk handle\n"));
+		TheChunk.Close();
+
+		test.Printf(_L("Close kernel chunk handle\n"));
+		TInt r = Ldd.CloseChunk();
+		test(r==1);
+
+		test.Printf(_L("Check chunk is destroyed\n"));
+		r = Ldd.IsDestroyed();
+		test(r==1);
+
+		test.Printf(_L("Close test driver\n"));
+		Ldd.Close();
+		}
+	else
+		{
+		test.Printf(_L("Heap Memory\n"));
+		test.Printf(_L("Delete Heap Buffer\n"));
+		delete DataBufH;
+		}
+	}
+
+void ParseCommandLine()
+	{
+	TBuf<0x100> cmd;
+	User::CommandLine(cmd);
+	TLex lex(cmd);
+
+    for (TPtrC token=lex.NextToken(); token.Length() != 0;token.Set(lex.NextToken()))
+		{
+		if (token.MatchF(RProcess().FileName())==0)
+			{
+			continue;
+			}
+
+		if (token.CompareF(_L("-m"))== 0)
+			{
+			gMisalignedReadWrites = ETrue;
+			continue;
+			}
+		if (token.CompareF(_L("-r"))== 0)
+			{
+			gReadCachingOn = EFalse;
+			continue;
+			}
+		if (token.CompareF(_L("+r"))== 0)
+			{
+			gReadCachingOn = ETrue;
+			continue;
+			}
+		if (token.CompareF(_L("-w"))== 0)
+			{
+			gWriteCachingOn = EFalse;
+			continue;
+			}
+		if (token.CompareF(_L("+w"))== 0)
+			{
+			gWriteCachingOn = ETrue;
+			continue;
+			}
+
+		if (token.CompareF(_L("-f"))== 0)
+			{
+			gFlushAfterWrite = EFalse;
+			continue;
+			}
+		if (token.CompareF(_L("+f"))== 0)
+			{
+			gFlushAfterWrite = ETrue;
+			continue;
+			}
+		if (token.CompareF(_L("+s"))== 0)
+			{
+			gSharedMemory = ETrue;
+			continue;
+			}
+		if (token.CompareF(_L("+x"))== 0)
+			{
+			gFragSharedMemory = ETrue;
+			continue;
+			}
+
+		test.Printf(_L("CLP=%S\n"),&token);
+
+		if(token.Length()!=0)
+			{
+			gDriveToTest=token[0];
+			gDriveToTest.UpperCase();
+			}
+		else
+			gDriveToTest='C';
+
+#if defined SYMBIAN_TEST_COPY
+		token.Set(lex.NextToken());
+		if(token.Length()!=0)
+			{
+			gDriveToTest2=token[0];
+			gDriveToTest2.UpperCase();
+			}
+		else
+			gDriveToTest2='C';
+		test.Printf(_L("CLP2=%S\n"),&token);
+#endif
+
+		}
+	}
+
+
+GLDEF_C void CallTestsL(void)
+//
+// Call all tests
+//
+	{
+	test.Title();
+	test.Start(_L("Start Benchmarking ..."));
+
+	test.Next(gSessionPath);
+
+	ParseCommandLine();
+
+	AllocateBuffers();
+	RProcess().SetPriority(EPriorityBackground);
+
+	TInt r = HAL::Get(HAL::EFastCounterFrequency, gFastCounterFreq);
+	test(r == KErrNone);
+	test.Printf(_L("HAL::EFastCounterFrequency %d\n"), gFastCounterFreq);
+
+	test.Printf(_L("gReadCachingOn %d  gWriteCachingOn %d gFlushAfterWrite %d\n"), gReadCachingOn, gWriteCachingOn, gFlushAfterWrite);
+
+	TestFileSeek();
+
+	// read once
+	TestFileRead(KMaxFileSize, gMisalignedReadWrites, EFalse);
+
+	// re-read
+	TestFileRead(KMaxFileSize, gMisalignedReadWrites, ETrue);
+
+	TestFileReadCPU(gMisalignedReadWrites);
+
+	// append to file
+	TestFileWrite(KMaxFileSize, gMisalignedReadWrites, EFalse);
+
+	// update (overwrite) file
+	TestFileWrite(KMaxFileSize, gMisalignedReadWrites, ETrue);
+
+	TestFileWriteCPU(gMisalignedReadWrites);
+
+	TestFileDelete();
+
+//	TestDirRead();
+//	PrintDirResults();
+#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+	TestLargeFileDelete();
+#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+
+	TestMkDir();
+
+	RecursiveRmDir(gSessionPath);
+
+	DeAllocateBuffers();
+
+	test.End();
+	test.Close();
+	}