// Copyright (c) 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_notify_perf.h

// 

//

#include <f32file.h>

#include <f32file_private.h>

#include <e32test.h>

#include <e32svr.h>

#include <hal.h>

#include <e32math.h>

#include <e32std.h>

// File operation made in test path to trigger notifications

enum TNotifyPerfTestOperations

	{

	// File Operations

	EOpEnd,			// indicates that a series of operations ended

	EOpCreate,

	EOpReplace,

	EOpChgAttr,

	EOpRename,

	EOpWrite,

	EOpResize,

	EOpDelete,

	EOpManyChanges,	// Large number changes to a single file 

	EOpManyFiles,	// Small changes to large number of files

	// Directory Operations

	EOpCreateDir,

	EOpRenameDir,

	EOpDeleteDir,

	// Mixed Operations

	EOpMixed		// A series of mixed operations involving both Files and Dirs

	};

enum TTestOptions

	{

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

	// Lowest 4 bit reserved for notification treads ID //

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

	// Test with a lot of filters for enhanced notification - 1st bit

	// set - on; unset - off

	EBigFilter	= 0x0010,

	// Whether perform full directory scan and save the file changes to a list - 2nd bit

	// set - perform; unset - not perform

	EReportChg	= 0x0020, 

	// Whether use big buffer for enhanced notification- 3rd bit

	// Set - big buffer(no overflow); unset - small(could have overflow)

	EBigBuffer	= 0x0040,

	// For multi clients test. Enhanced Notification Only!

	// Mode 1: set a variety of different notifications, same on each clients - 4th bit

	EMultiNoti1	= 0x0080,

	// For multi clients test. Enhanced Notification Only!

	// Mode 2: set a variety of different notifications, in which some are different on each clients, 

	// and some are same on each clients, only support upto 4 clients - 5th bit

	EMultiNoti2	= 0x0100,

	ENotPerfTestReserved6	= 0x0200, 

	ENotPerfTestReserved7	= 0x0400, 

	ENotPerfTestReserved8	= 0x0800, 

	// Notification type - 13th - 16th bits

	ENoNotify	= 0x1000,	// Test without notification

	EEnhanced	= 0x2000,	// Using enhanced notification APIs

	EOriginal	= 0x4000,	// Using original notification APIs

	EPlugin		= 0x8000,	// Using Nokia plug-in for notification

	};

// Note for Plugin Test

// the plugin test can only be run manually because the plugin is not available in KHS code base

// to run the test:

// 1. enable the MACRO above in the mmp

// 2. get a S60 environment

// 3. copy the MdsFileServerPlugin.ptx from the release(\Winscw or \Armv5 depend on what kind of test you want to run) 

//    directory of S60 to the equivalent folder of release directory of your epoc32

// 4. when build a rom, include the MdsFileServerPlugin.ptx file in the rom

// 5. then you can run

enum TMdsFSPOperation

    {

    EMdsFSPOpEnable,

    EMdsFSPOpDisable,

    EMdsFSPOpRegisterNotification,

    EMdsFSPOpAddNotificationPath,

    EMdsFSPOpRemoveNotificationPath,

    EMdsFSPOpAddIgnorePath,

    EMdsFSPOpRemoveIgnorePath,

    EMdsFSPOpNotificationCancel,

    };

class TMdsFSPStatus

    {

public:

    TInt iFileEventType;

    TInt iDriveNumber;

    TFileName iFileName;

    TFileName iNewFileName;

    TUid iProcessId;

    };

enum TMdsFileEventType

    {

    EMdsFileCreated,

    EMdsFileRenamed,

    EMdsFileModified,

    EMdsFileReplaced,

    EMdsFileDeleted,

    EMdsDriveFormatted,

    EMdsFileUnknown,

    EMdsDirRenamed

    };

typedef TPckgBuf<TMdsFSPStatus> TMdsFSPStatusPckg;

const TInt KMdsFSPluginPosition = 0x200071CD;

_LIT(KPluginName, "MdsFileServerPlugin");

// the list of operations to be conducted during a test case

const TUint KDefaultOpList[] = {EOpCreate, EOpReplace, EOpChgAttr, EOpRename, EOpWrite, EOpResize, EOpDelete, EOpEnd};

const TUint KDefaultOpListDir[] = {EOpCreateDir, EOpRenameDir, EOpDeleteDir, EOpEnd};

const TUint KManyChangesOpList[] = {EOpManyChanges, EOpManyChanges, EOpManyChanges, EOpManyChanges, EOpManyChanges, EOpEnd};

const TUint KManyFilesOpList[] = {EOpManyFiles, EOpManyFiles, EOpManyFiles, EOpManyFiles, EOpManyFiles, EOpEnd};

const TUint KMixedOpTestList[] = {EOpMixed, EOpMixed, EOpMixed, EOpMixed, EOpMixed, EOpEnd};

const TUint16 KNotifyOptionMask = 0xF000;

const TUint16 KNotifyTreadIdMask = 0x000F;

// default time scale for timer

const TUint KDefaultTimeScale = 1000; // 1ms

const TInt KMaxHeapSize = 0x1000000;

// used by SafeCheck

const TInt KNoThreadId = -1;

// a Controllor of whether measure time and write loggs;

extern TBool gPerfMeasure;

extern TFileName gTestPath;

extern TFileName gLogFilePath;

// Threads handles

extern RArray<RThread> gNotiThreads;

extern RThread gFileThread;

extern TBuf<50> gLogPostFix;

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

class CTimerLogger;

// a wrapper for test settings

class TTestSetting

	{

public:

	TTestSetting();

	TTestSetting(TInt aNumFiles, TInt aNumCli, TUint16 aOpt, const TUint* aOpList);

	inline void Reset();

public:

	TInt iNumFiles;

	TInt iNumCli;

	TUint16 iOption;

	const TUint* iOperationList;

	};

// a wrapper of parameters for the main thread to pass into notification thread or file operation thread

struct TThreadParam

	{

	TTestSetting iSetting;

	RSemaphore* iSmphFT;	// Semophore used by File Thread for waiting for signals from Notification Threads

	RSemaphore* iSmphNT;	// Semophore used by Notification Threads for waiting for signals from File Thread

	CTimerLogger* iLogger;	// Logger used by Notification Threads;

	RPointerArray<CTimerLogger>* iLoggerArray;	// a pointer to an array of pointers to CTimmerLoggger

	};

// This is the controller of the plugin, it's a simplified copy of the plugin engine used in S60 internally

class CMdsPluginControl : public RPlugin

    {   

public:

    inline void RegisterNotification( TMdsFSPStatusPckg& aMdsFSPStatus, TRequestStatus& aStat);

    inline void AddNotificationPath( const TDesC& aPath );

    inline void RemoveNotificationPath( const TDesC& aPath );

    inline TInt Enable();

    inline TInt Disable();

    inline void NotificationCancel();

    };

// timer class, also responsible for writing logs

class CTimerLogger : public CBase

	{

public:	

	static CTimerLogger* NewL(const TFileName& aLogFile);

	~CTimerLogger();

	inline TInt MeasureStart();

	inline TInt MeasureEnd();

	inline TBool Timing();

	TInt Log(const TDesC& aDes, TBool aIsLine = ETrue);

	TInt LogAndPrint(const TDesC& aDes, TBool aIsLine = ETrue);

	TInt LogSettingDescription(const TInt aNumFile, const TInt aNumCli, const TUint16 aOption, TBool aNumOpVaries = EFalse);

	TInt LogTestStepTime(TUint aOp, TInt aNum);

private:

	CTimerLogger();

	void ConstructL(const TFileName& aLogFile);

private:

	TBool iTiming;

	TUint32 iTickNumber;

	TUint iTimeScale;

	TInt iTickPeriod;

	TFileName iLogFile;

	RFs iFs;

	};

// the conductor of test cases

class CTestExecutor : public CBase

	{

public:

	CTestExecutor(TTestSetting& aSetting);

	~CTestExecutor();

	inline void SetTestSetting(TTestSetting& aSetting);

	inline void LogDescription();

	void RunTestCaseL();

	static void KillAllTestThreads();

private:

	TTestSetting iTestSetting;

	};

// This class performs file operations

class CFileOperator : public CBase

	{

public:	

	CFileOperator(const TTestSetting& aSetting, RPointerArray<CTimerLogger>& aLoggerArray, RSemaphore* aSmphFT, RSemaphore* aSmphNT);

	~CFileOperator();

	void DoChangesL();

private:

	void DoCreateL();

	void DoReplaceL();

	void DoChangeAttL();

	void DoRenameL();

	void DoWriteL();

	void DoResizeL();

	void DoDeleteL();

	void DoCreateDirL();

	void DoRenameDirL();

	void DoDeleteDirL();

	void DoMixedOperationsL();

	void DoManyChangesOnSingleFileL();

	void DoSmallChangesOnManyFilesL();

	void MesureStartsAll();

	void WaitForSignalsAll();

	void TestStepPrepare(TUint aOp);

	void TestStepFinish(TUint aOp);

private:

	// test case will use the number iFirstFile and iNumFiles to generate test file names.

	// For example: 

	// if iFirstFile = 0 and iNumFiles = 100, the test files will be 0000.tst, 0001.tst ... 0099.tst

	// if iFirstFile = 21 and iNumFiles = 200, the test files will be 0021.tst, 0022.tst ... 0220.tst

	//

	// When doing rename or replace test, the new names for test will be the biggest existing file 

	// number + 1 to the number + iNumFiles.

	// As a result, in the case of if iFirstFile = 0 and iNumFiles = 100:

	// The exsting files should be 0000.tst ... 0099.tst

	// Rename or Replace test will use the new names 0100.tst ... 0199.tst to replace or rename the

	// existing files.

	TInt iFirstFile;

	// Number of files for operating.

	// Note: in "Large number changes to a single file" case, this indicates the number of changes made on the single file.

	TInt iNumFiles;

	TInt iNumCli;

	TUint16 iOption;

	const TUint* iCurrentOp;

	RPointerArray<CTimerLogger> iLoggers;

	RSemaphore* iSmphS;		// Use for signaling Notification threads

	RSemaphore* iSmphW;		// Use for waiting signal from Notification threads

	RFs iFs;

	};

// an operator to monitor notification watcher and test stopper

class CNotifyOperator : public CBase

	{

public:

	CNotifyOperator(const TTestSetting& aSetting, RSemaphore* aSmphFT, RSemaphore* aSmphNT, CTimerLogger* aLogger);

	~CNotifyOperator();

	void StartOperationL();

private:

	void LogNotificationNumbers(TInt aNumNoti, TInt aNumIter, TInt aNumOverflow);

	void LogTestResult(TInt aCounter, TInt aMeanCounter, TInt aOFCounter);

	void TestChangeReport(TInt aNumChanges);

private:

	TInt iNumFiles;

	TUint16 iOption;

	const TUint* iCurrentOp;

	CTimerLogger* iLogger;

	RSemaphore* iSmphS;	// Use for signaling file operation thread

	RSemaphore* iSmphW;	// Use for waiting signal from file operation thread

	};

// this class is responsible for handling notifications

class CNotifyWatcher : public CActive

	{

friend class CNotifyOperator;

public:

	static CNotifyWatcher* NewL(TInt aNumFiles, TUint16 aOption, TUint aCurrentOp, CTimerLogger* aLogger);

	~CNotifyWatcher();

	void DoCancel();

	void RunL();

	void RequestNotification();

	void Reset(TUint aOp);

private:

	CNotifyWatcher(TInt aNumFiles, TUint16 aOption, TUint aCurrentOp, CTimerLogger* aLogger);

	void ConstructL();

	void FullDirectoryScanL(RArray<TEntry>& aArray);

	void MakeChangeRecordL(RArray<TEntry>& aArray);

	TBool CompareEntry(const TEntry& aEntry1, const TEntry& aEntry2);

	void AddLotsOfFilters();

	void RequestNotificationEnhanced();

	void RequestNotificationOriginal();

	void HandleNotification(TBool aLastTime);

	void HandleNotificationEnhanced(TBool aLastTime);

	void HandleNotificationOriginal(TBool aLastTime);

	void ResetMdsFSPStatus();

	void RequestNotificationPlugin();

	void HandleNotificationPlugin(TBool aLastTime);

private:

	TInt iCounter;

	TInt iMeanCounter;

	TInt iOverflowCounter;

	TUint iCurrentOp;

	TInt iNumFiles;

	TUint16 iOption;

	RArray<TEntry> iEntries;

	RArray<TFileName> iRecords;	// this is the output we produce

	CTimerLogger* iLogger;

	CFsNotify* iNotify;

	TMdsFSPStatusPckg iPluginStatusPkg;

    CMdsPluginControl iPlugin;	

	RFs iFs;

	};

// An AO aims for stopping the Active Scheduler when test finish

class CTestStopper : public CActive

	{

public:

	CTestStopper();

	~CTestStopper();

	void DoCancel();

	void RunL();

	void StartWaitingForFile();

private:

	TFileName iTestEndFile;

	RFs iFs;

	};

#include "t_notify_perf.inl"