// 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);
		TEST(timeResultsInfos.Find(EDriveC)!=KErrNotFound);
#if defined(__WINSCW__) 
		TEST(timeResultsInfos.Find(EDriveX)!=KErrNotFound);
#else 
		TEST(timeResultsInfos.Find(EDriveE)!=KErrNotFound);
#endif // __WINSCW__
		timeResultsInfos.Reset();
		
		
	//2.2 Testing rediscovery performance on deleting RSC files on multiple drives
		// Clean up time records on server.
		TRAP(err, timeRecords.ResetRecordsOnServerL());
		TEST(err==KErrNone);
		timeRecords.Reset();
		DeleteRSCFilesOnDrive(EDriveC);
#if defined(__WINSCW__) // C: and X: on emulator
		INFO_PRINTF1(_L("2.2 Testing rediscovery on removing RSC files from drive C: and X:"));
		DeleteRSCFolderOnDrive(EDriveX);
#else // C: and E: on hardware
		INFO_PRINTF1(_L("2.2 Testing rediscovery on removing RSC files from drive C: and E:"));
		DeleteRSCFolderOnDrive(EDriveE);
#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(TimerRunLScanZeroRSCOnOneDriveLimit * 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);
		TEST(timeResultsInfos.Find(EDriveC)!=KErrNotFound);
#if defined(__WINSCW__) 
		TEST(timeResultsInfos.Find(EDriveX)!=KErrNotFound);
#else 
		TEST(timeResultsInfos.Find(EDriveE)!=KErrNotFound);
#endif // __WINSCW__
		timeResultsInfos.Reset();


	//3. MMC Remounting tests on drive E:
	INFO_PRINTF1(_L("3. MMC Remounting tests on drive E:"));
#if defined(__WINSCW__)
	// Tests only run on hardware.
	INFO_PRINTF1(_L("This test can only run on hardware, please see test results of hardware for further information."));
#else
		CopyPluginCR629TestRSCOnDrive(EDriveE, 2);
		User::After(KOneSecond * 3);
		
	//3.1 before remounting: 	has plugins
	//    after remounting: 	has plugins
		INFO_PRINTF1(_L("3.1 Before Remount: has plugins; 	After Remount: has plugins"));
		// Clean up time records on server.
		TRAP(err, timeRecords.ResetRecordsOnServerL());
		TEST(err==KErrNone);
		timeRecords.Reset();
		TEST(fs.RemountDrive(EDriveE)==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 notifications ONLY triggered on E: drive
		TEST(timeResultsInfos.Count()==1);
		TEST(timeResultsInfos[0] == EDriveE);
		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 E: drive
		TEST(timeResultsInfos.Count()==1);
		TEST(timeResultsInfos[0] == EDriveE);
		timeResultsInfos.Reset();

	//3.2 before remounting: 	has plugins
	//    after remounting: 	has no plugins
		INFO_PRINTF1(_L("3.2 Before Remount: has plugins; 	After Remount: has no plugins"));
		// Clean up time records on server.
		TRAP(err, timeRecords.ResetRecordsOnServerL());
		TEST(err==KErrNone);
		timeRecords.Reset();
		DeleteRSCFolderOnDrive(EDriveE);
		TEST(fs.RemountDrive(EDriveE)==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 for E: drive
		TEST(timeResultsInfos.Count()==1);
		TEST(timeResultsInfos[0] == EDriveE);
		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 E: drive
		TEST(timeResultsInfos.Count()==1);
		TEST(timeResultsInfos[0] == EDriveE);
		timeResultsInfos.Reset();

	//3.3 before remounting: 	has no plugins
	//    after remounting: 	has plugins
		INFO_PRINTF1(_L("3.3 Before Remount: has no plugins; 	After Remount: has plugins"));
		// Clean up time records on server.
		TRAP(err, timeRecords.ResetRecordsOnServerL());
		TEST(err==KErrNone);
		timeRecords.Reset();
		CopyPluginCR629TestRSCOnDrive(EDriveE, 2);
		TEST(fs.RemountDrive(EDriveE)==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 for E: drive
		TEST(timeResultsInfos.Count()==1);
		TEST(timeResultsInfos[0] == EDriveE);
		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 E: drive
		TEST(timeResultsInfos.Count()==1);
		TEST(timeResultsInfos[0] == EDriveE);
		timeResultsInfos.Reset();

		DeleteRSCFolderOnDrive(EDriveE);
		User::After(KOneSecond * 3);

	//3.4 before remounting: 	has no plugin
	//    after remounting: 	has no plugin
		INFO_PRINTF1(_L("3.4 Before Remount: has no plugins; 	After Remount: has no plugins"));
		// Clean up time records on server.
		TRAP(err, timeRecords.ResetRecordsOnServerL());
		TEST(err==KErrNone);
		timeRecords.Reset();
		TEST(fs.RemountDrive(EDriveE)==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 for E: drive
		TEST(timeResultsInfos.Count()==1);
		TEST(timeResultsInfos[0] == EDriveE);
		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 NOT performed
		TEST(timeResultsInfos.Count()==0);
		timeResultsInfos.Reset();
		
#endif // __WINSCW__
		
	// Final cleanup
	DeleteRSCFilesOnDrive(EDriveC);
	DeleteRSCFolderOnDrive(EDriveX);
	DeleteRSCFolderOnDrive(EDriveE);
#else
	MacroNotDefinedError();
#endif // __ECOM_SERVER_PERFORMANCE__

	return TestStepResult();
	}