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

// tests read/write throughput on two drives simultaneously

// 

//

//! @file f32test\concur\t_cfsbench.cpp

#include <f32file.h>

#include <e32test.h>

#include <f32dbg.h>

#include "t_server.h"

#include "t_tdebug.h"

//IMPORT_C TUint32 DebugRegister();

GLDEF_D RTest test(_L("T_CFSBENCH"));

GLDEF_D	RFs TheFs;

LOCAL_D TFullName gFsName;

LOCAL_D TFullName gFsName1;

LOCAL_D TFullName gFsName2;

LOCAL_D TFullName gOldFsName;

LOCAL_D TFullName gNewFsName;

LOCAL_D TBool     gNoMedia = ETrue;

_LIT(KFsFile, "CFAFSDLY");

_LIT(KFsName, "DelayFS");

LOCAL_D const TInt32 KSecond = 1000000;

LOCAL_D const TInt32 KTimeBM = 20;

LOCAL_D const TInt32 KBufLen = 0x100;

LOCAL_D const TInt32 KMaxLag = 4;

LOCAL_D TBool gVerbose = EFalse;

TBuf16<KBufLen> gResults;

const TInt KMaxFileSize = (4*1024*1024);

const TInt KMinBufferSize = (16);

const TInt KMaxBufferSize = (512*1024);

const TInt KMaxIter = 17;

TBool gReadTests = EFalse;

TBool gWriteTests = EFalse;

TBool gAsyncTests = EFalse;

TBool gSyncTests = EFalse;

LOCAL_C TInt32 GetSpeed(TInt aOps, TInt aBufSize, TInt64 aDtime)

/// Calculate and return the throughput from the umber of blocks transferred

/// and the elapsed time.

	{

	TInt64 dsize = MAKE_TINT64(0, aOps) * MAKE_TINT64(0, aBufSize) * MAKE_TINT64(0, KSecond);

	TInt32 speed = I64LOW((dsize + aDtime/2) / aDtime);

	return speed;

	}

LOCAL_C TBool DriveIsOK(TChar c)

/// Test that a selected drive leter is OK to write files.

	{

	TInt r;

	TInt drv;

	r=TheFs.CharToDrive(c, drv);

	if (r != KErrNone)

		return EFalse;

	TDriveInfo info;

	r=TheFs.Drive(info,drv);

	test(r==KErrNone);

	return (info.iDriveAtt != 0 && !(info.iDriveAtt & KDriveAttRom));

	}

LOCAL_C TChar MountTestFileSystem(TInt aDrive)

//

// Mount a new CTestFileSystem on the drive under test

//

	{

	TInt r;

	TBuf<64> b;

	TChar c;

	r=TheFs.DriveToChar(aDrive,c);

	test(r==KErrNone);

	b.Format(_L("Mount test file system on %c:"),(TUint)c);

	test.Next(b);

	r=TheFs.AddFileSystem(KFsFile);

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

	r=TheFs.FileSystemName(gOldFsName,aDrive);

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

	TDriveInfo drv;

	r = TheFs.Drive(drv, aDrive);

	test(r == KErrNone);

	gNoMedia = (drv.iType == EMediaUnknown || drv.iType == EMediaNotPresent);

	if (gOldFsName.Length() > 0)

		{

		TTest::Printf(_L("Dismount %C: %S"), (TUint)c, &gOldFsName);

		r=TheFs.DismountFileSystem(gOldFsName,aDrive);

		test(r==KErrNone);

		}

	r=TheFs.MountFileSystem(KFsName,aDrive);

	test(r==KErrNone);

	r=TheFs.FileSystemName(gNewFsName,aDrive);

	test(r==KErrNone);

	test(gNewFsName.CompareF(KFsName)==0);

	return c;

	}

LOCAL_C void UnmountFileSystem(TInt aDrive)

/// Unmount a test filesystem and mount the old one.

	{

	TChar c;

	TInt r=TheFs.DriveToChar(aDrive,c);

	test(r==KErrNone);

	r=TheFs.DismountFileSystem(gNewFsName,aDrive);

	test(r==KErrNone);

	// if there's no media present, don't try to mount it

	if (gNoMedia)

		{

		test.Printf(_L("No media on %C: so don't remount it"), (TUint)c);

		}

	else if (gOldFsName.Length() > 0)

		{

		test.Printf(_L("Mount    %C: %S"), (TUint)c, &gOldFsName);

		r=TheFs.MountFileSystem(gOldFsName,aDrive);

		test(r==KErrNone);

		}

	if (r != KErrNone)

		test.Printf(_L("Error %d remounting %S on %C\n"), r, &gOldFsName, (TUint)c);

	}

LOCAL_C void RemountFileSystem(TInt aDrive, TBool aSync)

/// Unmount and remount the file system on the specified drive in the

/// selected mode.

/// @param aDrive Drive number (EDriveC etc.).

/// @param aSync  Mount synchronous if true, asynchronous if not.

	{

	TChar c;

	TInt r=TheFs.DriveToChar(aDrive,c);

	r=TheFs.FileSystemName(gFsName, aDrive);

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

	if (gFsName.Length() > 0)

		{

		r=TheFs.DismountFileSystem(gFsName, aDrive);

		if(r!=KErrNone)

			{

			test.Printf(_L("Error = %d"),r);

			test(EFalse);

			}

		}

	TBufC<16> type = _L("asynchronous");

	if (aSync)

		type = _L("synchronous");

	if (gVerbose)

		test.Printf(_L("Mount filesystem %c: %-8S as %S\n"), (TUint)c, &gFsName, &type);

#ifdef __CONCURRENT_FILE_ACCESS__

	r=TheFs.MountFileSystem(gFsName, aDrive, aSync);

#else

	r=TheFs.MountFileSystem(gFsName, aDrive);

#endif

	test(r==KErrNone);

	}

enum TOper

	{

	ERead,

	EWrite

	};

// ---------------------------------------------------------------------------

class RFileOps

/// Do operations on a file.

	{

public:

	RFileOps();

	enum TOper

	{

	ERead,

	EWrite

	};

	TInt Init(TChar dr, TInt aBufSize);

	void DeInit();

	void CalculateFreeSpace();

	TInt Open(TOper aOper);

	TInt Close();

	TInt Delete();

	TInt Reset();

	TInt Erase();

	TInt Write();

	TInt Read();

	TInt End();

	TInt CreateReadFile();

public:

	TFileName      iNameRead;

	TFileName      iNameWrite;

	RFile          iF;

	HBufC8* iBuffer[KMaxLag];

	TPtr8* iBufPtr[KMaxLag];

	TRequestStatus iStatus[KMaxLag];

	TInt iPtr;

	TInt iNum;

	TInt iOps;

	TInt iMax;

	TBool iOpen;

	TInt iBufSize;

	TChar iDrvCh;

	TInt64 iFree;

	TInt iFileSize;

	// counters

	TInt iFileWraps;

	TInt iFileSyncAccesses;

	TInt iFileAsyncAccesses;

	};

RFileOps::RFileOps() : iPtr(0), iNum(0), iOps(0), iMax(0), iOpen(EFalse)

	{

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

		{

		iStatus[i] = KErrNone;

		iBuffer[i] = NULL;

		iBufPtr[i] = NULL;

		}

	}

TInt RFileOps::Init(TChar aDrvCh, TInt aBufSize)

	{

	TInt r = KErrNone;

	test(!iOpen);

	iDrvCh = aDrvCh;

	iBufSize = aBufSize;

	iNameWrite.Format(_L("%c:\\TESTWT"), (TUint)aDrvCh);

	iNameRead.Format(_L("%c:\\TESTRD"), (TUint)aDrvCh);

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

		{

		iStatus[i] = KErrNone;

		iBuffer[i] = HBufC8::NewL(aBufSize);

		if (iBuffer[i] == NULL)

			return KErrNoMemory;

		iBufPtr[i] = new TPtr8(iBuffer[i]->Des());

		//TPtr8 buffer(iBuffer[i]->Des());

		//buffer.Fill(TChar('_'), aBufSize);

		iBufPtr[i]->Fill(TChar('_'), aBufSize);

		}

	return r;

	}

void RFileOps::DeInit()

	{

	test(!iOpen);

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

		{

		delete iBuffer[i];

		iBuffer[i] = NULL;

		delete iBufPtr[i];

		iBufPtr[i] = NULL;

		}

	}

void RFileOps::CalculateFreeSpace()

	{

	TVolumeInfo vol;

	TInt        drv;

	TInt r = TheFs.CharToDrive(iDrvCh, drv);

	if (r != KErrNone)

		TTest::Fail(HERE, _L("CharToDrive(%c) returned %d"), (TUint)iDrvCh, r);

	r = TheFs.Volume(vol, drv);

	if (r != KErrNone)

		TTest::Fail(HERE, _L("Volume(%c:) returned %d"), (TUint)iDrvCh, r);

	iFree = vol.iFree;

	TInt64 fileSize = iFree / 2;

	if (fileSize > KMaxFileSize)

		fileSize = KMaxFileSize;

	iFileSize = I64LOW(fileSize);

	// calculate the number of buffers to use

	// if we assume we'll be able to use half the available disk space

	TInt max = iFileSize / iBufSize;

	iMax = max;

    if (gVerbose)

		{

		test.Printf(_L("Free space on drive %c = %d KB\n"), (TUint)iDrvCh, I64LOW(iFree/1024));

		test.Printf(_L("File Size = %d KB. Using %d buffers of size %d\n"), iFileSize/1024, iMax, iBufSize);

		}

	}

TInt RFileOps::Open(TOper aOper)

/// Open the file for testing, give error if there is not enough space for it.

	{

	TInt r;

	test(!iOpen);

	// reset counters

	iFileWraps = 0;

	iFileSyncAccesses = 0;

	iFileAsyncAccesses = 0;

	TheFs.Delete(iNameWrite);

	if (aOper == ERead)

		{

		r = iF.Open(TheFs, iNameRead, EFileStreamText | EFileRead);

		if (r != KErrNone)

			return r;

		TInt sizeFile = 0;

		r = iF.Size(sizeFile);

		test(r == KErrNone);

        if (gVerbose)

			{

			test.Printf(_L("File Size = %d, %d buffers of size %d\n"), sizeFile, iMax, iBufSize);

			}

		iMax = sizeFile / iBufSize;

		}

	else

		{

		CalculateFreeSpace();

		if (iMax < KMaxLag)

			{

			test.Printf(_L("Insufficient free space on drive %c, deleting read file\n"), (TUint)iDrvCh);

			TInt maxOld = iMax;

			TheFs.Delete(iNameRead);

			CalculateFreeSpace();

			test.Printf(_L("Old available buffers = %d, new available buffers = %d\n"), maxOld, iMax);

			}

			if (iMax < KMaxLag)

				TTest::Fail(HERE, _L("Not enough space to do test, only %d KB available. Only %d buffers of %d bytes available"),

												  I64LOW(iFree/1024), iMax, iBufSize );

		r = iF.Replace(TheFs, iNameWrite, EFileStreamText | EFileWrite);

		}

	if (r == KErrNone)

		iOpen = ETrue;

	Reset();

	return r;

	}

// Close and delete the file, returning the number of operations done.

TInt RFileOps::Close()

	{

	if (!iOpen)

		return 0;

	iF.Close();

	iOpen = EFalse;

	// always delete the write file

	TheFs.Delete(iNameWrite);

	return iNum;

	}

TInt RFileOps::Delete()

	{

	TInt r = TheFs.Delete(iNameRead);

	r = TheFs.Delete(iNameWrite);

	return r;

	}

TInt RFileOps::Reset()

/// Reset all of the counts.

	{

	TInt err = KErrNone;

	iPtr = 0;

	iNum = 0;

	iOps = 0;

	return err;

	}

TInt RFileOps::CreateReadFile()

	{

	TInt r = KErrNone;

	CalculateFreeSpace();	// get iMax

	if (iOpen)

		iF.Close();

	iOpen = EFalse;

	r = iF.Open(TheFs, iNameRead, EFileStreamText | EFileRead);

	if (r == KErrNone)

		{

		if (gVerbose)

			test.Printf(_L("temp file already exists.\n"));

		iF.Close();

		return r;

		}

	r = iF.Replace(TheFs, iNameRead, EFileStreamText | EFileWrite);

	if (r != KErrNone)

		return r;

	iOpen = ETrue;

	Reset();

	test.Printf(_L("Creating temp file on drive %c of size %d..."), (TUint)iDrvCh, iFileSize);

	HBufC8* buf = HBufC8::NewL(KMaxBufferSize);

	TPtr8 bufptr(buf->Des());

	bufptr.Fill(TChar('_'), KMaxBufferSize);

	test(buf != NULL);

	for (TInt pos=0; pos<iFileSize; pos+= buf->Length())

		{

		r = iF.Write(pos, bufptr);

		if (r != KErrNone)

			test.Printf(_L("Write() returned %d\n"), r);

		test(r == KErrNone);

		}

	delete buf; buf = NULL;

	//	if (gVerbose)

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

	iF.Close();

	iOpen = EFalse;

	return r;

	}

TInt RFileOps::Write()

/// If there is a free buffer available, start a write.

	{

	if (!iOpen)

		return 0;

	while (iNum < iOps && iStatus[iNum%KMaxLag] != KRequestPending)

		{

		TInt status = iStatus[iNum%KMaxLag].Int();

		test (status == KErrNone);

		iNum++;

		}

	if (iOps < KMaxLag || iStatus[iPtr] != KRequestPending)

		{

		TInt pos = iOps%iMax * iBufSize;

		iF.Write(pos, *iBufPtr[iPtr], iStatus[iPtr]);

		TInt status = iStatus[iPtr].Int();

        if (gVerbose)

			{

			test.Printf(_L("Writing buf #%d to drive %c at pos %d, status = %d\n"), 

				iPtr, (TUint)iDrvCh, pos, status);

			}

		test (status == KErrNone || status == KRequestPending);

		iOps++;

		iPtr++;

		iPtr %= KMaxLag;

		return 1;

		}

	return 0;

	}

TInt RFileOps::Read()

/// If there is a free buffer available, start a read.

	{

	if (!iOpen)

		return 0;

	while (iNum < iOps && iStatus[iNum%KMaxLag] != KRequestPending)

		{

		TInt status = iStatus[iNum%KMaxLag].Int();

		if (status != KErrNone)

			test.Printf(_L("drive %c, iNum = %d, iOps=%d, Status = %d\n"), (TUint)iDrvCh, iNum, iOps, status);

		test (status == KErrNone);

		iNum++;

		}

	if (iOps < KMaxLag || iStatus[iPtr] != KRequestPending)

		{

		TInt pos = iOps%iMax * iBufSize;

		iBufPtr[iPtr]->SetLength(0);

		iF.Read(pos, *iBufPtr[iPtr], iStatus[iPtr]);

		TInt len = iBufPtr[iPtr]->Length();

		TInt status = iStatus[iPtr].Int();

		TInt err = KErrNone;

		if (status == KErrNone)

			{

			iFileSyncAccesses++;

			if (len < iBufPtr[iPtr]->MaxLength())

				err = KErrUnderflow;

			}

		else if (status == KRequestPending)

			{

			iFileAsyncAccesses++;

			}

		else

			{

			err = status;

			}

		if (gVerbose || err != KErrNone)

			{

			test.Printf(_L("Reading buf #%d, drive %c, pos %d, status %d, len %d, iNum %d, iOps %d, iMax %d\n"), 

				iPtr, (TUint)iDrvCh, pos, status, len, iNum, iOps, iMax);

			}

		test (err == KErrNone);

		iOps++;

		iPtr++;

		iPtr %= KMaxLag;

		// have we wrapped to postion zero ?

		if (iOps % iMax == 0)

			iFileWraps++;

		return 1;

		}

	return 0;

	}

TInt RFileOps::End()

/// Wait until all outstanding operations have ended, then return the number.

	{

	if (!iOpen)

		return 0;

	if (gVerbose)

		test.Printf(_L("Waiting for reads/writes to %c to complete, iNum=%d, iOps=%d...\n"), (TUint)iDrvCh, iNum, iOps);

	while (iNum < iOps)

		{

		if (iStatus[iNum%KMaxLag] == KRequestPending)

			{

			User::WaitForRequest(iStatus[iNum%KMaxLag]);

			}

		else

			{

			TInt status = iStatus[iNum%KMaxLag].Int();

			if (gVerbose || (status != KErrNone && status != KRequestPending))

				test.Printf(_L("Buf#%d: Status = %d\n"), iNum, status);

			test (status == KErrNone || status == KRequestPending);

			iNum++;

			}

		}

	return iNum;

	}

LOCAL_C TInt testAsyncAccess(

	TInt aDrive1,

	TInt aDrive2, 

	TInt aBufSize1, 

	TInt aBufSize2, 

	TBool aSync1, 

	TBool aSync2,

	TInt& aThroughput1,

	TInt& aThroughput2)

//

// Test one drive against the other.

//

    {

	TInt r;

	RFileOps f1;

	RFileOps f2;

	TChar dc1;

	TChar dc2;

	TInt   op1 = 0;

	TInt   op2 = 0;

	RTimer timer;

	TRequestStatus tstat;

	TTime startTime;

	TTime endTime;

	TTimeIntervalMicroSeconds timeTaken(0);

	TInt64 dtime;

	aThroughput1 = aThroughput2 = 0;

	if (aBufSize1 == 0 && aBufSize2 == 0)

		return KErrNone;

	timer.CreateLocal();

	r = TheFs.DriveToChar(aDrive1, dc1);

	test(r == KErrNone);

	r = TheFs.DriveToChar(aDrive2, dc2);

	test(r == KErrNone);

	// allocate buffers

	r = f1.Init(dc1, aBufSize1);

		test(r == KErrNone);

	r = f2.Init(dc2, aBufSize2);

	test(r == KErrNone);

	_LIT(KSync, " sync");

	_LIT(KAsync, "async");

	if (gVerbose)

		test.Printf(_L("%c: (%S) %d, %c: (%S) %d\n"), 

			(TUint)dc1, 

			aSync1?&KSync:&KAsync,

			aBufSize1, 

			(TUint)dc2, 

			aSync2?&KSync:&KAsync,

			aBufSize2);

	RemountFileSystem(aDrive1, aSync1);

	RemountFileSystem(aDrive2, aSync2);

	if (gReadTests)

		{

		//********************************************************************

		// read test

		//********************************************************************

		if (aBufSize1 > 0)

			{

			r = f1.CreateReadFile();

			test(r == KErrNone);

			}

		if (aBufSize2 > 0)

			{

			r = f2.CreateReadFile();

			test(r == KErrNone);

			}

		if (aBufSize1 > 0)

			r = f1.Open(RFileOps::ERead);

		test(r == KErrNone);

		if (aBufSize2 > 0)

			r = f2.Open(RFileOps::ERead);

		test(r == KErrNone);

		timer.After(tstat, KTimeBM * KSecond);

		startTime.HomeTime();

		while (tstat == KRequestPending)

			{

			TInt num = 0;

			if (aBufSize1 > 0)

				num = f1.Read();

			if (aBufSize2 > 0)

				num += f2.Read();

			if (num == 0)

				User::WaitForAnyRequest();

			}

		timer.Cancel();	

		if (aBufSize1 > 0)

			op1 = f1.End();

		if (aBufSize2 > 0)

			op2 = f2.End();

		endTime.HomeTime();

		timeTaken=endTime.MicroSecondsFrom(startTime);

		//********************************************************************

		// Read test end

		//********************************************************************

		}	// if (gReadTests)

	if (gWriteTests)

		{

		//********************************************************************

		// write test

		//********************************************************************

		if (aBufSize1 > 0)

			{

			r = f1.Open(RFileOps::EWrite);

			test(r == KErrNone);

			}

		if (aBufSize2 > 0)

			{

			r = f2.Open(RFileOps::EWrite);

			test(r == KErrNone);

			}

		timer.After(tstat, KTimeBM * KSecond);

		startTime.HomeTime();

		while (tstat == KRequestPending)

			{

			TInt num = 0;

			if (aBufSize1 > 0)

				num = f1.Write();

			if (aBufSize2 > 0)

				num += f2.Write();

			if (num == 0)

				User::WaitForAnyRequest();

			}

		timer.Cancel();

		if (aBufSize1 > 0)

			op1 = f1.End();

		if (aBufSize2 > 0)

			op2 = f2.End();

		endTime.HomeTime();

		timeTaken=endTime.MicroSecondsFrom(startTime);

		//********************************************************************

		// Write test end

		//********************************************************************

		}	// if gWriteTests

	dtime = timeTaken.Int64();

	aThroughput1 = GetSpeed(op1, aBufSize1, dtime);

	aThroughput2 = GetSpeed(op2, aBufSize2, dtime);

	test.Printf(_L("%c:,%c:,%10d,%10d,%10d,%10d\n"), 

		(TUint)dc1, (TUint)dc2, 

		aBufSize1,aBufSize2,

		aThroughput1,

		aThroughput2

		);

	if (gVerbose)

		{

		test.Printf(_L("%c: %d async reads, %d sync reads, wraps = %d\n"), 

			(TUint)dc1, f1.iFileAsyncAccesses, f1.iFileSyncAccesses, f1.iFileWraps);

		test.Printf(_L("%c: %d async reads, %d sync reads, wraps = %d\n"), 

			(TUint)dc2, f2.iFileAsyncAccesses, f2.iFileSyncAccesses, f2.iFileWraps);

		}

	f1.Close();

	f2.Close();

	timer.Close();

	f1.DeInit();

	f2.DeInit();

	return KErrNone;

    }

LOCAL_C TInt parseCmd(TChar& aDrvCh1, TChar& aDrvCh2)

/// Get parameters from the comand line; if there aren't enough then

/// prompt the user for them and return KErrAbort if ^C is pressed.

	{

	while (aDrvCh1 < 'A' || aDrvCh1 > 'Z')

		{

		test.Printf(_L("Enter drive letter: "));

		while (aDrvCh1 < 'A' || aDrvCh1 > 'Z')

			{

			if (aDrvCh1 == 0x03)

				return KErrAbort;

			aDrvCh1 = User::UpperCase(test.Getch());

			}

		if (!DriveIsOK(aDrvCh1))

			{

			test.Printf(_L("%c: is not a valid drive\n"), (TUint)aDrvCh1);

			aDrvCh1 = 0;

			}

		else

			{

			TInt drv;

			TheFs.CharToDrive(aDrvCh1, drv);

			TheFs.FileSystemName(gFsName1, drv);

			test.Printf(_L("%c: (%S)\n"), (TUint)aDrvCh1, &gFsName1);

			}

		}

	while (aDrvCh2 < 'A' || aDrvCh2 > 'Z')

		{

		test.Printf(_L("Enter drive letter: "));

		while (aDrvCh2 < 'A' || aDrvCh2 > 'Z')

			{

			if (aDrvCh2 == 0x03)

				return KErrAbort;

			aDrvCh2 = User::UpperCase(test.Getch());

			}

		if (!DriveIsOK(aDrvCh2))

			{

			test.Printf(_L("%c: is not a valid drive\n"), (TUint)aDrvCh2);

			aDrvCh2 = 0;

			}

		else

			{

			TInt drv;

			TheFs.CharToDrive(aDrvCh2, drv);

			TheFs.FileSystemName(gFsName2, drv);

			test.Printf(_L("%c: (%S)\n"), (TUint)aDrvCh2, &gFsName2);

			}

		}

	return KErrNone;

	}

typedef TInt RESULTS[KMaxIter][KMaxIter]; 

LOCAL_C void PrintResults(RESULTS& aResults, TChar aDrvCh, TChar aDrvCh2)

	{

	TInt bufSize2;

	TInt drive1Index, drive2Index;

	test.Printf(_L("*** Throughput for drive %c ***\n"), (TUint)aDrvCh);

	test.Printf(_L("         BufferSize (%C:)....\n"), (TUint)aDrvCh2);

	gResults.Zero();

	for (bufSize2 = drive2Index = 0; bufSize2 <= KMaxBufferSize; bufSize2 = bufSize2 << 1, drive2Index++)

		{

		gResults.AppendFormat(_L("%10d,"), bufSize2);

		if (bufSize2 == 0)

			bufSize2 = KMinBufferSize >> 1;

		}

	test.Printf(_L("%S\n"), &gResults);

	for (drive1Index = 0; drive1Index < KMaxIter; drive1Index++)

		{

		gResults.Zero();

		for (drive2Index = 0; drive2Index < KMaxIter; drive2Index++)

			{

			gResults.AppendFormat(_L("%10d,"), aResults[drive1Index][drive2Index]);

			}

		test.Printf(_L("%S\n"), &gResults);

		}

	}

//

// Do all tests

//

GLDEF_C void CallTestsL()

	{

	TInt r = TTest::Init();

	test(r == KErrNone);

	TChar drvch1 = 0;

	TChar drvch2 = 0;

	TInt  drive1;

	TInt  drive2;

	const TInt KMaxArgs = 5;

	TPtrC argv[KMaxArgs];

	TInt  argc = TTest::ParseCommandArguments(argv, KMaxArgs);

	if (argc > 1)

		drvch1 = User::UpperCase(argv[1][0]);

	if (argc > 2)

		drvch2 = User::UpperCase(argv[2][0]);

	TBool testFs = EFalse;

	for (TInt n=3; n<argc; n++)

		{

		if (argc > 3)

			{

			if (argv[n].Compare(_L("verbose")) == 0)

				gVerbose = ETrue;

			if (argv[n].Compare(_L("read")) == 0)

				gReadTests = ETrue;

			if (argv[n].Compare(_L("write")) == 0)

				gWriteTests = ETrue;

			if (argv[n].Compare(_L("async")) == 0)

				gAsyncTests = ETrue;

			if (argv[n].Compare(_L("sync")) == 0)

				gSyncTests = ETrue;

			if (argv[n].Compare(_L("testfs")) == 0)

				testFs = ETrue;

			}

		}

	if ((!gReadTests && !gWriteTests) ||

		(!gAsyncTests && !gSyncTests))

		{

	    test.Printf(_L("T_CFSPERFORM - tests read/write throughput on two drives simultaneously\n"));

	    test.Printf(_L("Syntax : t_cfsperform <Drive1> <Drive2> [verbose] [testfs] read|write sync|async\n"));

	    test.Printf(_L("Where  : async = concurrent access, sync = non-concurrent access\n"));

	    test.Printf(_L("E.g.   : t_cfsperform c d read async\n"));

	    test.Printf(_L("Press any key"));

		test.Getch();	

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

		return;

		}

	r = parseCmd(drvch1, drvch2);

	if (r != KErrNone)

		{

		User::Panic(_L("USER ABORT"), 0);

		}

	r = TheFs.CharToDrive(drvch1, drive1);

	test(r == KErrNone);

	r = TheFs.CharToDrive(drvch2, drive2);

	test(r == KErrNone);

	r = TheFs.FileSystemName(gFsName1, drive1);

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

	r = TheFs.FileSystemName(gFsName2, drive2);

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

	if (testFs)

		{

		MountTestFileSystem(drive1);

		MountTestFileSystem(drive2);

		}

	TInt bufSize1;

	TInt bufSize2;

	// delete temp files before starting

	RFileOps f;

	f.Init(drvch1, 256);

	f.Delete();

	f.DeInit();

	f.Init(drvch2, 256);

	f.Delete();

	f.DeInit();