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

	}