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

 // 

 //

 #include <f32file.h>

 #include <e32test.h>

 #include "t_select.h"

 #include "../server/t_server.h"

 GLDEF_D RTest test(_L("File Server Benchmarks"));

 LOCAL_D RSemaphore client;

 LOCAL_D TInt speedCount;

 LOCAL_D const TInt KHeapSize=0x2000;

 LOCAL_D TBuf8<4096> buf;

 //

 LOCAL_D TDriveList gDriveList;

 //

 LOCAL_D TInt gLocalDrive;

 LOCAL_D TInt gLocalDriveReadSize;

 LOCAL_D TInt gLocalDriveWriteSize;

 //

 LOCAL_D TFileName gFindEntryDir;

 LOCAL_D TInt gFindEntrySearchStart;

 LOCAL_D TInt gFindEntrySearchFinish;

 //

 LOCAL_D TInt gSeekPos1;

 LOCAL_D TInt gSeekPos2;

 LOCAL_D TFileName gSeekFile;

 LOCAL_D TInt ThreadCount=0;

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 const TInt64 KGb  	= 1 << 30;

 const TInt64 K2GB 	= 2 * KGb;

 const TInt64 K3GB   = 3 * KGb;

 LOCAL_D TInt64 gLSeekPos1;

 LOCAL_D TInt64 gLSeekPos2;

 enum TSelectedTest

     {

 	ELocalDriveTest, EFindEntryTest, EFileSeekTest, EFileSeekRFile64Test

 	};

 #else 

 enum TSelectedTest

     {

 	ELocalDriveTest, EFindEntryTest, EFileSeekTest

 	};

 #endif  ////SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 // RFs::CheckDisk() will return an error if the directory depth exceeds this value :

 const TInt KCheckDskMaxRecursionLevel = 50;

 LOCAL_C void FormatFat(TDriveUnit aDrive)

 //

 // Call all RFormat methods

 //

 	{

 	RFormat format;

 	TPckgBuf<TInt> count;

 	TInt r=format.Open(TheFs,aDrive.Name(),EHighDensity,count());

 	test(r==KErrNone);

 	test(count()==100);

 	TRequestStatus status;

 	while (count())

 		{

 		format.Next(count,status);

 		User::WaitForRequest(status);

 		test(status==KErrNone);

 		}

 	format.Close();

 	}

 LOCAL_C void DoTest(TThreadFunction aFunction)

 //

 // Do a speed test

 //

 	{

 	RThread speedy;

 	TBuf<8> buf=_L("Speedy");

 	buf.AppendNum(ThreadCount++);

 	TInt r=speedy.Create(buf,aFunction,KDefaultStackSize,KHeapSize,KHeapSize,NULL);

 	test(r==KErrNone);

 //

     speedy.SetPriority(EPriorityLess);

 	speedy.Resume();

 	client.Wait();

 	r = TheFs.CheckDisk(gSessionPath);

 	test (r == KErrNone);

 //

     User::After(300000);

     TInt b=speedCount;

     User::After(3000000);

     TInt n=speedCount;

     test.Printf(_L(" Completed %d calls per second\n"),(n-b)/3);

 	test(TheFs.CheckDisk(gSessionPath) == KErrNone);

 //

 	speedy.Kill(KErrNone);

 	test(r==KErrNone);

 	speedy.Close();

 	}

 LOCAL_C TInt rawReadData(TAny*)

 //

 // The entry point for the speed test thread.

 //

 	{

 	speedCount=0;

 	TBusLocalDrive localDrive;

     TBool changed;

 	localDrive.Connect(gLocalDrive,changed);

 	client.Signal();

 	FOREVER

 		{

 		localDrive.Read(512+32,gLocalDriveReadSize,buf);

 		speedCount++;

 		}

 //	return(KErrNone);

 	}

 LOCAL_C TInt rawWriteData(TAny*)

 //

 // The entry point for the speed test thread.

 //

 	{

 	speedCount=0;

 	TBusLocalDrive localDrive;

     TBool changed;

 	localDrive.Connect(gLocalDrive,changed);

 	buf.SetLength(gLocalDriveWriteSize);

 	client.Signal();

 	FOREVER

 		{

 		localDrive.Write(512+32,buf);

 		speedCount++;

 		}

 //	return(KErrNone);

 	}

 LOCAL_C void TestLocalDriveRead(TInt drive,TInt readsize)

 //

 // Test TBusLocalDrive read

 //

 	{

 	test.Printf(_L("TBusLocalDrive %d Reading %d bytes"),drive,readsize);

 #if defined(__WINS__)

 	if (drive==EDriveX)

 		drive=1;

 	else if (drive==EDriveY)

 		drive=0;

 #endif

 	gLocalDrive=drive;

 	gLocalDriveReadSize=readsize;

 	DoTest(rawReadData);

 	}

 LOCAL_C void TestLocalDriveWrite(TInt drive,TInt writesize)

 //

 // Test TBusLocalDrive write

 //

 	{

 	test.Printf(_L("TBusLocalDrive %d Writing %d bytes"),drive,writesize);

 #if defined(__WINS__)

 	if (drive==EDriveX)

 		drive=1;

 	else if (drive==EDriveY)

 		drive=0;

 #endif

 	gLocalDrive=drive;

 	gLocalDriveWriteSize=writesize;

 	DoTest(rawWriteData);

 	}

 LOCAL_C TInt FindEntryBounce(TAny*)

 //

 // Find entries in hierarchy

 //

 	{

 	speedCount=0;

 	RFs fs;

 	TInt r=fs.Connect();

 	test(r==KErrNone);

 	r=fs.SetSessionPath(gSessionPath);

 	test(r==KErrNone);

 	client.Signal();

 	FOREVER

 		{

 		TEntry entry;

 		r=fs.Entry(gFindEntryDir,entry);

 		test(r==KErrNone);

 		r=fs.Entry(_L("\\F32-TST"),entry);

 		test(r==KErrNone);

 		speedCount++;

 		}

 //	fs.Close();

 //	return(KErrNone);

 	}

 LOCAL_C void TestFindEntryBounce(TInt aDepth)

 //

 // Find entries at different depths

 //

 	{

 	test.Printf(_L("Find entry 1 then find entry %d"),aDepth);

 	gFindEntryDir=_L("\\F32-TST\\");

 	TInt i;

 	for(i=0;i<aDepth;i++)

 		{

 		gFindEntryDir+=_L("X");

 		gFindEntryDir.AppendNum(i);

 		gFindEntryDir+=_L("\\");

 		}

 	gFindEntryDir+=_L("X");

 	gFindEntryDir.AppendNum(i);

 	DoTest(FindEntryBounce);

 	}

 LOCAL_C TInt FindEntrySearch(TAny*)

 //

 // Find entries in hierarchy

 //

 	{

 	speedCount=0;

 	RFs fs;

 	TInt r=fs.Connect();

 	test(r==KErrNone);

 	r=fs.SetSessionPath(gSessionPath);

 	test(r==KErrNone);

 	client.Signal();

 	FOREVER

 		{

 		TFileName temp=gFindEntryDir;

 		for(TInt i=gFindEntrySearchStart;i<gFindEntrySearchFinish;i++)

 			{

 			temp+=_L("X");

 			temp.AppendNum(i);

 			TEntry entry;

 			r=fs.Entry(temp,entry);

 			test(r==KErrNone);

 			temp+=_L("\\");

 			}

 		speedCount++;

 		}

 //	fs.Close();

 //	return(KErrNone);

 	}

 LOCAL_C void TestFindEntrySearch(TInt aStart, TInt aFinish)

 //

 // Find entries at different depths

 //

 	{

 	test.Printf(_L("Find entries %d to %d"),aStart,aFinish);

 	gFindEntrySearchStart=aStart;

 	gFindEntrySearchFinish=aFinish;

 	gFindEntryDir=_L("\\F32-TST\\");

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

 		{

 		gFindEntryDir+=_L("X");

 		gFindEntryDir.AppendNum(i);

 		gFindEntryDir+=_L("\\");

 		}

 	DoTest(FindEntrySearch);

 	}

 LOCAL_C TInt FileSeekTest(TAny*)

 //

 // Read 16bytes at different locations

 //

 	{

 	speedCount=0;

 	RFs fs;

 	TInt r=fs.Connect();

 	test(r==KErrNone);

 	r=fs.SetSessionPath(gSessionPath);

 	test(r==KErrNone);

 	RFile f;

 	r=f.Open(fs,gSeekFile,EFileRead); // 3rd arg was EFileRandomAccess, but this no longer exists

 	test(r==KErrNone);

 	client.Signal();

 	FOREVER

 		{

 		r=f.Read(gSeekPos1,buf,16);

 		test(r==KErrNone);

 		r=f.Read(gSeekPos2,buf,16);

 		test(r==KErrNone);

 		speedCount++;

 		}

 //	f.Close();

 //	fs.Close();

 //	return(KErrNone);

 	}

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 LOCAL_C TInt FileSeekRFile64Test(TAny*)

 //

 // Read 16bytes at different locations

 //

 	{

 	speedCount=0;

 	RFs fs;

 	TInt r=fs.Connect();

 	test(r==KErrNone);

 	r=fs.SetSessionPath(gSessionPath);

 	test(r==KErrNone);

 	RFile64 f;

 	r=f.Open(fs,gSeekFile,EFileRead); // 3rd arg was EFileRandomAccess, but this no longer exists

 	test(r==KErrNone);

 	client.Signal();

 	FOREVER

 		{

 		r=f.Read(gLSeekPos1,buf,16);

 		test(r==KErrNone);

 		r=f.Read(gLSeekPos2,buf,16);

 		test(r==KErrNone);

 		speedCount++;

 		}

 	}

 LOCAL_C void TestSeek64(TInt64 aLoc1, TInt64 aLoc2)

 //

 // Read 16bytes at different locations

 //

 	{

 	test.Printf(_L("Read 16bytes at positions %ld and %ld"),aLoc1,aLoc2);

 	gLSeekPos1=aLoc1;

 	gLSeekPos2=aLoc2;

 	DoTest(FileSeekRFile64Test);

 	}

 #endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 LOCAL_C void TestSeek(TInt aLoc1, TInt aLoc2)

 //

 // Read 16bytes at different locations

 //

 	{

 	test.Printf(_L("Read 16bytes at positions %d and %d"),aLoc1,aLoc2);

 	gSeekPos1=aLoc1;

 	gSeekPos2=aLoc2;

 	DoTest(FileSeekTest);

 	}

 LOCAL_C void InitializeDrive(CSelectionBox* aSelector)

 //

 // Get the drive into a good state

 //

 	{

 	TDriveUnit drive=((CSelectionBox*)aSelector)->CurrentDrive();

 	gSessionPath[0]=TUint8('A'+drive);

 	TInt r=TheFs.SetSessionPath(gSessionPath);

 	test(r==KErrNone);

 	TDriveInfo driveInfo;

 	r=TheFs.Drive(driveInfo);

 	test(r==KErrNone);

 	if (driveInfo.iType==EMediaNotPresent)

 		{

 		test.Printf(_L("ERROR: MEDIA NOT PRESENT <Press return to continue>\n"));

 		test.Getch();

 		return;

 		}

 	r=TheFs.MkDirAll(gSessionPath);

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

 	if (r==KErrCorrupt)

 		FormatFat(gSessionPath[0]-'A');

 	if (r!=KErrNone && r!=KErrAlreadyExists)

 		{

 		r=TheFs.MkDirAll(gSessionPath);

 		test(r==KErrNone);

 		}

 	}

 LOCAL_C TInt ValidateDriveSelection(TDriveUnit aDrive,TSelectedTest aTest)

 	{

 	if ((aDrive==EDriveZ)||((aDrive==EDriveC)&&(aTest==ELocalDriveTest)))

 		{

 		test.Printf(_L("Test not available for this drive\n"));

 		test.Printf(_L("Press any key to continue...\n"));

 		test.Getch();

 		return (KErrNotSupported);

 		}

 	else

 		return (KErrNone);

 	}

 LOCAL_C TInt TestLocalDrive(TAny* aSelector)

 //

 // Test TBusLocalDrive

 //

 	{

 	if (((CSelectionBox*)aSelector)->CurrentKeyPress()!=EKeyEnter)

 		return(KErrNone);

 	TDriveUnit drive=((CSelectionBox*)aSelector)->CurrentDrive();

 	TInt r=ValidateDriveSelection(drive,ELocalDriveTest);

 	if (r==KErrNotSupported)

 		return (r);

 	InitializeDrive((CSelectionBox*)aSelector);

 //

 	TBuf<128> testTitle;

 	TBuf<KMaxFileName> name=drive.Name();

 	testTitle.Format(_L("Test TBusLocalDrive %S"),&name);

 	test.Start(testTitle);

 	TestLocalDriveRead(drive,16);

 	TestLocalDriveRead(drive,1024);

 	TestLocalDriveRead(drive,4096);

 //

 	TestLocalDriveWrite(drive,16);

 	TestLocalDriveWrite(drive,1024);

 	TestLocalDriveWrite(drive,4096);

 //

 	test.Printf(_L("Test finished, reformatting drive %d\n"),gSessionPath[0]-'A');

 	FormatFat(gSessionPath[0]-'A');

 	test.End();

 	return(KErrNone);

 	}

 LOCAL_C TInt TestFindEntries(TAny* aSelector)

 //

 // Test Entry

 //

 	{

 	if (((CSelectionBox*)aSelector)->CurrentKeyPress()!=EKeyEnter)

 		return(KErrNone);

 	TInt r=ValidateDriveSelection(((CSelectionBox*)aSelector)->CurrentDrive(),EFindEntryTest);

 	if (r==KErrNotSupported)

 		return(r);

 	InitializeDrive((CSelectionBox*)aSelector);

 //

 	test.Start(_L("Test Entry"));

 	TFileName dirFiftyDeep=_L("\\F32-TST\\");		// root + first directory = 2 directory levels

 	for(TInt i=0;i<KCheckDskMaxRecursionLevel-2;i++)	// 0 to 47 = 48 directory levels

 		{

 		dirFiftyDeep+=_L("X");

 		dirFiftyDeep.AppendNum(i);

 		dirFiftyDeep+=_L("\\");

 		}

 	r=TheFs.MkDirAll(dirFiftyDeep);

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

 //

 	TestFindEntryBounce(2);

 	TestFindEntryBounce(10);

 	TestFindEntryBounce(20);

 	TestFindEntryBounce(KCheckDskMaxRecursionLevel-3);

 //

 	TestFindEntrySearch(1,5);

 	TestFindEntrySearch(1,10);

 	TestFindEntrySearch(10,15);

 	TestFindEntrySearch(10,20);

 //

 	test.Printf(_L("Test finished, removing directory\n"));

 	CFileMan* fMan=CFileMan::NewL(TheFs);

 	r=fMan->RmDir(_L("\\F32-TST\\X0\\"));

 	test(r==KErrNone);

 	delete fMan;

 	test.End();

 	return(KErrNone);

 	}

 LOCAL_C TInt TestFileSeek(TAny* aSelector)

 //

 // Test Seek

 //

 	{

 	if (((CSelectionBox*)aSelector)->CurrentKeyPress()!=EKeyEnter)

 		return(KErrNone);

 	TInt r=ValidateDriveSelection(((CSelectionBox*)aSelector)->CurrentDrive(),EFileSeekTest);

 	if (r==KErrNotSupported)

 		return (r);

 	InitializeDrive((CSelectionBox*)aSelector);

 //

 	test.Start(_L("Test Seek"));

 	RFile f;

 	gSeekFile=_L("\\F32-TST\\FILE512K.BIG");

 	r=f.Replace(TheFs,gSeekFile,EFileWrite);

 	test(r==KErrNone);

 	r=f.SetSize(524268);

 	test(r==KErrNone);

 	f.Close();

 //

 	TestSeek(0,1000);

 	TestSeek(0,10000);

 	TestSeek(5000,6000);

 	TestSeek(5000,15000);

 	TestSeek(10000,100000);

 	TestSeek(200000,500000);

 //

 	r=TheFs.Delete(gSeekFile);

 	test(r==KErrNone);

 	test.End();

 	return(KErrNone);

 	}

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 //Read the file at position beyond 2GB-1

 //Minimum required disk space for this test is 3GB

 //

 LOCAL_C TInt TestLargeFileSeek(TAny* aSelector)

 	{

 	if (((CSelectionBox*)aSelector)->CurrentKeyPress()!=EKeyEnter)

 		return(KErrNone);

 	TInt r=ValidateDriveSelection(((CSelectionBox*)aSelector)->CurrentDrive(),EFileSeekRFile64Test);

 	if (r==KErrNotSupported)

 		return (r);

 	InitializeDrive((CSelectionBox*)aSelector);

 //

 	test.Start(_L("Test large File Seek"));

 	RFile64 BigFile;

 	gSeekFile=_L("\\F32-TST\\FILE4GBMINUS2.BIG");

     r=BigFile.Replace(TheFs,gSeekFile,EFileWrite);

 	test(r==KErrNone);

 	//check Disk space

 	TVolumeInfo volInfo;

     r = TheFs.Volume(volInfo);

     test(r==KErrNone);

 	//Get the free space available for test

 	if(volInfo.iFree < (K3GB-2)) 

 		{

 		BigFile.Close();

 		test(r==KErrNone);

 		r=TheFs.Delete(gSeekFile);

 		test.Printf(_L("Large File test is skipped: Free space %ld \n"),volInfo.iFree);

 		return r;

 		}

 	r=BigFile.SetSize(K3GB-2);

 	test(r==KErrNone);

 	BigFile.Close();

 	TestSeek64(0,1000);

 	TestSeek64(5000,6000);

 	TestSeek64(200000,500000);

     TestSeek64(K2GB,K2GB+1000);

 	TestSeek64(K3GB-1000,K3GB-2000);

 	TestSeek64(K3GB-50, K3GB-20);

 	r=TheFs.Delete(gSeekFile);

 	test(r==KErrNone);

 	test.End();

 	return(KErrNone);

 	}

 #endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 GLDEF_C void CallTestsL()

 //

 // Call all tests

 //

 	{

 	TInt r=client.CreateLocal(0);

 	test(r==KErrNone);

 	gSessionPath=_L("?:\\F32-TST\\");

 	CSelectionBox* TheSelector=CSelectionBox::NewL(test.Console());

 	TCallBack localDrivesCb(TestLocalDrive,TheSelector);

 	TCallBack findEntriesCb(TestFindEntries,TheSelector);

 	TCallBack fileSeekCb(TestFileSeek,TheSelector);

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	TCallBack largefileSeekCb(TestLargeFileSeek,TheSelector);

 #endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	TheSelector->AddDriveSelectorL(TheFs);

 	TheSelector->AddLineL(_L("Test LocalDrive"),localDrivesCb);

 	TheSelector->AddLineL(_L("Test Find Entries"),findEntriesCb);

 	TheSelector->AddLineL(_L("Test File Seek"),fileSeekCb);

 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	TheSelector->AddLineL(_L("Test large File Seek"),largefileSeekCb);

 #endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	TheSelector->Run();

 	client.Close();

 	delete TheSelector;

 	}