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

 				}

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

 				{

 				gTestCase = EFATPerfRead;

 				}	

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

 				{

 				gTestCase = EFATPerfDirCacheInfo;

 				}

 			else

 				{

 				test.Printf(_L("Bad command syntax"));

 				test(EFalse);

 				}

 			}

 		if (token.Compare(_L("-p")) == 0 || token.Compare(_L("-P")) == 0)

 			{

 			token.Set(lex.NextToken());

 			if (token.Length() != 0)

 				{

 				gPath = token;

 				}

 			else

 				{

 				test.Printf(_L("Bad command syntax"));

 				test(EFalse);

 				}

 			}

 		if (token.Compare(_L("-b")) == 0 || token.Compare(_L("-B")) == 0)

 			{

 			token.Set(lex.NextToken());

 			if (token.Length() != 0)

 				{

 				gFileNameBase = token;

 				}

 			else

 				{

 				test.Printf(_L("Bad command syntax"));

 				test(EFalse);

 				}

 			}

 		if (token.Compare(_L("-n")) == 0 || token.Compare(_L("-N")) == 0)

 			{

 			token.Set(lex.NextToken());

 			if (token.Length() != 0)

 				{

 				TLex tokenLex;

 				tokenLex.Assign(token);

 				TInt value;

 				tokenLex.Val(value);

 				gFileNo = value;

 				}

 			else

 				{

 				test.Printf(_L("Bad command syntax"));

 				test(EFalse);

 				}

 			}

 		if (token.Compare(_L("-m")) == 0 || token.Compare(_L("-M")) == 0)

 			{

 			token.Set(lex.NextToken());

 			if (token.Length() != 0)

 				{

 				TLex tokenLex;

 				tokenLex.Assign(token);

 				TInt value;

 				tokenLex.Val(value);

 				gCacheClear = value;

 				}

 			else

 				{

 				test.Printf(_L("Bad command syntax"));

 				test(EFalse);

 				}

 			}

         if (token.Compare(_L("-f")) == 0 || token.Compare(_L("-F")) == 0)

             {

             token.Set(lex.NextToken());

             if (token.Length() != 0)

                 {

                 TLex tokenLex;

                 tokenLex.Assign(token);

                 TInt value;

                 tokenLex.Val(value);

                 gZeroPadFileNumberForFixedLengthFileNames = value;

                 }

             else

                 {

                 test.Printf(_L("Bad command syntax"));

                 test(EFalse);

                 }

             }

 		}

 	}

 /* System Info */

 LOCAL_C void GetSystemInfo()

 	{

 	test.Next(_L("Get System Info"));

 	TFSName fsName;

 	TInt drvNo = -1; 

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

 	test(err == KErrNone);

 	err = TheFs.FileSystemSubType(drvNo, fsName);

 	test(err == KErrNone);

 	test.Printf(_L("File System: [%S]\n"), &fsName);

 	TVolumeIOParamInfo ioParam;

 	err = TheFs.VolumeIOParam(drvNo, ioParam);

 	test(err == KErrNone);

 	test.Printf(_L("Sector Size: [%d Bytes]\n"), ioParam.iBlockSize);

 	test.Printf(_L("Cluster Size: [%d Bytes]\n"), ioParam.iClusterSize);

 	}

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

 /**

 Main Function to call specific test features

 */

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

 void CallTestsL()

 	{

 	//Interpreting Command Line Arguments

 	ParseMyCommandArguments(); 

 	// Get Drive Information

 	GetSystemInfo(); 

  	// Switch Case for Test Functions

  	switch(gTestCase)

 		{

 	    //Test Setup

 		case EFATPerfSetup:    

 			{

 			DoTestCaseSetup();

 			break;

 			}

 		//File Create

 		case EFATPerfCreate:

 			{

 			DoTestCaseCreateFile();

 			break;

 			}

 	  	// File Open 

 		case EFATPerfOpen:

 			{

 			DoTestCaseOpenFile();

 			break;

 			}

 		// File Delete

 		case EFATPerfDelete:

 			{

 			DoTestCaseDeleteFile();

 			break;

 			}

 		// File Write

 		case EFATPerfWrite:

 			{

 			DoTestCaseWriteFile();

 			break;

 			}

 		// File Read

 		case EFATPerfRead:

 			{

 			DoTestCaseReadFile();

 			break;

 			}

 		// Print / Dump DirCache Info

 		case EFATPerfDirCacheInfo:

 			{

 			DoTestCaseDirCacheInfo();

 			break;

 			}

 		default:

 			break;

 		}

 	}

 /*-- EOF--*/