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

// File Name:		f32test/bench/t_fat_perf.cpp

// This file contains implementation for the functions called 

// by test cases from the command line to test FAT Performance on

// large number of files (PREQ 1885).

// 

//

//Include files

#include <e32test.h>

#include <f32file.h>

#include <f32dbg.h>

#include "t_server.h"

#include "t_fat_perf.h"

LOCAL_C void ClearCache(TInt); 

RTest test(_L("T_FAT_PERF"));

TFileName 	gPath;

TFileName 	gFileNameBase;

TInt 		gFileNo = 0;

TInt		gTestCase = -1;

TInt		gCacheClear = 0;

TInt        gZeroPadFileNumberForFixedLengthFileNames = 0;

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

TNamingSchemeParam::TNamingSchemeParam() 

    : iConOrRan(EConsecutive), iUniOrAsc(EAscii), iZeroPadFileNumber(EFalse), iMaxFileNameLength(0), iMinStringLength(0)

    {

    iFileNameBase = _L("");

    }

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

/**

  	This function creates the files in the following directories

  	INITIAL CONDITION: FILL FOLLOWING SUB-DIRS WITH 1600 FILES

	"\\DIR1\\"...2000 files ("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_1 ~ 2000.TXT")

	"\\DIR1\\DIR11\\"...1600 files ("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_1 ~ 1600.TXT")

	"\\DIR1\\DIR11\\DIR111\\"...1610 files ("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_1 ~ 1600.TXT") + "ANOTHERLONGFILENAME_1~10.TXT"

	"\\DIR1\\DIR12RAN\\"...1600 files ("...random string (31~34)....TXT")

	"\\DIR2\\"...1600 files ("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_1 ~ 1600.TXT")

 */

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

LOCAL_C void DoTestCaseSetup()

	{

	test.Next(_L(" 'Test Setup' - 00"));

	TMLUnitParam mlParam = 

		{

		12345	// iID

		};

	CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);

	CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);

	TInt curDriveNum;

	TInt err = TheFs.CharToDrive(gDriveToTest, curDriveNum);

	test(KErrNone == err);

	FormatFatDrive(TheFs,curDriveNum, EQuickFormat, NULL, EFalse);

/*-----------------------------------------------------------------------------

 * Setup for "\\DIR1\\"

 *-----------------------------------------------------------------------------*/

   	TNamingSchemeParam namingScheme;

	namingScheme.iConOrRan 			       = EConsecutive;

	namingScheme.iUniOrAsc 			       = EAscii;

	namingScheme.iZeroPadFileNumber   = EFalse;

	namingScheme.iFileNameBase 		       = _L("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_");

	namingScheme.iMaxFileNameLength        = 0;

	namingScheme.iMinStringLength 	       = 0;

	TDirUnitParam dirParam1;

	dirParam1.iPriority 			= 1;

	dirParam1.iDirName 				= _L("?:\\DIR1\\");

	dirParam1.iRuns 				= 1;

	dirParam1.iFilesPerRun 			= 2000;

	dirParam1.iSampleInterval 		= 0;

	dirParam1.iNamingScheme 		= namingScheme;

	dirParam1.iFileOpMode 			= EFATPerfFileCreate;

	execUnit->AddDirUnitL(dirParam1);

/*-----------------------------------------------------------------------------

 * Setup for "\\DIR1\\DIR11\\"

 *-----------------------------------------------------------------------------*/

	TDirUnitParam dirParam11		= dirParam1;

	dirParam11.iDirName 			= _L("?:\\DIR1\\DIR11\\");

	dirParam11.iFilesPerRun			= 1600;

	dirParam11.iSampleInterval		= 0;

	execUnit->AddDirUnitL(dirParam11);

/*-----------------------------------------------------------------------------

 * Setup for "\\DIR1\\DIR11\\DIR111\\"

 *-----------------------------------------------------------------------------*/

	TDirUnitParam dirParam111		= dirParam1;

	dirParam111.iDirName 			= 	_L("?:\\DIR1\\DIR11\\DIR111\\");

	dirParam111.iFilesPerRun		= 1600;

	dirParam111.iSampleInterval		= 0;

	execUnit->AddDirUnitL(dirParam111);

/*-----------------------------------------------------------------------------

 * Test setup for "\\DIR1\\DIR11\\DIR111\\" with "ANOTHERLONGFILENAME_" file

 *-----------------------------------------------------------------------------*/

	TNamingSchemeParam namingScheme111A = namingScheme;

	namingScheme111A.iFileNameBase 		= _L("ANOTHERLONGFILENAME_");

	TDirUnitParam dirParam111A		= dirParam1;

	dirParam111A.iDirName 			= 	_L("?:\\DIR1\\DIR11\\DIR111\\");

	dirParam111A.iFilesPerRun		= 10;

	dirParam111A.iSampleInterval	= 0;

	dirParam111A.iNamingScheme 		= namingScheme111A;

	execUnit->AddDirUnitL(dirParam111A);

/*-----------------------------------------------------------------------------

 * Setup for "\\DIR1\\DIR12RAN\\"

 *-----------------------------------------------------------------------------*/

	TNamingSchemeParam namingScheme12 = namingScheme;

	namingScheme12.iConOrRan 			   = ERandom;

	namingScheme12.iZeroPadFileNumber = EFalse;

	namingScheme12.iFileNameBase 		   = _L("");

	namingScheme12.iMaxFileNameLength 	   = 34;

	namingScheme12.iMinStringLength 	   = 31;

	TDirUnitParam dirParam12		= dirParam1;

	dirParam12.iDirName 			= _L("?:\\DIR1\\DIR12RAN\\");

	dirParam12.iFilesPerRun			= 1600;

	dirParam12.iSampleInterval		= 0;

	dirParam12.iNamingScheme 		= namingScheme12;

	execUnit->AddDirUnitL(dirParam12);

/*-----------------------------------------------------------------------------

 * Setup for "\\DIR2\\"

 *-----------------------------------------------------------------------------*/

	TDirUnitParam dirParam2		= dirParam1;

	dirParam2.iDirName 			= _L("?:\\DIR2\\");

	dirParam2.iFilesPerRun		= 1600;

	dirParam2.iSampleInterval	= 0;

	dirParam2.iNamingScheme 	= namingScheme;

	execUnit->AddDirUnitL(dirParam2);

	execUnit->Run();

	CleanupStack::PopAndDestroy(2);

	}

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

/**

This function creates a files in the valid directory path

*/

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

LOCAL_C void DoTestCaseCreateFile()

	{

	test.Next(_L(" 'Create File' - 01"));

	TMLUnitParam mlParam = 

		{

		12345	// iID

		};

	CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);

	CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);

	ClearCache(gCacheClear);

	TNamingSchemeParam namingScheme;

	namingScheme.iZeroPadFileNumber = 	gZeroPadFileNumberForFixedLengthFileNames;

	TDirUnitParam dirParam1;

	dirParam1.iPriority 			= 1;

	dirParam1.iDirName 				= _L("");

	dirParam1.iRuns 				= 1;

	dirParam1.iFilesPerRun 			= 0;

	dirParam1.iSampleInterval 		= 1;

	dirParam1.iNamingScheme 		= namingScheme;

	dirParam1.iFileOpMode 			= EFATPerfFileCreate;

	TFileName path = _L("?:\\");

	path.Append(gPath);

	if (path[path.Length() - 1] != '\\')

		{

		path.Append('\\');

		}

	dirParam1.iDirName = path;

	dirParam1.iFilesPerRun = gFileNo;

	dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;

	execUnit->AddDirUnitL(dirParam1);

	execUnit->Run();

	CleanupStack::PopAndDestroy(2);

	}

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

/**

This function opens file in the valid directoy path

*/

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

LOCAL_C void DoTestCaseOpenFile()

	{

	test.Next(_L(" 'Open File' - 02"));

	TMLUnitParam mlParam = 

		{

		12345	// iID

		};

	CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);

	CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);

	ClearCache(gCacheClear);

	TNamingSchemeParam namingScheme;

	namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;

	TDirUnitParam dirParam1;

	dirParam1.iPriority 			= 1;

	dirParam1.iDirName 				= _L("");

	dirParam1.iRuns 				= 1;

	dirParam1.iFilesPerRun 			= 0;

	dirParam1.iSampleInterval 		= 1;

	dirParam1.iNamingScheme 		= namingScheme;

	dirParam1.iFileOpMode 			= EFATPerfFileOpen;

	TFileName path = _L("?:\\");

	path.Append(gPath);

	if (path[path.Length() - 1] != '\\')

		{

		path.Append('\\');

		}

	dirParam1.iDirName = path;

	dirParam1.iFilesPerRun = gFileNo;

	dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;

	execUnit->AddDirUnitL(dirParam1);

	execUnit->Run();

	CleanupStack::PopAndDestroy(2);

	}

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

/**

This function deletes the files in the valid directory path

*/

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

LOCAL_C void DoTestCaseDeleteFile()

	{

	test.Next(_L(" 'Delete File' - 03"));

	TMLUnitParam mlParam = 

		{

		12345	// iID

		};

	CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);

	CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);

	ClearCache(gCacheClear);

	TNamingSchemeParam namingScheme;

	namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;

	TDirUnitParam dirParam1;

	dirParam1.iPriority 			= 1;

	dirParam1.iDirName 				= _L("");

	dirParam1.iRuns 				= 1;

	dirParam1.iFilesPerRun 			= 0;

	dirParam1.iSampleInterval 		= 1;

	dirParam1.iNamingScheme 		= namingScheme;

	dirParam1.iFileOpMode 			= EFATPerfFileDelete;

	TFileName path = _L("?:\\");

	path.Append(gPath);

	if (path[path.Length() - 1] != '\\')

		{

		path.Append('\\');

		}

	dirParam1.iDirName = path;

	dirParam1.iFilesPerRun = gFileNo;

	dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;

	execUnit->AddDirUnitL(dirParam1);

	execUnit->Run();

	CleanupStack::PopAndDestroy(2);

	}

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

/**

PREQ1885  - optional test case 

This function writes data into the files in the valid directory path

*/

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

LOCAL_C void DoTestCaseWriteFile()

	{

	test.Next(_L(" 'Write File'  - 04 - Write 4KB of Data"));

	TMLUnitParam mlParam = 

		{

		12345	// iID

		};

	CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);

	CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);

	ClearCache(gCacheClear);

	TNamingSchemeParam namingScheme;

	namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;

	TDirUnitParam dirParam1;

	dirParam1.iPriority 			= 1;

	dirParam1.iDirName 				= _L("");

	dirParam1.iRuns 				= 1;

	dirParam1.iFilesPerRun 			= 0;

	dirParam1.iSampleInterval 		= 1;

	dirParam1.iNamingScheme 		= namingScheme;

	dirParam1.iFileOpMode 			= EFATPerfFileWrite;

	TFileName path = _L("?:\\");

	path.Append(gPath);

	if (path[path.Length() - 1] != '\\')

		{

		path.Append('\\');

		}

	dirParam1.iDirName = path;

	dirParam1.iFilesPerRun = gFileNo;

	dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;

	execUnit->AddDirUnitL(dirParam1);

	execUnit->Run();

	CleanupStack::PopAndDestroy(2);

	}

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

/**

PREQ1885  - optional test case  

This function Reads data from the files in the valid directory path

*/

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

LOCAL_C void DoTestCaseReadFile()

	{

	test.Next(_L(" 'Read File' - 05 Read 4KB of data"));

	TMLUnitParam mlParam = 

		{

		12345	// iID

		};

	CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);

	CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);

	ClearCache(gCacheClear);

	TNamingSchemeParam namingScheme;

    namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;

	TDirUnitParam dirParam1;

	dirParam1.iPriority 			= 1;

	dirParam1.iDirName 				= _L("");

	dirParam1.iRuns 				= 1;

	dirParam1.iFilesPerRun 			= 0;

	dirParam1.iSampleInterval 		= 1;

	dirParam1.iNamingScheme 		= namingScheme;

	dirParam1.iFileOpMode 			= EFATPerfFileRead;

	TFileName path = _L("?:\\");

	path.Append(gPath);

	if (path[path.Length() - 1] != '\\')

		{

		path.Append('\\');

		}

	dirParam1.iDirName = path;

	dirParam1.iFilesPerRun = gFileNo;

	dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;

	execUnit->AddDirUnitL(dirParam1);

	execUnit->Run();

	CleanupStack::PopAndDestroy(2);

	}

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

/**

This function Dumps the information about Directory Cache

*/

//

LOCAL_C void DoTestCaseDirCacheInfo()

	{

	ClearCache(gCacheClear);

	RDebug::Print(_L("Dumping DirCache Info - Only for DEBUG Mode \n"));

	#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

        TInt ret = TheFs.ControlIo(CurrentDrive(), ETestFATDirCacheInfo);    // For DirCache info

        if (ret != KErrNone)

            {

            RDebug::Print(_L("RFs::ControlIo() returned %d when attempting to dump cache info"), ret);

            }

        ret = TheFs.ControlIo(CurrentDrive(), ETestDumpFATDirCache);  // For Dumping DirCache contents

        if (ret != KErrNone)

            {

            RDebug::Print(_L("RFs::ControlIo() returned %d when attempting to dump cache contents"), ret);

            }

	#endif

	}

/* To clear the cache - remount drive */

LOCAL_C void ClearCache(TInt gCacheClear)

    {

    TInt rel = KErrNone;

    if (gCacheClear == 1)

        {

        // Remount the drive to clear the cache 

        rel = RemountFS (TheFs, CurrentDrive(), NULL);

        if (rel != KErrNone)

            {

            RDebug::Print(_L("<<Error>>: Remounting: %d\n"), rel);

            User::Leave(rel);

            }	

        }

    }

/* Function for command line arguments for the tests */

LOCAL_C void ParseMyCommandArguments()

	{

	TBuf<0x100> cmd;

	User::CommandLine(cmd);

	TLex lex(cmd);

	TPtrC token=lex.NextToken();

	TFileName thisfile=RProcess().FileName();

	if (token.MatchF(thisfile)==0)

		{

		token.Set(lex.NextToken());

		}

	test.Printf(_L("CLP=%S"),&token);

	if(token.Length()!=0)		

		{

		gDriveToTest=token[0];

		gDriveToTest.UpperCase();

		}

	else

		{

		gDriveToTest='C';

		return;

		}

	while (!lex.Eos())

		{

		token.Set(lex.NextToken());

		if (token.Compare(_L("-c")) == 0 || token.Compare(_L("-C")) == 0)

			{

			token.Set(lex.NextToken());

			if (token.MatchF(_L("Setup"))==0)

				{

				gTestCase = EFATPerfSetup;

				}

			else if (token.MatchF(_L("Create"))==0)

				{

				gTestCase = EFATPerfCreate; 

				}

			else if (token.MatchF(_L("Open"))==0)

				{

				gTestCase = EFATPerfOpen;

				}

			else if (token.MatchF(_L("Delete"))==0)

				{

				gTestCase = EFATPerfDelete;

				}

			else if (token.MatchF(_L("Write"))==0)

				{

				gTestCase = EFATPerfWrite;

				}