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

// 

//

#include "t_notify_perf.h"

#include "t_server.h"

extern void FileNameGen(TFileName& aName, TInt aNum, TBool aIsFile = ETrue);

extern TInt FileOperationThread(TAny* aSetting);

extern TInt NotificationOperationThread(TAny* aSetting);

extern TInt KillerThread(TAny*);

extern TUint OpNotifyMapping(TUint16& aOption, TInt aOperation);

extern TBool CompareEntryName(const TEntry& aEntry1, const TEntry& aEntry2);

extern void SafeTestL(TBool aResult, TInt aId, TInt aLine, TText* aFile);

extern void SafeTestL(TInt aResult, TInt aExpected, TInt aId, TInt aLine, TText* aFile);

const TInt KNotificationHeaderSize = (sizeof(TUint16)*2)+(sizeof(TUint));

const TInt KMinNotificationBufferSize = 2*KNotificationHeaderSize + 2*KMaxFileName;

TBool gPerfMeasure;

TFileName gTestPath;

TFileName gLogFilePath;

RArray<RThread> gNotiThreads;

RThread gFileThread;

TBuf<50> gLogPostFix;

// Prints out the filename

#define ExpandMe(X)  L ## X

#define Expand(X)    ExpandMe(X)

// Safe test, so that sub-threads are not hanging after check fail

#define SAFETEST0(a) SafeTestL(a,KNoThreadId,__LINE__,(TText*)Expand("t_notify_perf_impl.cpp"))

#define SAFETEST1(a,b) SafeTestL(a,b,__LINE__,(TText*)Expand("t_notify_perf_impl.cpp"))

#define SAFETEST2(a,b,c) SafeTestL(a,b,c,__LINE__,(TText*)Expand("t_notify_perf_impl.cpp"))

TTestSetting::TTestSetting()

: iNumFiles(0), iNumCli(0), iOption(0), iOperationList(NULL)

	{

	}

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

: iNumFiles(aNumFiles), iNumCli(aNumCli), iOption(aOpt), iOperationList(aOpList)

	{

	}

//===========================================================

CTimerLogger* CTimerLogger::NewL(const TFileName& aLogFile)

	{

	CTimerLogger* self = new(ELeave) CTimerLogger();

	CleanupStack::PushL(self);

	self->ConstructL(aLogFile);

	CleanupStack::Pop(self);

	return self;

	}

void CTimerLogger::ConstructL(const TFileName& aLogFile)

	{

	User::LeaveIfError(HAL::Get(HALData::ENanoTickPeriod, iTickPeriod));

	iLogFile.Copy(aLogFile);

	}

CTimerLogger::CTimerLogger()

:  iTiming(EFalse), iTickNumber(0), iTimeScale(KDefaultTimeScale)

	{

	iFs.Connect();

	}

CTimerLogger::~CTimerLogger()

	{

	iFs.Close();

	}

// Write Logs

TInt CTimerLogger::Log(const TDesC& aDes, TBool aIsLine)

	{

	RFile file;

	iFs.Connect();

	TInt err = file.Open(iFs,iLogFile,EFileShareExclusive|EFileWrite);

	SAFETEST0(err == KErrNone || err == KErrNotFound || err == KErrPathNotFound);

	if (err != KErrNone)

		{

		err = iFs.MkDirAll(iLogFile);

		SAFETEST0(err == KErrNone || err == KErrAlreadyExists);

		err = file.Create(iFs,iLogFile,EFileShareExclusive|EFileWrite);

		SAFETEST0(err == KErrNone);

		}

	TBuf8<240> data;

	data.Copy(aDes);

	if (aIsLine)

		{

		data.Append(_L8("\r\n"));

		}

	TInt offset = 0;

	err = file.Seek(ESeekEnd, offset);

	SAFETEST0(err == KErrNone);

	err = file.Write(data);

	SAFETEST0(err == KErrNone);

	file.Close();

	iFs.Close();

	return err;

	}

// Write Logs and also print the line written in the console

TInt CTimerLogger::LogAndPrint(const TDesC& aDes, TBool aIsLine)

	{

	TInt err = KErrNone;

	RDebug::Print(aDes);

	if (gPerfMeasure)

	    err = Log(aDes, aIsLine);

	return err;

	}

// Write and print the time result

TInt CTimerLogger::LogTestStepTime(TUint aOp, TInt aNum)

	{

	if (iTiming)

		return KErrGeneral;

	TBuf<100> buf;

	switch (aOp)

		{

		case EOpCreate:

			buf.Append(_L("Create - "));

			break;

		case EOpReplace:

			buf.Append(_L("Replace - "));

			break;

		case EOpChgAttr:

			buf.Append(_L("Change Attribute - "));

			break;

		case EOpRename:

			buf.Append(_L("Rename - "));

			break;

		case EOpWrite:

			buf.Append(_L("Write - "));

			break;

		case EOpResize:

			buf.Append(_L("Resize - "));

			break;

		case EOpDelete:

			buf.Append(_L("Delete - "));

			break;

		case EOpManyChanges:

			buf.AppendFormat(_L("%d Changes on Single File - "), aNum);

			break;

		case EOpManyFiles:

			buf.AppendFormat(_L("Small Changes on %d Files - "), aNum);

			break;

		case EOpCreateDir:

			buf.Append(_L("Create(dir) - "));

			break;

		case EOpRenameDir:

			buf.Append(_L("Rename(dir) - "));

			break;

		case EOpDeleteDir:

			buf.Append(_L("Delete(dir) - "));

			break;

		case EOpMixed:

			buf.AppendFormat(_L("%d Mixed Operations - "), aNum*18);

		default:

			break;

		}

	TReal time = (static_cast<TReal>(iTickNumber) * iTickPeriod) / iTimeScale;

	buf.AppendFormat(_L("time: %d ms"), static_cast<TInt>(time));

	return LogAndPrint(buf);

	}

// write and print the test case discription

TInt CTimerLogger::LogSettingDescription(const TInt aNumFile, const TInt aNumCli, const TUint16 aOption, TBool aNumOpVaries)

	{	

	LogAndPrint(_L("===================================================="));

	TBuf<120> buf;

	buf.Append(_L("Test: "));

	if (!aNumOpVaries)

		{

		buf.AppendFormat(_L("%d files/directories, %d Clients, "), aNumFile, aNumCli);

		}

	// Notification Type

	switch(aOption & KNotifyOptionMask)

		{		

		case ENoNotify:

			buf.Append(_L("No Notification"));

			break;

		case EEnhanced:

			buf.Append(_L("Enhanced"));

			break;

		case EOriginal:

			buf.Append(_L("Original"));

			break;

		case EPlugin:

			buf.Append(_L("Nokia Plug-in"));

			break;

		default:

			return KErrArgument;

		}

	if (aOption & EBigFilter)

		{

		buf.Append(_L(", 100 Filters"));

		}

	if (aOption & EReportChg)

		{

		buf.Append(_L(", Change Reporting"));

		}

	else

		{

		buf.Append(_L(", Not Report Changes"));

		}

	if (aOption & EEnhanced)

		{

		if (aOption & EBigBuffer)

			{

			buf.Append(_L(", Big Buffer"));

			} 

		else

			{

			buf.Append(_L(", Small Buffer"));

			}

		if (aOption & EMultiNoti1)

			{

			buf.Append(_L(", Multi Notification Mode 1"));

			}

		else if (aOption & EMultiNoti2)

			{

			buf.Append(_L(", Multi Notification Mode 2"));

			}

		}

	LogAndPrint(buf);

	LogAndPrint(_L("----------------------------------------------------"));

	return KErrNone;

	}

//===========================================================

CTestExecutor::CTestExecutor(TTestSetting& aSetting)

: iTestSetting(aSetting)

	{

	}

CTestExecutor::~CTestExecutor()

	{

	}

void CTestExecutor::KillAllTestThreads()

    {

    RThread killer;

    killer.Create(_L("KillerThread"), KillerThread, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, NULL); 

    killer.Resume();

    TRequestStatus status;

    killer.Logon(status);

    User::WaitForRequest(status);

    TInt err = killer.ExitReason();

    test(err == KErrNone);

    }

// start run a test case

void CTestExecutor::RunTestCaseL()

	{

	RSemaphore smphF;

	smphF.CreateLocal(0);

	RSemaphore smphN;

	smphN.CreateLocal(0);

	RArray<RThread> notiThreads; // list of handles of notification threads

	RPointerArray<CTimerLogger> loggerList;

	TUint16 count = 0;

	TUint16 option = iTestSetting.iOption;

	while (count < iTestSetting.iNumCli)

		{

		test(count < 16);

		iTestSetting.iOption = (TUint16)(option + count); // Put Thread ID in option

		TThreadParam param;

		param.iSetting = iTestSetting;

		param.iSmphFT = &smphF;

		param.iSmphNT = &smphN;

		TFileName logName;

		logName.FillZ();

		if (gPerfMeasure)

		    {

            logName.Append(gLogFilePath);

            if (iTestSetting.iNumCli == 1)

                logName.Append(_L("SingleClient"));

            else

                logName.AppendFormat(_L("MultiClient%02d"), count);

            logName.Append(gLogPostFix);

		    }

		CTimerLogger* logger = CTimerLogger::NewL(logName);

		CleanupStack::PushL(logger);

		param.iLogger = logger;

		param.iLoggerArray = NULL;

		TUint operation = *iTestSetting.iOperationList;

		TBool numFilesVaries = EFalse; 

		if (operation == EOpManyFiles || operation == EOpManyChanges || operation == EOpMixed)

			{

			numFilesVaries = ETrue;

			}

		logger->LogSettingDescription(iTestSetting.iNumFiles, iTestSetting.iNumCli, iTestSetting.iOption, numFilesVaries);

		loggerList.AppendL(logger);

		TBuf<20> threadName;

		threadName.AppendFormat(_L("NotificationThread%02d"), count);

		RThread notifyOp;

		notifyOp.Create(threadName, NotificationOperationThread, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &param);

		notiThreads.AppendL(notifyOp);

		notifyOp.Resume();

		smphF.Wait();	// Wait for the parameters being properly passed

		CleanupStack::Pop(logger);

		count++;

		}

	gNotiThreads = notiThreads;

	if (iTestSetting.iNumCli == 0)	// no notification

		{

		TFileName logName;

		logName.Append(gLogFilePath);

		logName.Append(_L("SingleClient"));

		logName.Append(gLogPostFix);

		CTimerLogger* logger = CTimerLogger::NewL(logName);

		CleanupStack::PushL(logger);

		logger->LogSettingDescription(iTestSetting.iNumFiles, iTestSetting.iNumCli, iTestSetting.iOption);

		loggerList.AppendL(logger);

		CleanupStack::Pop(logger);

		}

	TThreadParam paramFileOp;

	paramFileOp.iSetting = iTestSetting;

	paramFileOp.iSmphFT = &smphF;

	paramFileOp.iSmphNT = &smphN;

	paramFileOp.iLogger = NULL;

	paramFileOp.iLoggerArray = &loggerList;

	RThread fileOp;

	fileOp.Create(_L("FileOperationThread"), FileOperationThread, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &paramFileOp);	

	gFileThread = fileOp;

	fileOp.Resume();

	TInt err;

	TRequestStatus status;

	fileOp.Logon(status);

	User::WaitForRequest(status);

	err = fileOp.ExitReason();

	test(err == KErrNone);

	count = 0;

	while(count < notiThreads.Count())

		{

		notiThreads[count].Logon(status);

		User::WaitForRequest(status);

		err = notiThreads[count].ExitReason();

		test(err == KErrNone);

		count++;

		}

	CLOSE_AND_WAIT(fileOp);

	count = 0;

	while(count < notiThreads.Count())

		{

		RThread thread = notiThreads[count];

		CLOSE_AND_WAIT(thread);

		count++;

		}

	for (TInt i = 0; i < loggerList.Count(); i++)

		{

		loggerList[i]->LogAndPrint(_L("===================================================="));

		}

	smphN.Close();

	smphF.Close();

	loggerList.ResetAndDestroy();

	loggerList.Close();

	notiThreads.Reset();

	notiThreads.Close();

	}

//===========================================================

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

: iFirstFile(0)

	{

	iNumFiles = aSetting.iNumFiles;

	iOption = aSetting.iOption;

	iCurrentOp = aSetting.iOperationList;

	iNumCli = aSetting.iNumCli;

	iLoggers = aLoggerArray; 

	iSmphS = aSmphNT;

	iSmphW = aSmphFT;

	iFs.Connect();

	}

CFileOperator::~CFileOperator()

	{

	iFs.Close();

	}

// starts measuring for all the notification thread

// the loggers in iLogger are shared by Notification thread

void CFileOperator::MesureStartsAll()

	{

	TInt i = 0;

	while (i < iNumCli)

		{

		iLoggers[i]->MeasureStart();

		i++;

		}

	}

// Wait for all notification threads to signal

void CFileOperator::WaitForSignalsAll()

	{

	TInt i = 0;

	while (i < iNumCli)

		{

		iSmphW->Wait();

		i++;

		}

	}

// prepare each test step

void CFileOperator::TestStepPrepare(TUint aOp)

	{

	RDebug::Print(_L("Preparing for the next test step..."));

	switch (aOp)

		{

		case EOpReplace:

			{

			User::After(1500000); // Wait for 1.5 sec so that the new files have different modified time

			RFile file;

			TInt count = iFirstFile + iNumFiles;

			while (count < (iFirstFile + (iNumFiles * 2)))

				{

				TFileName nextFile;

				FileNameGen(nextFile, count);

				file.Create(iFs, nextFile, EFileRead);

				file.Close();

				count++;

				}

			break;

			}

		case EOpManyChanges:

			{

			RFile file;

			TFileName nextFile;

			FileNameGen(nextFile, 9999);

			file.Create(iFs, nextFile, EFileRead);

			file.Close();

			break;

			}

		case EOpManyFiles:

			{

			CDir* list;

			iFs.GetDir(gTestPath, KEntryAttMaskSupported, ESortNone, list);

			TInt count = list->Count();

			delete list;

			RFile file;

			for (TInt i = 0; i < iNumFiles - count; i++)

				{

				TFileName nextFile;

				FileNameGen(nextFile, count + i);

				file.Create(iFs, nextFile, EFileRead);

				file.Close();

				}

			break;

			}

		// No preparation for other operations

		default:

			break;

		}

	RDebug::Print(_L("Preparation done..."));

	}

// Finish each test step, do some clearing or test setting modification