// 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 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_fcachebm.cpp
// 
//

#include <f32file.h>
#include <e32test.h>
#include <e32math.h>
#include "t_select.h"
#include "t_benchmain.h"

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      PBASE-T_RCACHE-0192
//! @SYMTestType        CIT
//! @SYMPREQ            PREQ914
//! @SYMTestCaseDesc    This test case is testing performance of the File Server Cache.  
//! @SYMTestActions     0   setup the environment to execute the tests
//!						1	small random reads/writes
//!						2	large sequential reads/writes
//!						3 	streaming test (100, 200 and 500 kbps)
//! @SYMTestExpectedResults Finishes if the system behaves as expected, panics otherwise
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------


GLDEF_D RTest test(_L("File Cache BM"));

LOCAL_D RSemaphore client;
LOCAL_D const TInt KHeapSize = 0x4000;
LOCAL_D const TInt KTobps = 1000;
LOCAL_D const TInt KByte = 8;
LOCAL_D const TInt KOneSec = 1000000; // One second in microseconds

// Tests setup
LOCAL_D const TInt KSmallRow = 11;
LOCAL_D const TInt KSmallCol = 7;
LOCAL_D const TInt KSmallThreshold = 64;
LOCAL_D const TInt KSeveralTimes = 10;

LOCAL_D const TInt KLargeRow = 19;
LOCAL_D const TInt KLargeCol = 3;

LOCAL_D TInt gCurrentSpeed = 0; 
LOCAL_D TInt gCurrentBS = 0;


LOCAL_D TBuf8<4096> buf;
LOCAL_D TDriveList gDriveList;

// Concurrent thread
RThread gSpeedy;
RThread gSpeedyII;

TBuf16<25> gBaseFile;
TBuf16<25> gFileA;
TBuf16<25> gFileB;
TBuf16<25> gStreamFile;
TInt64 gMediaSize;

HBufC8* gBuf = NULL;
TPtr8 gBufReadPtr(NULL, 0);	
HBufC8* gBufSec = NULL;
TPtr8 gBufWritePtr(NULL, 0);	


HBufC8* gBufB = NULL;
TPtr8 gBufReadBPtr(NULL, 0);	
TBool gWriting = EFalse;

LOCAL_D TInt ThreadCount=0;

enum TTestState 
	{
	ENoThreads,			// No threads 
	ETwoThreadsDif,		// Accessing to different files 
	ETwoThreadsDifDif, 	// Accessing to different files, different blocksizes
	ETwoThreadsSame		// Accessing the same file
	};


/** 2 ^ b

	@param b Power 
*/
LOCAL_C TInt Pow(TInt b)
{
	return 1 << b;
}

/** Pseudo-random number generator, random enough for the purpose

	@param aMax Upper limit of the number. The interval of generated numbers is [0,aMax)
*/
LOCAL_C TInt Rand(TInt aMax) 
{
	return (Math::Random() % aMax);
}


/** Fills a buffer with character aC, aC+1, aC+2, ..., aC+32, aC, etc 

	@param aBuffer 	Buffer to fill out
	@param aLength 	Length to be filled with characters
	@param aC 		Base character to fill the buffer
*/
LOCAL_C void FillBuffer(TDes8& aBuffer, TInt aLength, TChar aC)
	{
	test (aBuffer.MaxLength() >= aLength);
	
	for(TInt i = 0; i < aLength; i++)
		{
		aBuffer.Append((i%32)+aC);
		}
	}
	
/** Send content through the RDebug for trgtest 
	not to hung, when the test is not writing

*/
LOCAL_C TInt noise(TAny* )
{
	FOREVER
	{	
		User::After(2147483647); // max value, 35 minutes, 47 seconds
		if(!gWriting)
			RDebug::Print(_L("."));
	}
}

/**  Delete content of directory

	@param aDir Directory to be emptied
*/
LOCAL_C TInt DeleteAll(TDes16& aDir) 
	{
		TBuf16<100> dir;
		CFileMan* fMan = CFileMan::NewL(TheFs);
		TInt r = 0;
		
		dir = aDir;
		dir.Append(_L("F*.*"));
		r = fMan->Delete(dir);	

		delete fMan;
		return r;
	}


/**   Creates a file of aSize KBytes

	@param aFile File name 
	@param aSize Size of the file to be created
*/
LOCAL_C void CreateFile(TDes16& aFile, TInt aSize)
{
	TInt r = 0;
	RFile file;
	
	
	r = file.Replace(TheFs, aFile, EFileShareAny|EFileWrite);
	FailIfError(r);

	TInt j = 0;
	while(j <= aSize)
		{
			r = file.Write(gBufWritePtr, KOneK);
			FailIfError(r);
			j += KOneK;
		}					
	file.Close();
}

/**   Kills the concurrent session

*/
LOCAL_C void DoTestKill()
{
	TInt r = 0;
	
	gSpeedy.Kill(KErrNone);
	FailIfError(r);
	gSpeedy.Close();	
	
	gSpeedyII.Kill(KErrNone);
	FailIfError(r);
	gSpeedyII.Close();	
}

/** Read aSize KBs from aFile file in blocks of aBlockSize bytes

	@param aFile 		Name of the file
	@param aPos			Position from where the read starts within the file
	@param aBlockSize 	Block size for the I/O operation
	@param aSize 		
*/
LOCAL_C TInt ReadFromFile(TDes16& aFile, TInt aPos, TInt aBlockSize, TInt aSize) 
{
	TInt r = 0;
	TTime startTime;
	TTime endTime;
	RFile file;
	TInt j = 0;
	TInt size = aSize * KOneK;
	TTimeIntervalMicroSeconds timeTaken(0);

	r = file.Open(TheFs,aFile,EFileShareAny|EFileRead);
	FailIfError(r);
	
	startTime.HomeTime();	
	r = file.Seek(ESeekStart, aPos);
	FailIfError(r);	
	
	while(j <= size)
		{
			r = file.Read(gBufReadPtr, aBlockSize);
			FailIfError(r);
			j += aBlockSize;
		}					
	endTime.HomeTime();
	
	file.Close();
	timeTaken = endTime.MicroSecondsFrom(startTime);
	
	return I64LOW(timeTaken.Int64() / gTimeUnit);
}

/** Read aSize KBs from aFile file in blocks of aBlockSize bytes several times

	@param aFile 		Name of the file
	@param ayMax 		Maximum for the position
	@param aBlockSize 	Block size for the I/O operation
	@param aSize 		Size of the file in KB
*/
LOCAL_C TInt ReadFromFileSeveralTimes(TDes16& aFile, TInt ayMax, TInt aBlockSize, TInt aSize) 
{
	TInt r = 0;
	TTime startTime;
	TTime endTime;
	RFile file;
	TInt j = 0, i, pos;
	TInt size = aSize * KOneK;
	TTimeIntervalMicroSeconds timeTaken(0);
	TInt64 time = 0;
	

	r = file.Open(TheFs, aFile, EFileShareAny|EFileRead);
	FailIfError(r);
	
	i = 0;
	while( i < KSeveralTimes ) 
		{
		pos = Rand(Pow(ayMax - 1));
		startTime.HomeTime();	
		r = file.Seek(ESeekStart, pos); 
		FailIfError(r);	
		
		j = 0;
		while(j <= size)
			{
				r = file.Read(gBufReadPtr, aBlockSize);
				FailIfError(r);
				j += aBlockSize;
			}					
		endTime.HomeTime();

		timeTaken = endTime.MicroSecondsFrom(startTime);
		time += I64LOW(timeTaken.Int64());
		i++;
		}
	
	file.Close();
	
	return I64LOW((time / gTimeUnit) / KSeveralTimes); // Overflow not expected here, since the number is not big enough
}


/** Write aSize KBs to  aFile file in blocks of aBlockSize bytes

	@param aFile 		Name of the file
	@param aPos			Position from where the read starts within the file
	@param aBlockSize 	Block size for the I/O operation
	@param aSize 		Size of the file in KB
*/
LOCAL_C TInt WriteToFile(TDes16& aFile, TInt aPos, TInt aBlockSize, TInt aSize) 
{
	TInt r = 0;
	TTime startTime;
	TTime endTime;
	RFile file;
	TInt j = 0;
	TInt size = aSize * KOneK;
	TTimeIntervalMicroSeconds timeTaken(0);
	
	r = file.Open(TheFs, aFile, EFileShareAny|EFileWrite);
	FailIfError(r);
	
	startTime.HomeTime();	
	r = file.Seek(ESeekStart, aPos);
	FailIfError(r);	
	while(j <= size)
		{
			r = file.Write(gBufWritePtr, aBlockSize);
			FailIfError(r);
			j += aBlockSize;
		}					
	endTime.HomeTime();
	
	file.Close();
	timeTaken = endTime.MicroSecondsFrom(startTime);
	
	return I64LOW(timeTaken.Int64() / gTimeUnit);
}

/** Write aSize KBs to  aFile file in blocks of aBlockSize bytes several times

	@param aFile 		Name of the file
	@param ayMax 		Maximum for the position
	@param aBlockSize 	Block size for the I/O operation
	@param aSize 		Size of the file in KB
*/
LOCAL_C TInt WriteToFileSeveralTimes(TDes16& aFile, TInt ayMax, TInt aBlockSize, TInt aSize) 
{
	TInt r = 0;
	TTime startTime;
	TTime endTime;
	RFile file;
	TInt i, j = 0, pos;
	TInt size = aSize * KOneK;
	TTimeIntervalMicroSeconds timeTaken(0);
	TInt64 time = 0;
	
	r = file.Open(TheFs, aFile, EFileShareAny|EFileWrite);
	FailIfError(r);
	
	i = 0;
	while( i < KSeveralTimes ) 
		{
		pos = Rand(Pow(ayMax - 1));
		startTime.HomeTime();	
		r = file.Seek(ESeekStart, pos);
		FailIfError(r);	
		
		j = 0;
		while(j <= size)
			{
				r = file.Write(gBufWritePtr, aBlockSize);
				FailIfError(r);
				j += aBlockSize;
			}					
		endTime.HomeTime();
	
		timeTaken = endTime.MicroSecondsFrom(startTime);
		time += I64LOW(timeTaken.Int64());
		i++;
		}
		
	file.Close();

	return I64LOW((time / gTimeUnit) / KSeveralTimes); // Overflow not expected here, since the number is not big enough
}

/** Read small blocks in the gBaseFile

*/
LOCAL_C TInt ReadSmallBase(TAny* )
{
	RTest test(_L("test 2"));
	RFs fs;
	RFile file;
	TBuf8<1024> dummy(1024);
	TInt blockSize = 0;
	TInt randPos = 0;
	TInt i = 0;

	TInt r = fs.Connect();
	
	fs.SetSessionPath(gSessionPath);
	r = file.Open(fs, gBaseFile, EFileShareAny|EFileRead);
	client.Signal();
	
	FailIfError(r);
		
	FOREVER
	{	
			randPos = Rand(64) * KOneK ; 
			r = file.Seek(ESeekStart, randPos);
			FailIfError(r);
			blockSize = i;
			
			r = file.Read(dummy, blockSize); // Sync operation
			if(i >= 1023) i = 0;
			else i++;
	}
}
	
/** Read small blocks in gFileA

*/
LOCAL_C TInt ReadSmallA(TAny* )
{
	RTest test(_L("test 2"));
	RFs fs;
	RFile file;
	TInt blockSize = 0;
	TInt randPos = 0;
	TBuf8<1024> dummy(1024);
	TInt i = 0;

	TInt r = fs.Connect();
	
	fs.SetSessionPath(gSessionPath);

	r = file.Open(fs,gFileA,EFileShareAny|EFileRead);
	
	client.Signal();
	FailIfError(r);
	
	FOREVER
	{	
			randPos = Rand(64) * KOneK ; 
			r = file.Seek(ESeekStart, randPos);
			FailIfError(r);
			
			blockSize = i;
			
			r = file.Read(dummy, blockSize); // Sync operation
			FailIfError(r);
			if(i >= 1023) i = 0;
			else i++;
	}
}
	
/** Read small blocks in gFileB

*/
LOCAL_C TInt ReadSmallB(TAny* )
	{
	RTest test(_L("test 2"));
	RFs fs;
	RFile file;
	TBuf8<1024> dummy(1024);
	TInt blockSize = 0;
	TInt randPos = 0;
	TInt i = 0;

	TInt r = fs.Connect();
	
	fs.SetSessionPath(gSessionPath);
	r = file.Open(fs, gFileB, EFileShareAny|EFileRead);
	
	client.Signal();
	FailIfError(r);
	
	FOREVER
	{
		randPos = Rand(64) * KOneK ; 
		r = file.Seek(ESeekStart, randPos);
		FailIfError(r);
		blockSize = i;
		
		r = file.Read(dummy, blockSize); // Sync operation
		FailIfError(r);
		if(i >= 1023) i = 0;
		else i++;
	}
}


/** Read large blocks in gBaseFile

*/
LOCAL_C TInt ReadLargeBase(TAny* )
	{
	RTest test(_L("test 2"));
	RFs fs;
	RFile file;
	TInt pos = 0;
	TInt blockSize = 128 * KOneK;
	
	TInt r = fs.Connect();
	
	fs.SetSessionPath(gSessionPath);
	r = file.Open(fs,gBaseFile,EFileShareAny|EFileRead);
	
	client.Signal();
	FailIfError(r);
	
	FOREVER
	{	
			r = file.Seek(ESeekStart, pos);
			FailIfError(r);
			
			r = file.Read(gBufReadBPtr, blockSize); // Sync operation
			FailIfError(r);
	}
}

/** Read large blocks in gFileA

*/
LOCAL_C TInt ReadLargeA(TAny* )
{
	RTest test(_L("test 2"));
	RFs fs;
	RFile file;
	TInt blockSize = 128 * KOneK;
	TInt pos = 0;

	TInt r = fs.Connect();

	fs.SetSessionPath(gSessionPath);
	
	r = file.Open(fs,gFileA,EFileShareAny|EFileRead);
	
	client.Signal();
	FailIfError(r);
		
	FOREVER
	{	
		r = file.Seek(ESeekStart, pos);
		FailIfError(r);
		
		r = file.Read(gBufReadBPtr, blockSize); // Sync operation
		FailIfError(r);
	}
}
	
/** Read large blocks in gFileB

*/
LOCAL_C TInt ReadLargeB(TAny* )
{
	RTest test(_L("test 2"));
	RFs fs;
	RFile file;
	TInt blockSize = 128 * KOneK;
	TInt pos = 0;

	TInt r=fs.Connect();
	FailIfError(r);
	
	fs.SetSessionPath(gSessionPath);

	r = file.Open(fs,gFileB,EFileShareAny|EFileRead);

	client.Signal();
	FailIfError(r);
	
	FOREVER
	{
		r = file.Seek(ESeekStart, pos);
		FailIfError(r);
		
		r = file.Read(gBufReadBPtr, blockSize); // Sync operation
		FailIfError(r);
	}
}

/** Small reads from a file
 
	@param xMax 	Maximum position on the x axe
	@param yMax		Maximum position on the y axe
	@param aCase	Type of test. Possible values:
		 - ENoThreads : isolated
		 - ETwoThreadsSame : with two threads accessing same file
		 - ETwoThreadsDif : with two threads accessing dif. files 
*/
LOCAL_C void smallReads(TInt xMax, TInt yMax, TTestState aCase)
	{	
	TInt i = 0;
	TInt j = 0;
	TInt r = 0;
	TInt timeRes = 0;
	
	CreateFile(gBaseFile, Pow(yMax-1));
	
	if(aCase == ETwoThreadsSame) 
		{ // Start two different threads accessing the same file
		TBuf<20> buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadSmallBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadSmallBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();

		client.Wait();
		client.Wait();
		}
	
	if(aCase == ETwoThreadsDif)
		{ // Start two different threads accessing different files
		CreateFile(gFileA, Pow(yMax-1));
		CreateFile(gFileB, Pow(yMax-1));
		
		TBuf<20> buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadSmallA, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadSmallB, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();
				
		client.Wait();
		client.Wait();
		}
	
	while(i < xMax)
		{ // Actual accesses and timing to the main file
		j = 0;
		PrintResult(i + 1, j + 1, Pow(i));
		while(j < yMax) 
			{
			if(Pow(i) < KSmallThreshold) 
				{
				timeRes = ReadFromFile(gBaseFile, Rand(Pow(yMax - 1)), Pow(i), Pow(j));
				}
			else
				{ // Too small for only one time measure
				timeRes = ReadFromFileSeveralTimes(gBaseFile, yMax, Pow(i), Pow(j)); 			
				}
			
			gWriting = ETrue; 
			User::After(1000000);

			PrintResultTime(i + 1, j + 2, timeRes); 
			
			gWriting = EFalse;
			
			j++;
			}
		i++;
		}
		
	
	if((aCase == ETwoThreadsSame) || (aCase == ETwoThreadsDif))
		{ // Finish the threads
		DoTestKill();			
		}
	}

/** Large reads from a file
 
 	@param xMax 	Maximum position on the x axe
	@param yMax		Maximum position on the y axe
	@param aCase	Type of test. Possible values:
		 - ENoThreads : isolated
		 - ETwoThreadsSame : with two threads accessing same file
		 - ETwoThreadsDif : with two threads accessing dif. files 
		 - ETwoThreadsDifDif : with two threads accessing dif. files, different block sizes (big/small)
*/
LOCAL_C void largeReads(TInt xMax, TInt yMax, TTestState aCase)
{
	TInt i = 0;
	TInt j = 0;
	TInt r = 0;
	TInt timeRes = 0;
	
	CreateFile(gBaseFile, 10 * KOneK * KOneK); // 10 Mb 
	
	if(aCase == ETwoThreadsSame) 
	{ // Start two different threads accessing the same file

		TRAPD(res, gBufB = HBufC8::NewL(256 * KOneK));
		test(res == KErrNone && gBufB != NULL);
		gBufReadBPtr.Set(gBufSec->Des());

		TBuf<20> buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadLargeBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadLargeBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();

		client.Wait();
		client.Wait();
	}
	
	if(aCase == ETwoThreadsDif)
	{ // Start two different threads accessing different files
	
		CreateFile(gFileA, KOneK * KOneK);
		CreateFile(gFileB, KOneK * KOneK);
		
		TRAPD(res, gBufB = HBufC8::NewL(256 * KOneK));
		test(res == KErrNone && gBufB != NULL);
		gBufReadBPtr.Set(gBufSec->Des());
		
		TBuf<20> buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadLargeA, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadLargeB, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();
				
		client.Wait();
		client.Wait();
	}
	
	if(aCase == ETwoThreadsDifDif)
	{ // Start two different threads accessing different files
	
		CreateFile(gFileA, KOneK * KOneK);
		CreateFile(gFileB, KOneK * KOneK);
		
		TRAPD(res,gBufB = HBufC8::NewL(256 * KOneK));
		test(res == KErrNone && gBufB != NULL);
		gBufReadBPtr.Set(gBufSec->Des());
		
		TBuf<20> buf=_L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadLargeA, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadSmallB, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();
				
		client.Wait();
		client.Wait();
	}

	i = 11;
	while(i < xMax )
	{ // Actual accesses and timing to the main file
		j = 0;
		PrintResult(i - 10, j + 1, Pow(i));
		while(j < yMax) 
		{
			TInt size=0;
			if(j == 0) 	size = 100 ; // 100 Kb
			if(j == 1) 	size = KOneK ; // 1 Mb
			if(j == 2) 	size = 10 * KOneK ; // 10 Mb
			
			timeRes = ReadFromFile(gBaseFile, 0, Pow(i), size); 

			gWriting = ETrue; 
			User::After(1000000);

			PrintResultTime(i - 10, j + 2, timeRes); 
				
			gWriting = EFalse;

			j++;
		}
		i++;
	}
	
	if((aCase == ETwoThreadsSame) || (aCase == ETwoThreadsDif) || (aCase == ETwoThreadsDifDif))
	{ // Finish the threads
		DoTestKill();			
		delete gBufB;
	}
	
}

/** Large writes to a file
 
	@param xMax 	Maximum position on the x axe
	@param yMax		Maximum position on the y axe
	@param aCase	Type of test. Possible values:
		 - ENoThreads : isolated
		 - ETwoThreadsSame : with two threads accessing same file
		 - ETwoThreadsDif : with two threads accessing dif. files 
*/
LOCAL_C void largeWrites(TInt xMax, TInt yMax, TTestState aCase)
{
	TInt i = 0;
	TInt j = 0;
	TInt r = 0;
	TInt timeRes = 0;
		
	CreateFile(gBaseFile, 10 * KOneK * KOneK); // 10 Mb 
	
	if(aCase == ETwoThreadsSame) 
	{ // Start two different threads accessing the same file

		TRAPD(res, gBufB = HBufC8::NewL(256 * KOneK));
		test(res == KErrNone && gBufB != NULL);
		gBufReadBPtr.Set(gBufSec->Des());

		TBuf<20> buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadLargeBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadLargeBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();

		client.Wait();
		client.Wait();
	}
	
	if(aCase == ETwoThreadsDif)
	{ // Start two different threads accessing different files
	
		CreateFile(gFileA, KOneK * KOneK);
		CreateFile(gFileB, KOneK * KOneK);
		
		TRAPD(res, gBufB = HBufC8::NewL(256 * KOneK));
		test(res == KErrNone && gBufB != NULL);
		gBufReadBPtr.Set(gBufSec->Des());
		
		TBuf<20> buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadLargeA, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadLargeB, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();
				
		client.Wait();
		client.Wait();
	}
	
	i = 11;
	while(i < xMax )
	{ // Actual accesses and timing to the main file
		j = 0;
		PrintResult(i - 10 , j + 1, Pow(i));
		while(j < yMax) 
		{
			TInt size=0;
			if(j == 0) 	size = 100 ; // 100 Kb
			if(j == 1) 	size = KOneK ; // 1 Mb
			if(j == 2) 	size = 10 * KOneK ; // 10 Mb
			timeRes = WriteToFile(gBaseFile, 0, Pow(i), size); 
			
			gWriting = ETrue; 
			User::After(1000000);

			PrintResultTime(i - 10, j + 2, timeRes); 
			
			gWriting = EFalse;			
			j++;
		}
		i++;
	}
	
	if((aCase == ETwoThreadsSame) || (aCase == ETwoThreadsDif) || (aCase == ETwoThreadsDifDif))
	{ // Finish the threads
		DoTestKill();			
		delete gBufB;
	}
	
}

/** Small writes to a file
 
	@param xMax 	Maximum position on the x axe
	@param yMax		Maximum position on the y axe
	@param aCase	Type of test. Possible values:
		 - ENoThreads : isolated
		 - ETwoThreadsSame : with two threads accessing same file
		 - ETwoThreadsDif : with two threads accessing dif. files 
*/
LOCAL_C void smallWrites(TInt xMax, TInt yMax, TTestState aCase)
{
	TInt i = 0;
	TInt j = 0;
	TInt r = 0;
	TInt timeRes = 0;
	
	CreateFile(gBaseFile, Pow(yMax-1));
	
	if(aCase == ETwoThreadsSame) 
	{ // Start two different threads accessing the same file
		TBuf<20> buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadSmallBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadSmallBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();

		client.Wait();
		client.Wait();
	}
	
	if(aCase == ETwoThreadsDif)
	{ // Start two different threads accessing different files
		CreateFile(gFileA, Pow(yMax-1));
		CreateFile(gFileB, Pow(yMax-1));
		
		TBuf<20> buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		r = gSpeedy.Create(buf, ReadSmallA, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		buf = _L("Speedy");
		buf.AppendNum(ThreadCount++);
		
		r = gSpeedyII.Create(buf, ReadSmallB, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
		FailIfError(r);
		
		gSpeedy.Resume();
		gSpeedyII.Resume();
				
		client.Wait();
		client.Wait();
	}
	
	while(i < xMax)
	{
		j = 0;
		PrintResult(i + 1, j + 1, Pow(i));
		while(j < yMax) 
		{
			if(Pow(i) < KSmallThreshold) 
				{
				timeRes = WriteToFile(gBaseFile, Rand(Pow(yMax-1)), Pow(i), Pow(j)); 
				}
			else
				{
				timeRes = WriteToFileSeveralTimes(gBaseFile, yMax, Pow(i), Pow(j)); 
				}
							
			gWriting = ETrue; 
			User::After(1000000);

			PrintResultTime(i + 1, j + 2, timeRes); 
			
			gWriting = EFalse;
				
			j++;
		}
		i++;
	}
	
	if((aCase == ETwoThreadsSame) || (aCase == ETwoThreadsDif))
	{ // Finish the threads
		DoTestKill();
	}
	
}

/** This test benchmarks small random r/w (e.g. database access)

	@param aSelector Selection array for manual tests
*/
LOCAL_C TInt TestSmall(TAny* aSelector)
{
	
	Validate(aSelector);
	
	// Each test case of the suite has an identifyer for parsing purposes of the results
	gTestHarness = 7;	
	gTestCase = 1;
	gTimeUnit = 1;
	
	PrintHeaders(4, _L("t_fcachebm. Small Random r/w"));
	
	// Small reads
	test.Printf(_L("#~TS_Title_%d,%d: Small reads, no threads \n"), gTestHarness, gTestCase);

	smallReads(KSmallRow, KSmallCol, ENoThreads); 

	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Small reads, threads accessing same file \n"), 
														gTestHarness, gTestCase);
	
	smallReads(KSmallRow, KSmallCol, ETwoThreadsSame); 
	
	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Small reads, threads accessing dif files \n"),
															 gTestHarness, gTestCase);
	
	smallReads(KSmallRow, KSmallCol, ETwoThreadsDif); 
	
	gTestCase++;
	DeleteAll(gSessionPath);
	
	// Small writes test case 
	
	test.Printf(_L("#~TS_Title_%d,%d: Test small writes\n"), gTestHarness, gTestCase);

	smallWrites(KSmallRow, KSmallCol, ENoThreads); 

	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Small writes, threads accessing same file \n"), 
															gTestHarness, gTestCase);
	smallWrites(KSmallRow, KSmallCol, ETwoThreadsSame); 

	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Small writes, threads accessing dif files \n"),
															 gTestHarness, gTestCase);
	smallWrites(KSmallRow, KSmallCol, ETwoThreadsDif); 

	gTestCase++;
	DeleteAll(gSessionPath);
	test.Printf(_L("#~TestEnd_%d\n"), gTestHarness);
	
	return(KErrNone);
}

/** This test benchmarks large sequential r/w (e.g. MM)

	@param aSelector Selection array for manual tests
*/
LOCAL_C TInt TestLarge(TAny* aSelector)
{
	
	Validate(aSelector);

	// Each test case of the suite has an identifyer for parsing purposes of the results
	gTestHarness = 8;	
	gTestCase = 1;
	gTimeUnit = 1000;
	
	PrintHeaders(3, _L("t_fcachebm. Large sequential r/w"));
	
	// Large reads
	test.Printf(_L("#~TS_Title_%d,%d: Large sequential reads\n"), gTestHarness, gTestCase);
	
	largeReads(KLargeRow, KLargeCol, ENoThreads); 

	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Large sequential reads, threads accessing same file\n"), 
																	gTestHarness, gTestCase);
	largeReads(KLargeRow, KLargeCol, ETwoThreadsSame); 

	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Large sequential reads, threads accessing dif files\n"), 
																	gTestHarness, gTestCase);
	largeReads(KLargeRow, KLargeCol, ETwoThreadsDif); 

	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Large sequential reads, threads accessing dif files some big some small blocks\n"),
																	gTestHarness, gTestCase);
	largeReads(KLargeRow, KLargeCol, ETwoThreadsDifDif); 

	gTestCase++;
	DeleteAll(gSessionPath);

	// Large writings		
	test.Printf(_L("#~TS_Title_%d,%d: Large sequential writes\n"), gTestHarness, gTestCase);

	largeWrites(KLargeRow, KLargeCol, ENoThreads); 

	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Large sequential writes, threads accessing same file\n"), 
																	gTestHarness, gTestCase);
	largeWrites(KLargeRow, KLargeCol, ETwoThreadsSame); 

	gTestCase++;
	test.Printf(_L("#~TS_Title_%d,%d: Large sequential writes, threads accessing dif files\n"), 
																	gTestHarness, gTestCase);
	largeWrites(KLargeRow, KLargeCol, ETwoThreadsDif); 

	gTestCase++;
	DeleteAll(gSessionPath);
	test.Printf(_L("#~TestEnd_%d\n"), gTestHarness);
	
	return(KErrNone);
}

/** Writes aSize bytes of data in aBlockSize during aTime seconds 
	if the aSize bps is not met, it fails

	@param f 			File to write to
	@param aSize 		Size in bytes of data to be written 
	@param aBlockSize 	Block size to be used
	@param aTime 		Time during which the write has to happen in seconds 
*/
LOCAL_C TBool writeStr( RFile f, TInt aSize, TInt aBlockSize, TInt aTime) 
{
	TInt r = 0, j = 0;
	TTime startTime, endTime;
	TTimeIntervalMicroSeconds timeTaken(0);
	TTimeIntervalMicroSeconds32 timeLeft(0);
	TBool onTarget = ETrue;
	
	TInt time;

	TInt i = 0;
	while((i < aTime) && onTarget) 
	{
		// If measuring the CPU time
		
		startTime.HomeTime();	
		j = 0;
		while(j < aSize)
			{
				r = f.Write(gBufWritePtr, aBlockSize);
				FailIfError(r);
				j += aBlockSize;
			}					
		endTime.HomeTime();
		
		timeTaken = endTime.MicroSecondsFrom(startTime);	
		time = I64LOW(timeTaken.Int64());
		if(time > KOneSec) 
		{
			onTarget = EFalse; 			
		}
		
		timeLeft = KOneSec - time;
		if(timeLeft.Int() >= 0) 
		{
			User::After(timeLeft);
		}
		i++;
	}
	
	return onTarget;
}

/** Reads streaming

*/
LOCAL_C TInt ReadStream(TAny*)
{
	RTest test(_L("test 2"));
	RFs fs;
	RFile file;
	TInt j = 0;
	TTime startTime, endTime;
	TTimeIntervalMicroSeconds timeTaken(0);
	TTimeIntervalMicroSeconds32 timeLeft(0);
	TInt time;
	TInt size , currentPos = 0; 

	TInt r = fs.Connect();
	
	fs.SetSessionPath(gSessionPath);
	
	r = file.Open(fs, gStreamFile, EFileShareAny|EFileRead);
	
	client.Signal();

	FailIfError(r);
	r = file.Size(size);
	FailIfError(r);

	FOREVER
	{
		startTime.HomeTime();	
		j = 0;
		while(j < (gCurrentSpeed * KOneK))
			{
				r=file.Read(gBufReadPtr,gCurrentBS);
				FailIfError(r);
				j += gCurrentBS;
			}					
		endTime.HomeTime();
		
		timeTaken = endTime.MicroSecondsFrom(startTime);	
		time = I64LOW(timeTaken.Int64());
		
		if(time > KOneSec) 
		{
			test.Printf(_L("Background Thread: Speed failed to be achieved: %d kbps\n"), gCurrentSpeed);			
		}
		

		
		timeLeft = KOneSec - time;
		User::After(timeLeft);
		currentPos += (gCurrentSpeed * KOneK); 
		r = file.Size(size);
		FailIfError(r);
		if(currentPos > size ) 
		{
			currentPos = 0;
			file.Seek(ESeekStart, currentPos);
		}

	}
	
}

/** Test case layout, read/write at aSpeed during aWtime and aRTime

	@param aSpeed 		Target speed in kbps
	@param aBlockSize 	Block size for the I/O operation
	@param aWTime		Writing time
	@param aRTime 		Reading time 		
*/
LOCAL_C void streamIt ( TInt aSpeed, TInt aBlockSize, TInt aWTime, TInt aRTime, TInt aStep)
{
	TInt iSize = (aSpeed * KTobps) / KByte;  // Size in bytes
	RFile file;
	TInt pos = 0;
	TInt r = 0;
	
	PrintResult(aStep, 1, aBlockSize);
	
	r = file.Replace(TheFs, gStreamFile, EFileShareAny|EFileWrite);
	FailIfError(r);

	// Streaming to the media during aWTime seconds
	if(writeStr(file, iSize, aBlockSize, aWTime))
	{	//Pass (1)
		PrintResult(aStep, 2, 1); 
	}
	else 
	{ //Fail (0)
		PrintResult(aStep, 2, 0); 
	}
	
	// Create a different thread for reading from the beginning during aRTime
	TBuf<20> buf = _L("Speedy");
	buf.AppendNum(ThreadCount++);
	
	gCurrentSpeed = aSpeed; 
	gCurrentBS = aBlockSize; 
	r = gSpeedy.Create(buf, ReadStream, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
	FailIfError(r);

	gSpeedy.Resume();
	client.Wait();

	// Keep writing during the time the other thread is reading
	if(writeStr(file, iSize, aBlockSize, aRTime))
	{ //Pass (1)
		PrintResult(aStep, 3, 1); 	
	}
	else
	{ //Fail (0)
		PrintResult(aStep, 3, 0); 
	}
	
	// Writing from the beginning again 
	file.Seek(ESeekStart, pos);
	if(writeStr(file, iSize, aBlockSize, aRTime))
	{ //Pass (1)
		PrintResult(aStep, 4, 1); 	
	}
	else
	{ //Fail (0)
		PrintResult(aStep, 4, 0); 
	}
	

	// Kill the thread for reading
	gSpeedy.Kill(KErrNone);
	FailIfError(r);
	gSpeedy.Close();	
	
	file.Close();	
}

/** Iterating through different blocksizes

	@param aSpeed Speed at which the test happens
*/
LOCAL_C void streaming(TInt aSpeed)
{
	TInt i = 9; // Pow(i) = 512 bytes
	TInt blockSize = 0;
	TInt testStep = 1;
	
	while( i < 15 ) // Pow(i) = 16 Kb
	{
		blockSize = Pow(i) ; 
		streamIt(aSpeed, blockSize, 5 * 60, 15, testStep++); // 5 minutes writing , then 15 secs reading
		i++;
	}
}

/** High level test routine. Different test cases executed

	@param aSelector 	Test case configuration in case of manual execution
*/
LOCAL_C TInt TestStreaming(TAny* aSelector)
{
	
	Validate(aSelector);
	// Each test case of the suite has an identifyer for parsing purposes of the results
	gTestHarness = 9;	
	gTestCase = 1;


	PrintHeaders(5, _L("t_fcachebm. Streaming"));
	
	test.Printf(_L("#~TS_Title_%d,%d: Writing / reading at 100 kbps\n"), 
												gTestHarness, gTestCase);
	
	streaming(100);
	
	test.Printf(_L("#~TS_Title_%d,%d: Writing / reading at 200 kbps\n"), 
												gTestHarness, ++gTestCase);

	streaming(200);

	test.Printf(_L("#~TS_Title_%d,%d: Writing / reading at 500 kbps\n"), 
												gTestHarness, ++gTestCase);

	streaming(500);


	DeleteAll(gSessionPath);

	// Start the small random reads in the background
	CreateFile(gBaseFile, Pow(KSmallCol-1));
	
	TBuf<20> buf=_L("Speedy");
	buf.AppendNum(ThreadCount++);
	
	TInt r = gSpeedyII.Create(buf, ReadSmallBase, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
	FailIfError(r);

	gSpeedyII.Resume();
	client.Wait();
	
	// Measure the throughput with background activity
	test.Printf(_L("#~TS_Title_%d,%d: Writing / reading at 100 kbps, while small reads\n"), 
																gTestHarness, ++gTestCase);

	streaming(100);	

	test.Printf(_L("#~TS_Title_%d,%d: Writing / reading at 200 kbps, while small reads\n"), 
																gTestHarness, ++gTestCase);

	streaming(200);
	
	test.Printf(_L("#~TS_Title_%d,%d: Writing / reading at 500 kbps, while small reads\n"), 
																gTestHarness, ++gTestCase);
	
	streaming(500);
	
	// Kill the small random reads and writes 
	gSpeedyII.Kill(KErrNone);
	FailIfError(r);
	
	gSpeedyII.Close();	
	
	DeleteAll(gSessionPath);

	gTestCase++;
	test.Printf(_L("#~TestEnd_%d\n"), gTestHarness);
	
	return(KErrNone);
}

/** It goes automatically through all the options

	@param aSelector Configuration in case of manual execution
*/
LOCAL_C TInt TestAll(TAny* aSelector)
{
 	TestSmall(aSelector);
 	TestLarge(aSelector);
 	TestStreaming(aSelector);

	return(KErrNone);
}

/** Call all tests

*/
GLDEF_C void CallTestsL()
{
	TBuf16<25> temp;
	
	TInt r=client.CreateLocal(0);
	FailIfError(r);
	
	// Setting up the environment and creating the needed files
	gSessionPath = _L("?:\\F32-TST\\");
	gSessionPath[0] = (TText) gDriveToTest;
	
	FileNamesGeneration(temp, 8, 0, 1);	
	gBaseFile = gSessionPath;
	gBaseFile.Append(temp);
	
	FileNamesGeneration(temp, 8, 1, 1);	
	gFileA = gSessionPath;
	gFileA.Append(temp);
	
	FileNamesGeneration(temp, 8, 2, 1);	
	gFileB = gSessionPath;
	gFileB.Append(temp);

	FileNamesGeneration(temp, 8, 3, 1);	
	gStreamFile = gSessionPath;
	gStreamFile.Append(temp);

	TRAPD(res,gBuf = HBufC8::NewL(256 * KOneK));
	test(res == KErrNone && gBuf != NULL);
		
	gBufWritePtr.Set(gBuf->Des());
	FillBuffer(gBufWritePtr, 256 * KOneK, 'A');
	
	TRAPD(res2, gBufSec = HBufC8::NewL(256 * KOneK));
	test(res2 == KErrNone && gBufSec != NULL);
	gBufReadPtr.Set(gBufSec->Des());

	TVolumeInfo volInfo;
	TInt drive;
	
	r = TheFs.CharToDrive(gDriveToTest,drive);
	FailIfError(r);
	r = TheFs.Volume(volInfo, drive);
	FailIfError(r);
	
	gMediaSize = volInfo.iSize;
	
	FormatFat(gSessionPath[0]-'A');
	TheFs.MkDirAll(gSessionPath);

	RThread noisy; 
	TBuf<20> buf = _L("Noisy");
	r = noisy.Create(buf, noise, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
	FailIfError(r);
	
	noisy.Resume();

	CSelectionBox* TheSelector=CSelectionBox::NewL(test.Console());
	
	if(gMode == 0) 
	{ // Manual
		gSessionPath=_L("?:\\");
		TCallBack smallOps(TestSmall, TheSelector);
		TCallBack largeOps(TestLarge, TheSelector);
		TCallBack simulOps(TestStreaming, TheSelector);
		TCallBack tAll(TestAll, TheSelector);
		TheSelector->AddDriveSelectorL(TheFs);
		TheSelector->AddLineL(_L("Small random r/w"), smallOps);
		TheSelector->AddLineL(_L("Large conseq r/w"), largeOps);
		TheSelector->AddLineL(_L("Streaming"), simulOps);
		TheSelector->AddLineL(_L("Execute all options"), tAll);
		TheSelector->Run();
	}
	else 
	{ // Automatic
		TestAll(TheSelector);
	}
	
	DeleteAll(gSessionPath);
			
	client.Close();
	delete TheSelector;
	delete gBuf;
	delete gBufSec;
	noisy.Kill(KErrNone);
	noisy.Close();	
}