diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/TestExecute/EComPerfTest/src/Te_EComPluginReDiscoverPerfTestStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/TestExecute/EComPerfTest/src/Te_EComPluginReDiscoverPerfTestStep.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,782 @@ +// 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 +#include +#include +#include +#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& 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 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 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(); + }