// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Te_EComPluginReDiscoverPerfTest.cpp

// Implements the performance loggr for ECOM

// 

//

/**

 @file

 @internalComponent

*/

#include "Te_EComPluginReDiscoverPerfTestStep.h"

#include <e32test.h>

#include <bautils.h>

#include <startup.hrh>

#include <ecom/ecom.h>

#include "Interface.h"

#include "EcomTestUtils.h"

#ifdef __ECOM_SERVER_PERFORMANCE__

const TInt KOneSecond = 1000000;

const TReal KNotifierRunLTimeLimitH2RAM = 2;					// mSec

const TReal KTimerRunLScanTwoRSCsOnOneDriveLimitH2RAM = 80;	// mSec

const TReal KTimerRunLScanZeroRSCOnOneDriveLimitH2RAM = 40;	// mSec

const TReal KNotifierRunLTimeLimitH4RAM = 1;               // mSec

const TReal KTimerRunLScanTwoRSCsOnOneDriveLimitH4RAM = 40;   // mSec

const TReal KTimerRunLScanZeroRSCOnOneDriveLimitH4RAM = 20;   // mSec 

const TReal KNotifierRunLTimeLimitH4NAND = 6;               // mSec

const TReal KTimerRunLScanTwoRSCsOnOneDriveLimitH4NAND = 50;   // mSec

const TReal KTimerRunLScanZeroRSCOnOneDriveLimitH4NAND = 20;   // mSec 

const TReal KNotifierRunLTimeLimitH6RAM = 1;               // mSec

const TReal KTimerRunLScanTwoRSCsOnOneDriveLimitH6RAM = 20;   // mSec

const TReal KTimerRunLScanZeroRSCOnOneDriveLimitH6RAM = 8;   // mSec 

const TReal KNotifierRunLTimeLimitH6NAND = 4;               // mSec

const TReal KTimerRunLScanTwoRSCsOnOneDriveLimitH6NAND = 25;   // mSec

const TReal KTimerRunLScanZeroRSCOnOneDriveLimitH6NAND = 8;   // mSec 

// The default benchmark checking threshold are defined as zero, for emulator platform.

// The values will be changed for H2 or H4 OR H6 boards.

// See CEComPluginReDiscoverPerfTest::SetBenchmarks()

static TReal NotifierRunLTimeLimit = 0;				

static TReal TimerRunLScanTwoRSCsOnOneDriveLimit = 0;	

static TReal TimerRunLScanZeroRSCOnOneDriveLimit = 0;	

_LIT(KRamOnlyEComCR629Example2RSC,			"Z:\\RAMOnly\\EComCR629Example2.rsc");

_LIT(KEComExample12RSCOnZ,						"Z:\\RAMOnly\\EComExample12.rsc");

_LIT(KEComExample12RSC1OnC,						"C:\\Resource\\Plugins\\EComExample12_1.rsc");

_LIT(KEComExample12RSC2OnC,						"C:\\Resource\\Plugins\\EComExample12_2.rsc");

_LIT(KEComRscDirName,						"\\Resource\\Plugins");

_LIT(KEComCR629RSCFileName,					"\\Resource\\Plugins\\EComCR629Example1_");

_LIT(KEComRSCFileExt,						".rsc");

_LIT(KEComAllRSCFilesName,					"\\Resource\\Plugins\\*.rsc");

#endif //__ECOM_SERVER_PERFORMANCE__

CEComPluginReDiscoverPerfTest::CEComPluginReDiscoverPerfTest() : CEComPerfTestBase(KEComPluginReDiscoverPerfTest)

	{

	}

CEComPluginReDiscoverPerfTest::~CEComPluginReDiscoverPerfTest()

	{

	}

#ifdef __ECOM_SERVER_PERFORMANCE__

/*

	Set different benchmark thresholds for H2 or H4 or H6 boards. 

	Emulator tests will not disable benchmark checking, so don't need to set values for it.

**/

void CEComPluginReDiscoverPerfTest::SetBenchmarksL()

	{

	THardwareConfiguration hardware_configuration = EComTestUtils::GetHardwareConfiguration();

	switch (hardware_configuration)

		{

		case EPlatformH2RAM:

	    	NotifierRunLTimeLimit = KNotifierRunLTimeLimitH2RAM;

			TimerRunLScanTwoRSCsOnOneDriveLimit = KTimerRunLScanTwoRSCsOnOneDriveLimitH2RAM;

			TimerRunLScanZeroRSCOnOneDriveLimit = KTimerRunLScanZeroRSCOnOneDriveLimitH2RAM;

			INFO_PRINTF1(_L("Hardware configuration: H2 RAM"));

			break;

		case EPlatformH2NAND:		

			INFO_PRINTF1(_L("Hardware configuration: H2 NAND"));

			INFO_PRINTF1(_L("***Performance testing on H2 NAND is not supported!***"));

			SetTestStepResult(EFail);			

			break;

		case EPlatformH2NANDDP:

			INFO_PRINTF1(_L("Hardware configuration: H2 NAND DP"));

			INFO_PRINTF1(_L("***Performance testing on H2 NAND DP is not supported!***"));

			SetTestStepResult(EFail);			

			break;

		case EPlatformH4RAM:

			NotifierRunLTimeLimit = KNotifierRunLTimeLimitH4RAM;

			TimerRunLScanTwoRSCsOnOneDriveLimit = KTimerRunLScanTwoRSCsOnOneDriveLimitH4RAM;

			TimerRunLScanZeroRSCOnOneDriveLimit = KTimerRunLScanZeroRSCOnOneDriveLimitH4RAM;

			INFO_PRINTF1(_L("Hardware configuration: H4 RAM"));

			break;

		case EPlatformH4NAND:		

			NotifierRunLTimeLimit = KNotifierRunLTimeLimitH4NAND;

			TimerRunLScanTwoRSCsOnOneDriveLimit = KTimerRunLScanTwoRSCsOnOneDriveLimitH4NAND;

			TimerRunLScanZeroRSCOnOneDriveLimit = KTimerRunLScanZeroRSCOnOneDriveLimitH4NAND;

			INFO_PRINTF1(_L("Hardware configuration: H4 NAND"));

			break;

		case EPlatformH4NANDDP:	

			INFO_PRINTF1(_L("Hardware configuration: H4 NAND DP"));

			break;

		case EPlatformH6RAM:

			NotifierRunLTimeLimit = KNotifierRunLTimeLimitH6RAM;

			TimerRunLScanTwoRSCsOnOneDriveLimit = KTimerRunLScanTwoRSCsOnOneDriveLimitH6RAM;

			TimerRunLScanZeroRSCOnOneDriveLimit = KTimerRunLScanZeroRSCOnOneDriveLimitH6RAM;

			INFO_PRINTF1(_L("Hardware configuration: H6 RAM"));

			break;

		case EPlatformH6NAND:		

			NotifierRunLTimeLimit = KNotifierRunLTimeLimitH6NAND;

			TimerRunLScanTwoRSCsOnOneDriveLimit = KTimerRunLScanTwoRSCsOnOneDriveLimitH6NAND;

			TimerRunLScanZeroRSCOnOneDriveLimit = KTimerRunLScanZeroRSCOnOneDriveLimitH6NAND;

			INFO_PRINTF1(_L("Hardware configuration: H6 NAND"));

			break;

		case EPlatformH6NANDDP:	

			INFO_PRINTF1(_L("Hardware configuration: H6 NAND DP"));

			break;

		case EPlatformWINSCW:

			INFO_PRINTF1(_L("Hardware configuration: WINSCW"));

			break;

		default:		

			SetTestStepResult(EFail);

			INFO_PRINTF1(_L("***Unrecognized platform!***"));

			break;		

		}

	}

TBool CEComPluginReDiscoverPerfTest::CheckTimeResults(TReal aTimeLimit, RArray<TEComPerfRealTimeResult>& aTimeResults)

	{

	TInt count = aTimeResults.Count();

	if(count)

		{

		switch(aTimeResults[0].iType)

			{

			case ECDiscovererNotifierRunL:

				{

				for(TInt idx = 0; idx < count; ++idx)

					{

					TReal elapsedTime = aTimeResults[idx].iEndTime - aTimeResults[idx].iStartTime;

					INFO_PRINTF2(_L("Notifier RunL gets called for drive: %d"), aTimeResults[idx].iInfo);

					CheckPerformance(elapsedTime, aTimeLimit, _L("Notifier RunL"));

					}

				break;

				}

			case ECDiscovererTimerRunL:

				{

				// Check timer runl only ran once

				if(count>1)

					{

					INFO_PRINTF1(_L("Timer RunL ran more than once!\n"));

					return EFalse;

					}

				else

					{

					const TEComPerfRealTimeResult& timeResult = aTimeResults[0];

					TReal elapsedTime = aTimeResults[0].iEndTime - aTimeResults[0].iStartTime;

					CheckPerformance(elapsedTime, aTimeLimit, _L("Timer RunL"));

					}

				break;

				}

			default:

				{

				INFO_PRINTF1(_L("Unrecognizable type for checking performance!\n"));

				return EFalse;

				}

			}

		return ETrue;

		}

	else // No time result retrieved

		{

		INFO_PRINTF1(_L("No time result Retrieved!\n"));

		return EFalse;

		}

	}

void CEComPluginReDiscoverPerfTest::CopyPluginCR629TestRSCOnDrive(TUint aDriveNum, TInt aNumOfCopies)

	{

	if(aNumOfCopies > 0)

		{

		TInt err=KErrNone;

		TDriveUnit aDrive(aDriveNum);

		TBuf<256> resourceFileName;

		for(TInt num = 1; num<= aNumOfCopies; num++ )

			{

			resourceFileName.Zero();

			resourceFileName.Append(aDrive.Name());

			resourceFileName.Append(KEComCR629RSCFileName);

			resourceFileName.AppendNum(num);

			resourceFileName.Append(KEComRSCFileExt);

			TRAP(err, EComTestUtils::FileManCopyFileL(KRamOnlyEComCR629Example2RSC, resourceFileName));

			TEST(err ==KErrNone);

			}

		}

	else

		{

		INFO_PRINTF1(_L("Number of file copies should be greater than 0!\n"));

		}

	}

void CEComPluginReDiscoverPerfTest::DeleteRSCFilesOnDrive(TUint aDriveNum)

	{

	TInt err=KErrNone;

	TDriveUnit aDrive(aDriveNum);

	TBuf<256> resourceFileName;

	resourceFileName.Append(aDrive.Name());

	resourceFileName.Append(KEComAllRSCFilesName);

	TRAP(err, EComTestUtils::FileManDeleteFileL(resourceFileName));

	}

void CEComPluginReDiscoverPerfTest::DeleteRSCFolderOnDrive(TUint aDriveNum)

	{

	TInt err=KErrNone;

	TDriveUnit aDrive(aDriveNum);

	TBuf<256> resourceFileName;

	resourceFileName.Append(aDrive.Name());

	resourceFileName.Append(KEComAllRSCFilesName);

	TRAP(err, EComTestUtils::FileManDeleteFileL(resourceFileName));

	TBuf<256> resourceDirName;

	resourceDirName.Append(aDrive.Name());

	resourceDirName.Append(KEComRscDirName);

	TRAP(err, EComTestUtils::FileManDeleteDirL(resourceDirName));

	}

#endif //__ECOM_SERVER_PERFORMANCE__

/*

	Test cases covered in the test step:

	1. Multiple notification processing on single drive (C:)

		1.1 Rediscovery on adding RSC files

				Performance check on Notifier RunL

				Functionality check on Notifier RunL

				Performance check on Timer RunL

				Functionality check on RediscoveryScanDirectoryL

		1.2 Rediscovery on deleting RSC files

				As above.

		1.3 Rediscovery on adding RSC PlugIn3 files. It does the performance test 

			for parsing new registry data.

				As above.

	2. Multiple notification processing on multiple drives (C: and X: or E:)

		2.1 Rediscovery on adding RSC files

				As above.

		2.2 Rediscovery on deleting RSC filles

				As above.

	3. MMC Remounting tests on drive E:

		3.1 Before: has plugins

			After: 	has plugins

				As above.

		3.2 Before: has plugins

			After: 	has no plugins

				As above.

		3.3 Before: has no plugins

			After: 	has plugins

				As above.

		3.4 Before: has no plugins

			After: 	has no plugins

				As above.

@pre For hardware test, MMC (E:) drive should be available.

@return EPass if the test succeeds and the measured times pass the checks

		EFail otherwise.

 */

TVerdict CEComPluginReDiscoverPerfTest::doTestStepL()

	{

#ifdef __ECOM_SERVER_PERFORMANCE__

	// Set benchmark threshold for different hardware platform, default values are 0s, for emulator.

	SetBenchmarksL();

	//1. Multiple notification processing on single drive (C:)

	INFO_PRINTF1(_L("1. Multiple notification processing on single drive (C:)"));		

	//1.1 Testing rediscovery performance on adding RSC files on C:

		INFO_PRINTF1(_L("1.1 Testing rediscovery on adding RSC files onto drive C:"));

		// Clean up Plugins

		DeleteRSCFilesOnDrive(EDriveC);

		User::After(KOneSecond * 3);

		REComPerfTimeRecords timeRecords;

		// Clean up time records on server.

		TRAPD(err, timeRecords.ResetRecordsOnServerL());

		TEST(err==KErrNone);

		timeRecords.Reset();

		CopyPluginCR629TestRSCOnDrive(EDriveC, 2);

		User::After(KOneSecond * 3);

		// Now get all time records from server

		TRAP(err, timeRecords.OpenL());

		TEST(err==KErrNone);

		TEST(timeRecords.Count() > 0);

		RArray<TEComPerfRealTimeResult> timeResults;

		TRAP(err, timeRecords.RetrieveResultsByTypeL(ECDiscovererNotifierRunL, timeResults));

		TEST(err==KErrNone);

		// Test notifications were triggered and check performance of RunL of Notifiers

		TEST(CheckTimeResults(NotifierRunLTimeLimit, timeResults));

		timeResults.Reset();

		RArray<TInt> timeResultsInfos;

		TRAP(err, timeRecords.RetrieveResultsInfoByTypeL(ECDiscovererNotifierRunL, timeResultsInfos));

		TEST(err==KErrNone);

		// Test notifications ONLY triggered on C: drive

		TEST(timeResultsInfos.Count()==1);

		TEST(timeResultsInfos[0] == EDriveC);

		timeResultsInfos.Reset();

		TRAP(err, timeRecords.RetrieveResultsByTypeL(ECDiscovererTimerRunL, timeResults));

		TEST(err==KErrNone);

		// Test Timer RunL ran only once and check performance.

		TEST(CheckTimeResults(TimerRunLScanTwoRSCsOnOneDriveLimit, timeResults));

		timeResults.Reset();

		TRAP(err, timeRecords.RetrieveResultsInfoByTypeL(ECDiscovererRediscoveryScanDirectoryL, timeResultsInfos));

		TEST(err==KErrNone);

		// Test directory scanning has and ONLY performed on C: drive

		TEST(timeResultsInfos.Count()==1);

		TEST(timeResultsInfos[0] == EDriveC);

		timeResultsInfos.Reset();

	//1.2 Testing rediscovery performance on deleting RSC files

		INFO_PRINTF1(_L("1.2 Testing rediscovery on removing RSC files from drive C:"));

		// Clean up time records on server.

		TRAP(err, timeRecords.ResetRecordsOnServerL());

		TEST(err==KErrNone);

		timeRecords.Reset();

		DeleteRSCFilesOnDrive(EDriveC);

		User::After(KOneSecond * 3);

		// Now get all time records from server.

		TRAP(err, timeRecords.OpenL());

		TEST(err==KErrNone);

		TEST(timeRecords.Count() > 0);

		TRAP(err, timeRecords.RetrieveResultsByTypeL(ECDiscovererNotifierRunL, timeResults));

		TEST(err==KErrNone);

		// Test notifications were triggered and check performance of RunL of Notifiers

		TEST(CheckTimeResults(NotifierRunLTimeLimit, timeResults));

		timeResults.Reset();

		TRAP(err, timeRecords.RetrieveResultsInfoByTypeL(ECDiscovererNotifierRunL, timeResultsInfos));

		TEST(err==KErrNone);

		// Test notifications ONLY triggered on C: drive

		TEST(timeResultsInfos.Count()==1);

		TEST(timeResultsInfos[0] == EDriveC);

		timeResultsInfos.Reset();

		TRAP(err, timeRecords.RetrieveResultsByTypeL(ECDiscovererTimerRunL, timeResults));

		TEST(err==KErrNone);

		// Test Timer RunL ran only once and check performance.

		TEST(CheckTimeResults(TimerRunLScanZeroRSCOnOneDriveLimit, timeResults));

		timeResults.Reset();

		TRAP(err, timeRecords.RetrieveResultsInfoByTypeL(ECDiscovererRediscoveryScanDirectoryL, timeResultsInfos));

		TEST(err==KErrNone);

		// Test directory scanning has and ONLY performed on C: drive

		TEST(timeResultsInfos.Count()==1);

		TEST(timeResultsInfos[0] == EDriveC);

		timeResultsInfos.Reset();

	//1.3 Testing rediscovery performance on adding RSC PLUGIN3 files on C:

		INFO_PRINTF1(_L("1.3 Testing rediscovery on adding RSC PLUGIN3 files onto drive C:"));

		// Clean up Plugins

		DeleteRSCFilesOnDrive(EDriveC);

		User::After(KOneSecond * 3);

		// Clean up time records on server.

		TRAP(err, timeRecords.ResetRecordsOnServerL());

		TEST(err==KErrNone);

		timeRecords.Reset();

		// Adding RSC PLUGIN3 file twice

		TRAP(err, EComTestUtils::FileManCopyFileL(KEComExample12RSCOnZ, KEComExample12RSC1OnC));

		TEST(err==KErrNone);

		TRAP(err, EComTestUtils::FileManCopyFileL(KEComExample12RSCOnZ, KEComExample12RSC2OnC));

		TEST(err==KErrNone);

		User::After(KOneSecond * 3);

		// Now get all time records from server

		TRAP(err, timeRecords.OpenL());

		TEST(err==KErrNone);

		TEST(timeRecords.Count() > 0);

		TRAP(err, timeRecords.RetrieveResultsByTypeL(ECDiscovererNotifierRunL, timeResults));

		TEST(err==KErrNone);

		// Test notifications were triggered and check performance of RunL of Notifiers

		TEST(CheckTimeResults(NotifierRunLTimeLimit, timeResults));

		timeResults.Reset();

		TRAP(err, timeRecords.RetrieveResultsInfoByTypeL(ECDiscovererNotifierRunL, timeResultsInfos));

		TEST(err==KErrNone);

		// Test notifications ONLY triggered on C: drive

		TEST(timeResultsInfos.Count()==1);

		TEST(timeResultsInfos[0] == EDriveC);

		timeResultsInfos.Reset();

		TRAP(err, timeRecords.RetrieveResultsByTypeL(ECDiscovererTimerRunL, timeResults));

		TEST(err==KErrNone);

		// Test Timer RunL ran only once and check performance.

		TEST(CheckTimeResults(TimerRunLScanTwoRSCsOnOneDriveLimit, timeResults));

		timeResults.Reset();

		TRAP(err, timeRecords.RetrieveResultsInfoByTypeL(ECDiscovererRediscoveryScanDirectoryL, timeResultsInfos));

		TEST(err==KErrNone);

		// Test directory scanning has and ONLY performed on C: drive

		TEST(timeResultsInfos.Count()==1);

		TEST(timeResultsInfos[0] == EDriveC);

		timeResultsInfos.Reset();

		// Delete the RSC files

		TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample12RSC1OnC));

		TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample12RSC2OnC));

		User::After(KOneSecond * 3);

	//2. Multiple notification processing on multiple drives (C: and X: or E:)

		RFs fs;

		TEST(fs.Connect()==KErrNone);

	//2.1 Testing rediscovery performance on adding RSC files on multiple drives

		// Clean up time records on server.

		TRAP(err, timeRecords.ResetRecordsOnServerL());

		TEST(err==KErrNone);

		timeRecords.Reset();

		CopyPluginCR629TestRSCOnDrive(EDriveC, 2);

#if defined(__WINSCW__) // C: and X: on emulator

		INFO_PRINTF1(_L("2. Multiple notification processing on multiple drives (C: and X:)"));

		INFO_PRINTF1(_L("2.1 Testing rediscovery on adding RSC files onto drive C: and X:"));

		CopyPluginCR629TestRSCOnDrive(EDriveX, 2);

#else // C: and E: on hardware

		INFO_PRINTF1(_L("2. Multiple notification processing on multiple drives (C: and E:)"));

		INFO_PRINTF1(_L("2.1 Testing rediscovery on adding RSC files onto drive C: and E:"));

		// Check the availability of E: drive and MMC card.

		TDriveList drivelist;

		TEST(fs.DriveList(drivelist)==KErrNone);

		if (!(drivelist[EDriveE]))

			{

			SetTestStepResult(EFail);

			INFO_PRINTF1(_L("*** Drive E: is not available for hardware tests! ***"));

			DeleteRSCFilesOnDrive(EDriveC);

			return TestStepResult();

			}

		TDriveInfo aDriveInfo;

		TEST(fs.Drive(aDriveInfo, EDriveE)==KErrNone);

		if (aDriveInfo.iType != EMediaHardDisk)

			{

			SetTestStepResult(EFail);

			INFO_PRINTF1(_L("*** MMC card is not available for hardware tests! ***"));

			DeleteRSCFilesOnDrive(EDriveC);

			return TestStepResult();

			}		

		// Now copy files

		CopyPluginCR629TestRSCOnDrive(EDriveE, 2);

#endif // __WINSCW__

		User::After(KOneSecond * 3);

		// Now get all time records from server.

		TRAP(err, timeRecords.OpenL());

		TEST(err==KErrNone);

		TEST(timeRecords.Count() > 0);

		TRAP(err, timeRecords.RetrieveResultsByTypeL(ECDiscovererNotifierRunL, timeResults));

		TEST(err==KErrNone);

		// Test notifications were triggered and check performance of RunL of Notifiers

		TEST(CheckTimeResults(NotifierRunLTimeLimit, timeResults));

		timeResults.Reset();

		TRAP(err, timeRecords.RetrieveResultsInfoByTypeL(ECDiscovererNotifierRunL, timeResultsInfos));

		TEST(err==KErrNone);

		// Test notifications ONLY triggered on C: and X: (or E:) drive

		TEST(timeResultsInfos.Count()==2);

		TEST(timeResultsInfos.Find(EDriveC)!=KErrNotFound);

#if defined(__WINSCW__) 

		TEST(timeResultsInfos.Find(EDriveX)!=KErrNotFound);

#else 

		TEST(timeResultsInfos.Find(EDriveE)!=KErrNotFound);

#endif // __WINSCW__

		timeResultsInfos.Reset();

		TRAP(err, timeRecords.RetrieveResultsByTypeL(ECDiscovererTimerRunL, timeResults));

		TEST(err==KErrNone);

		// Test Timer RunL ran only once and check performance.

		TEST(CheckTimeResults(TimerRunLScanTwoRSCsOnOneDriveLimit * 2, timeResults));

		timeResults.Reset();

		TRAP(err, timeRecords.RetrieveResultsInfoByTypeL(ECDiscovererRediscoveryScanDirectoryL, timeResultsInfos));

		TEST(err==KErrNone);

		// Test directory scanning has and ONLY performed on C: and X: (or E:) drive

		TEST(timeResultsInfos.Count()==2);