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

// 

//

#include <f32file.h>

#include <e32test.h>

#include <e32hal.h>

#include <e32math.h>

#include <f32dbg.h>

#include "t_benchmain.h"

#include "t_chlffs.h"

RFs         TheFs;

TFileName   gSessionPath;

TFileName   gExeFileName(RProcess().FileName());

TInt        gAllocFailOff=KAllocFailureOff;

TInt        gAllocFailOn=KAllocFailureOff;

TInt64      gSeed = 51703;

TInt        gFilesLimit; 	

TInt        gTypes;  		

TInt        gMode; 

TInt        gFormat = EFalse; 	

TInt        gMinutes; 

TInt        gFileSize = 0; 			// In Kbytes	

TInt 		gTestHarness = 0;

TInt 		gTestCase = 1;

TInt 		gTimeUnit = 1000; // values: 1 - us, 1000 - ms, 1000000 - s

TChar       gDriveToTest = ' ';

////////////////////////////////////////////////////////////

// Template functions encapsulating ControlIo magic

//

template <class C>

TInt controlIo(RFs &fs, TInt drv, TInt fkn, C &c)

	{

    TPtr8 ptrC((TUint8 *)&c, sizeof(C), sizeof(C));

    TInt r = fs.ControlIo(drv, fkn, ptrC);

    return r;

	}

/** Prints headers of FAT32 and File Cache benchmarking

	@param aType type of test (FAT32 = 1/2 or File Cache = 3/4/5)

	@param

*/

void PrintHeaders(TInt aType, TPtrC16 aTitle ) 

	{

	TBuf16<250> title = _L("#~TestTitle_%d: ");

	title.Append(aTitle);

	title.Append(_L("\n"));

	test.Printf(_L("#~TestId=%d\n"), gTestHarness);	

	test.Printf(title, gTestHarness);

	test.Printf(_L("#~Report Variant: \n"));	

	test.Printf(_L("#~Report Description: \n"));	

	_LIT(KSeconds,"seconds");

	_LIT(KMilliSecs,"milliseconds");

	_LIT(KMicroSecs,"microseconds");

	TPtrC16 timeUnit;

	if (gTimeUnit == 1) 

		timeUnit.Set(KMicroSecs);

	else if (gTimeUnit == 1000) 

		timeUnit.Set(KMilliSecs);

	else if (gTimeUnit == 1000000)

		timeUnit.Set(KSeconds);

	else

		{

		test.Printf(_L("Please, check gTimeUnit value\n"));

		test(EFalse);	

		}

	if(aType == 1) 

		{ // All FAT32 tests but t_fsrrepeat

		test.Printf(_L("#~TestParam_%d: MaxFiles=%d, type=%d, mode=%d, timeUnit=%S\n"), gTestHarness, gFilesLimit, gTypes, gMode, &timeUnit);

		test.Printf(_L("#~TestRows_%d: 4\n"), gTestHarness);

		test.Printf(_L("#~TestColumns_%d: 4, NFiles, 8_3, 20_chars, 50_50\n"), gTestHarness);	

		}

	else if(aType == 2) 

		{ // t_fsrrepeat

		test.Printf(_L("#~TestParam_%d: MaxFiles=%d, type=%d, mode=%d, timeUnit=%S\n"), gTestHarness, gFilesLimit, gTypes, gMode, &timeUnit);

		test.Printf(_L("#~TestRows_%d: 12\n"), gTestHarness);

		test.Printf(_L("#~TestColumns_%d: 4, DirName, 1st, 2nd, 3rd\n"), gTestHarness);			

		} 

	else if(aType == 3)

		{ // Large sequential reads/writes

		test.Printf(_L("#~TestParam_%d: mode=%d, timeUnit=%S\n"), gTestHarness, gMode, &timeUnit);

		test.Printf(_L("#~TestRows_%d: 8\n"), gTestHarness);

		test.Printf(_L("#~TestColumns_%d: 4, bsize, 100KB, 1MB, 10MB\n"), gTestHarness);

		}

	else if(aType == 4)

		{ // Small random reads/writes

		test.Printf(_L("#~TestParam_%d: mode=%d, timeUnit=%S\n"), gTestHarness, gMode, &timeUnit);

		test.Printf(_L("#~TestRows_%d: 11\n"), gTestHarness);

		test.Printf(_L("#~TestColumns_%d: 8, bsize, 1KB, 2KB, 4KB, 8KB, 16KB, 32KB, 64KB\n"), gTestHarness);

		}

	else if(aType == 5)

		{ // Streaming

		test.Printf(_L("#~TestParam_%d: mode=%d, timeUnit=%S\n"), gTestHarness, gMode, &timeUnit);

		test.Printf(_L("#~TestRows_%d: 6\n"), gTestHarness);

		test.Printf(_L("#~TestColumns_%d: 4, bsize, 5m_w, 15s_w_r, 15s_w_r \n"), gTestHarness);

		}

	else 

		{

		test.Printf(_L("Check the function PrintHeaders() in t_benchmain.cpp, which wasn't called with the right parameters\n"));

		test(EFalse);	

		}

	}

/** Prints a line of results 

	@param aPosX  Row of the table

	@param aPosY  Column of the table

	@param aValue Value figure for that position 

*/

void PrintResultTime( TInt aPosX, TInt aPosY, TInt aValue) 

	{

	test.Printf(_L("#~TS_Res_%d,%d,[%d,%d]=%d\n "), gTestHarness, gTestCase, aPosX, aPosY, aValue );

	}

/** Prints any other type of data 

	@param aPosX  Row of the table

	@param aPosY  Column of the table

	@param aValue Value figure for that position 

*/

void PrintResult( TInt aPosX, TInt aPosY, TInt aValue) 

	{

	test.Printf(_L("#~TS_Res_%d,%d,[%d,%d]=%d\n "), gTestHarness, gTestCase, aPosX, aPosY, aValue);

	}

/** Prints string

	@param aPosX  Row of the table

	@param aPosY  Column of the table

	@param aValue Value figure for that position 

*/

void PrintResultS( TInt aPosX, TInt aPosY, TDes16& aValue) 

	{

	TBuf16<250> buffer = _L("#~TS_Res_%d,%d,[%d,%d]=");

	buffer.Append(aValue);

	buffer.Append(_L("\n"));

	test.Printf(buffer, gTestHarness, gTestCase, aPosX, aPosY);

	}

/** Call all RFormat methods

	@param aDrive Drive to be formatted

*/

void FormatFat(TDriveUnit aDrive)

	{

	RFormat format;

	TPckgBuf<TInt> count;

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

	FailIfError(r);

	test(count() == 100);

	TRequestStatus status;

	while (count())

		{

		format.Next(count, status);

		User::WaitForRequest(status);

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

		}

	format.Close();

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

	}

/** Validates the drive selection

	@param aDrive Drive to be validated

	@param aTest  Type of test 

*/

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"));

		return (KErrNotSupported);

		}

	else

		return (KErrNone);

	}

/** Validates the selection for this tests and update appropriate variables

	@param aSelector This object is meant to give information about what needs 

					 to be tests in manual mode

*/

TInt Validate(TAny* aSelector) 

	{

	if(gMode == 0) 

		{

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

				return(KErrNone);

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

		if (r == KErrNotSupported)

			return (r);

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

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

		r = TheFs.SetSessionPath(gSessionPath);

		FailIfError(r);

		}

	return KErrNone;

	}

/** Prints current volume information

*/

void PrintVolInfo()

	{

    TVolumeInfo volInfo;

    TInt r;

    r = TheFs.Volume(volInfo);

    FailIfError(r);

    test.Printf(_L("DriveAtt:0x%X, MediaAtt:0x%X, Free:%d KBytes\n"), volInfo.iDrive.iDriveAtt, volInfo.iDrive.iMediaAtt, (TUint32)(volInfo.iFree / 1024));

	}

/** Create directory with a number of files, with specified file name type

    @param  aN      number of files to create

    @param  aType   file names type : 1 - 8.3, 2 - 20 characters, 3 - 50/50

*/

TInt CreateDirWithNFiles(TInt aN, TInt aType)

	{

	TInt i,r=0;

	RFile file;

	TBuf16<50> directory;

	TBuf16<50> dirtemp;

	TBuf16<50> path;

	TBuf16<50> buffer(50); 	

	dirtemp.Format(KDirMultipleName,aType, aN);

	directory=gSessionPath;

	directory.Append(dirtemp);

	r = TheFs.MkDir(directory);

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

    const TUint KNumFilesPrintTreshold = 100;

    const TInt  KFileSize = gFileSize * 1024;

    PrintVolInfo();

	i = 0; 

	while( i < aN )

		{        

        // generate file name depending on type required

        switch(aType)    

        	{

            case 1: // 8.3 filemnames 

                FileNamesGeneration(buffer, 8, i, i%3+1);

            break;

            case 2: // 20 characrer filenames

                FileNamesGeneration(buffer, 20, i, i%3+1);

            break;

            case 3: // 50/50 mix

                if(i%2) 

                	FileNamesGeneration(buffer, 8, i, i%3+1) ;

			    else  	

			    	FileNamesGeneration(buffer, 20, i, i%3+1) ;

            break;

            default:

                test(0);

            break;

        	};

        path = directory;

		path.Append(buffer);

        // create or replace a file

        r = file.Replace(TheFs, path, EFileShareAny|EFileWrite);

        if(r != KErrNone)

        	{

            PrintVolInfo();

            test.Printf(_L("Error creating file: %S, %d\n"), &path, r);

            test(0);

        	}

        // set file size if required, file contents doesn't matter

        if(gFileSize > 0)

        	{

            r = file.SetSize(KFileSize); 

            if(r != KErrNone)

            	{

                PrintVolInfo();

                test.Printf(_L("Error setting file size: %S, %d, err:%d\n"), &path, KFileSize, r);

                test(0);

            	}

        	}

		file.Close();

        if(i > 0 && ((i+1)%KNumFilesPrintTreshold) == 0)

        	{

            test.Printf(_L("created %d files, type:%d\n"), i + 1, aType);

        	}

		i++;

    	}//while

    // write "last.txt" file to the end of directory

	path = directory;

	path.Append(KCommonFile);

	r = file.Replace(TheFs,path,EFileShareAny|EFileWrite);

    if(r != KErrNone)

    	{

        PrintVolInfo();

        test.Printf(_L("Error creating file: %S, %d\n"), &path, r);

        test(0);

    	}

	// put random content to the "last.txt" file if specified length of files > 0

    if(gFileSize > 0)

    	{

        r = file.SetSize(gFileSize * 1024); // gFileSize is in KBytes

        if(r != KErrNone)

        	{

            PrintVolInfo();

            test.Printf(_L("Error setting file size: %S, %d\n"), &path, r);

            test(0);

        	}

    	}

	file.Close();

	return(KErrNone);

	}

/**

 Creates 12 directories with different sort of files and namefiles

 100 files with 8.3, 20 chars and 50/50

 1000 files with 8.3, 20 chars and 50/50

 5000 files with 8.3, 20 chars and 50/50

 10000 files with 8.3, 20 chars and 50/50 

*/

TInt TestFileCreate(TAny* aSelector)

	{

	TInt i = 100, j = 1;

	Validate(aSelector);

	while(i <= gFilesLimit) 

		{

		if(i == 100) 

			{	

			j = 1;

			while(j <= gTypes) 

				CreateDirWithNFiles(100, j++); 

			}

		if(i == 1000) 

			{	

			j=1;

			while(j <= gTypes) 

				CreateDirWithNFiles(1000, j++); 

			}

		if(i == 5000) 

			{	

			j = 1;

			while(j <= gTypes) 

				CreateDirWithNFiles(5000, j++); 

			}

		if(i == 10000) 

			{	

			j = 1;

			while(j <= gTypes) 

				CreateDirWithNFiles(10000, j++); 

			}

		i += 100;

		}

	return(KErrNone);

	}

/** Generate a filename according to the parameters configuration

    @param  aBuffer Buffer where the name of the file will be returned

    @param  aLong 	Length of the name of the file

    @param  aPos 	Number to be attached to the name of the file

    @param  ext 	Type of extension (1/2/3) 

*/

void FileNamesGeneration(TDes16& aBuffer, TInt aLong, TInt aPos,TInt ext) 

	{

	TInt padding;

	TInt i=0;

	TBuf16<10> tempbuf;

	_LIT(KNumber,"%d");

	tempbuf.Format(KNumber, aPos);

	padding = aLong - tempbuf.Size() / 2;

	aBuffer = _L("");

	while(i < padding)

		{

		aBuffer.Append('F');

		i++;

		}

	_LIT(KExtension1, ".TXT");

	_LIT(KExtension2, ".HTM");

	_LIT(KExtension3, ".LOG");

	aBuffer.Append(tempbuf);

	switch(ext)

		{

		case 1: aBuffer.Append(KExtension1);break;

		case 2: aBuffer.Append(KExtension2);break;

		case 3: aBuffer.Append(KExtension3);break;

		default: aBuffer.Append(KExtension1);break;

		}	

	}

/** Do a checkdisk and report failure

*/

void CheckDisk()

	{

	test.Next(_L("Check Disk"));

	TInt r = TheFs.CheckDisk(gSessionPath);

	if (r != KErrNone && r != KErrNotSupported && r != KErrPermissionDenied)

		ReportCheckDiskFailure(r);

	}

/** Report a disk failure

	@param aRet The error will be returned in this variable

*/

void ReportCheckDiskFailure(TInt aRet)

	{

	test.Printf(_L("CHECKDISK FAILED: "));

	switch(aRet)

		{

		case 1:	test.Printf(_L("File cluster chain contains a bad value (<2 or >maxCluster)\n")); break;

		case 2:	test.Printf(_L("Two files are linked to the same cluster\n")); break;

		case 3:	test.Printf(_L("Unallocated cluster contains a value != 0\n"));	break;

		case 4:	test.Printf(_L("Size of file != number of clusters in chain\n")); break;

		default: test.Printf(_L("Undefined Error value %d\n"),aRet);

		}

	}

/** Expand the cleanup stack

*/

void PushLotsL()

	{

	TInt i;

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

		CleanupStack::PushL((CBase*)NULL);

	CleanupStack::Pop(1000);

	}

/** Do testing on aDrive

	@param aDrive Drive for the testing

*/

void DoTests(TInt aDrive)

	{

	gSessionPath=_L("?:\\");

	TChar driveLetter;

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

	FailIfError(r);

	gSessionPath[0] = (TText)driveLetter;

	r = TheFs.SetSessionPath(gSessionPath);

	FailIfError(r);

    test.Printf(_L("DoTests() Session Path: %S\n"),&gSessionPath);

	CheckMountLFFS(TheFs,driveLetter);

	User::After(1000000);

	r = TheFs.MkDirAll(gSessionPath);

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

		{

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

		test(EFalse);

		}

	TheFs.ResourceCountMarkStart();

	TRAP(r,CallTestsL());

	if (r == KErrNone)

		TheFs.ResourceCountMarkEnd();

	else