/**

 * 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.h

 * Include file for t_fat_perf.cpp (PREQ 1885).

 * 

 *

 */

 //Include Files

 #include <f32file.h>

 #include <e32test.h>

 #include <hal.h>

 #include "t_server.h"

 #include "fat_utils.h"

 #include "f32_test_utils.h" 

 using namespace F32_Test_Utils;

 using namespace Fat_Test_Utils;

 extern TInt gTestCaseNo;

 extern TFileName 	gPath;

 extern TFileName 	gFileNameBase;

 extern TInt 		gFileNo;

 extern TInt		    gTestCase;

 extern TInt			gCacheClear;

 extern TInt         gZeroPadFileNumberForFixedLengthFileNames;

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

 // Interfaces

 // File Operation Modes

 enum TFileOperationMode

 	{

 	EFATPerfFileOpen,

 	EFATPerfFileCreate,

 	EFATPerfFileReplace,

 	EFATPerfFileDelete,

 	EFATPerfFileWrite,

 	EFATPerfFileRead,

 	};

 // File Creation Options

 enum TNamingConOrRan

 	{

 	EConsecutive,

 	ERandom,

 	};

 // Standards

 enum TNamingUniOrAsc

 	{

 	EAscii,

 	EUnicode,

 	};

 // Test function names

 enum TTestFunction

 	{

 	EFATPerfSetup,

 	EFATPerfCreate,

 	EFATPerfOpen,

 	EFATPerfDelete,

 	EFATPerfRead,

 	EFATPerfWrite,

 	EFATPerfDirCacheInfo,

 	};

 // For DirCache info printing 

 // These enum values are based on enum TControlIO defined in \f32\sfat\common_constants.h

 enum TDirCacheControlIOMap

 	{

 	ETestDumpFATDirCache = 15,	///<15

 	ETestFATDirCacheInfo = 16,	///<16

 	};

 // File Naming schemes

 class TNamingSchemeParam

 	{

 public:

     TNamingSchemeParam();

 public:

 	TNamingConOrRan	iConOrRan;

 	TNamingUniOrAsc	iUniOrAsc;

 	TBool iZeroPadFileNumber; // Only applies to consecutive file name generation

 	TFileName 	iFileNameBase;

 	TUint	iMaxFileNameLength;	// Applies only to random name generation

 	TUint	iMinStringLength;

 	};

 class CMeasureAndLogUnit;

 // File Operation Parameters

 struct TFileOpUnitParam

 	{

 	TFileName 	iDirName;

 	TNamingSchemeParam iNamingSchemeParam;

 	TFileOperationMode	iFileOpMode;

 	CMeasureAndLogUnit* iMLUnitPtr;

 	};

 // Directory Unit Parameters

 struct TDirUnitParam

 	{

 	TUint		iPriority;

 	TFileName	iDirName;

 	TUint		iRuns;

 	TUint		iFilesPerRun;

 	TUint		iSampleInterval;

 	TNamingSchemeParam		iNamingScheme;

 	TFileOperationMode		iFileOpMode;

 	};

 struct	TMLUnitParam

 	{

 	TInt	iID;

 	};

 struct TMLParam

 	{

 	TFileName	iDirName;

 	TFileName	iFileName;

 	TNamingSchemeParam iNamingScheme;

 	TUint	iCurFileNo;

 	TFileOperationMode	iFileOpMode;

 	};

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

 // Module definition

 // Measurement and Log Unit

 class CMeasureAndLogUnit : CBase

 	{

 public:

 	static CMeasureAndLogUnit* NewLC(const TMLUnitParam& aParam);

 	static CMeasureAndLogUnit* NewL(const TMLUnitParam& aParam);

 	~CMeasureAndLogUnit();

 	TInt	MeasureStart();

 	TInt	MeasureEnd();

 	TInt	Log(const TFileName& aDirName, const TFileName& aFileName, TUint aCurrentFileNo, TUint aCurrentFilePos);

 private:

 	CMeasureAndLogUnit();

 	void ConstructL(const TMLUnitParam& aParam);

 	TInt	DoMeasureStart();

 	TInt	DoMeasureEnd();

 	TInt	DoLog(const TFileName& aFileName, TUint aCurrentFileNo, TUint aCurrentFilePos);

 private:

 	TInt	iID;

 	TUint32	iStartStatus;

 	TUint32	iEndStatus;

 	TInt	iFreq;

 	TReal	iScale;		

 	TUint	iLogItemNo;

 	};

 // File Operation Unit

 class CFileOperationUnit : CBase

 	{

 public:

 	static CFileOperationUnit* NewLC(const TFileOpUnitParam& aParam);

 	static CFileOperationUnit* NewL(const TFileOpUnitParam& aParam);

 	~CFileOperationUnit();

 	TInt 	Run(const TFileName& aDirName, const TFileName& aFileName, TBool aIsTakingMeasurement, TUint aCurFileNo, TUint aCurFilePos);

 	void	SetMLUnit(CMeasureAndLogUnit* aMLUnit);

 private:

 	CFileOperationUnit();	

 	void ConstructL(const TFileOpUnitParam& aParam);

 private:

 	TFileName 	iDirName;

 	TNamingSchemeParam iNamingSchemeParam;

 	TFileOperationMode	iFileOpMode;

 	CMeasureAndLogUnit* iMLUnitPtr;

 	RFs					iRFs;

 	TBool				iDirCreated;

 	};

 class CDirUnit : public CBase

 	{

 public:

 	static CDirUnit* NewLC(const TDirUnitParam& aParam, const TChar aDriveChar);

 	static CDirUnit* NewL(const TDirUnitParam& aParam, const TChar aDriveChar);

 	~CDirUnit();

 	TInt Run(const TInt aCurPriority);

 	void SetMLUnit(CMeasureAndLogUnit* aMLUnit);

 	TInt Priority();

 	const TFileName& Name();

 private:

 	CDirUnit();

 	void ConstructL(const TDirUnitParam& aParam, const TChar aDriveChar);

 	TInt 	GenerateFileName(TFileName& aFileName); // uses iNameGen

 	TBool 	CheckMeasurementTaking();		     	// uses currentFileNo, 

 												    // totalFileNo, 

 												    // samplingInterval

 	TInt 	DoFileOperation();

 	TFileName GenerateRandomString(const TUint aMinStringLength, const TUint aMaxStringLength, const TNamingUniOrAsc aUniOrAsc);

 	TBool FileNameIsUnique(const TFileName& aFileName);

 private:

 	TInt					iPriority;

 	TFileName				iDirName;

 	TUint					iRuns;

 	TUint					iCurrentRunNo;

 	TUint					iFilesPerRun;

 	TUint					iCurrentFileNo;

 	TUint					iTotalFileNo;

 	TUint					iSampleInterval;

 	TUint                   iNumDigitsInTotalFileNo;    // The number of digits iTotalFileNo has.

                                                         // Used to zero pad the file number if iZeroPadFileNumberForFixedWidthFileNames is ETrue

 	TNamingConOrRan	iConOrRan;                 // Consecutive or random

 	TNamingUniOrAsc	iUniOrAsc;                 // ASCII or Unicode

 	TBool iZeroPadFileNumberForFixedLengthFileNames;

 	TFileName 			iFileNameBase;

 	TUint				iMaxFileNameLength;   // Applies only to random name generation

 	TUint				iMinStringLength;     // Applies only to random name generation

 	CFileOperationUnit* 	iFileOpUnit;

 	CMeasureAndLogUnit*	iMLUnitPtr;

 	};

 //Execution Unit

 class CExecutionUnit : public CBase

 	{

 public:

 	static CExecutionUnit* NewLC(CMeasureAndLogUnit* aMLUnit, const TChar aDriveChar);

 	static CExecutionUnit* NewL(CMeasureAndLogUnit* aMLUnit, const TChar aDriveChar);

 	~CExecutionUnit();

 	TInt 	AddDirUnitL(const TDirUnitParam& aParam);

 	TInt	RecalculateCurrentPrioirty();

 	TInt 	Run();

 	///For Debug

 	TUint ForDebug_AddrOfDirUnit(TUint aDirUnitIter);

 	TUint ForDebug_AddrOfDirUnitArray();

 private:

 	CExecutionUnit();

 	void ConstructL(CMeasureAndLogUnit* aMLUnit, const TChar aDriveChar);

 private:

 	// Array of CDirUnit

 	RPointerArray<CDirUnit>	iDirUnitArray;

 	// Logging Unit

 	CMeasureAndLogUnit*	iMLUnitPtr;	// no ownership

 	// Current priority

 	TInt 	iCurPriority;

 	TChar	iDriveChar;

 	}; 

 /*-- EOF--*/