// Copyright (c) 2005-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_EComPerfTestStep.cpp

// Implements the performance loggr for ECOM

// 

//

/**

 @file

 @internalComponent

*/

#include "Te_EComStartupStatePerfTestStep.h"

#include <e32test.h>

#include <f32file.h>

#include <bautils.h>

#include <startup.hrh>

#include <ecom/ecom.h>

#include "Interface.h"

#include "EcomTestUtils.h"

#ifdef __ECOM_SERVER_PERFORMANCE__

// Start-up urel/armv5 test limits for CS and NC are calculated using the number of DLL's added to the

// registry for Ro Internal Drives and Non RO Internal Drives respectively.

// The test limit formula used for the upper limit is:

// 50mS+(1.75mS*number of DLLs discovered) for H2 builds 

// 15mS+(1mS*number of DLLs discovered) for H4 RAM (non-NAND) builds

// 125mS+(1.5mS*number of DLLs discovered) for H4 NAND builds 

// 5mS+(1mS*number of DLLs discovered) for H6 RAM (non-NAND) builds  

// 40mS+(1.5mS*number of DLLs discovered) for H6 NAND builds   

// These figures were determined using benchmarks from the ONB&TR.

// Although these limits are passed to CheckPerformance() for non urel/armv5 testing this method

// does not test against them. It is disabled.

const TReal KStartupLimitBaseH2RAM = 50;

const TReal KStartupLimitMultiplierH2RAM = 2.05;

const TReal KStartupLimitBaseH4RAM = 25;

const TReal KStartupLimitMultiplierH4RAM = 1;

const TReal KStartupLimitBaseH6RAM = 5;

const TReal KStartupLimitMultiplierH6RAM = 0.5;

const TReal KStartupLimitBaseH4NAND = 140;

const TReal KStartupLimitMultiplierH4NAND = 1.5;

const TReal KStartupLimitBaseH6NAND = 40;

const TReal KStartupLimitMultiplierH6NAND = 1;

// There is no discovery at CD therefore limit is fixed.

const TReal KCriticalDynamicLimitH2RAM = 10;

const TReal KCriticalDynamicLimitH4RAM = 2;

const TReal KCriticalDynamicLimitH4NAND = 5;

const TReal KCriticalDynamicLimitH6RAM = 1;

const TReal KCriticalDynamicLimitH6NAND = 2.5;

// Initialisation limit is independant of DLL count and is also fixed

const TReal KInitialisationLimitH2RAM = 50;

const TReal KInitialisationLimitH4RAM = 25;

const TReal KInitialisationLimitH4NAND = 25;

const TReal KInitialisationLimitH6RAM = 5;

const TReal KInitialisationLimitH6NAND = 5;

#endif //__ECOM_SERVER_PERFORMANCE__

CEComStartupStatePerfTest::CEComStartupStatePerfTest() : CEComPerfTestBase(KEComStartupStatePerfTest)

/**

 * Constructor

 */

	{

	// does nothing here.

	}

CEComStartupStatePerfTest::~CEComStartupStatePerfTest()

/**

 * Destructor

 */

	{

	// does nothing here.

	}

#ifdef __ECOM_SERVER_PERFORMANCE__

void CEComStartupStatePerfTest::RetrieveRegistryCountL(

		RegistryCounts::TRegistryCounts::TRegistryCountDriveType aDriveType,

		RegistryCounts::TRegistryCounts& aCounts,

		TPtrC aMessage)

	{

	RegistryCounts::GetRegistryCountsL(aDriveType, aCounts);

	INFO_PRINTF3(_L("Drive count for %S: [%d]"), &aMessage, aCounts.iDrives);

	INFO_PRINTF3(_L("DLL count for %S: [%d]"), &aMessage, aCounts.iDlls);

	INFO_PRINTF3(_L("Interface count for %S: [%d]"), &aMessage, aCounts.iInterfaces);

	INFO_PRINTF3(_L("Implementation count for %S: [%d]\n"), &aMessage, aCounts.iImplementations);

	}

TVerdict CEComStartupStatePerfTest::ProcessState(RStartupStateTimerResults& aTimerResults, 

		TInt aTimerState, 

		TReal& aStateStartTime, 

		TReal& aStateComplTime)

	{

	TInt idx = aTimerResults.FindInOrderTimerResult(aTimerState);

	if(idx == KErrNotFound)

	 	{

 		INFO_PRINTF1(_L("Something went wrong......whoops\n"));

	 	SetTestStepResult(EFail);

	 	return EFail;

	 	}

	const TStartupStateTimerResult& timerResult = aTimerResults.At(idx);

	aStateStartTime = timerResult.iStartTime;

	aStateComplTime = timerResult.iEndTime;

	INFO_PRINTF3(_L("State: %d elapsed time: %f mSecs\n"), aTimerState, aStateComplTime - aStateStartTime);

	return EPass;

	}

TVerdict CEComStartupStatePerfTest::ProcessState(REComHeapUsageRecords& aHeapResults, TInt aState,TInt& aHeapUsage)

	{

	TInt heap=aHeapResults.GetHeapUsageAtState(aState);

	if (heap==KErrNotFound)

		{

 		INFO_PRINTF1(_L("Something went wrong......whoops\n"));

	 	SetTestStepResult(EFail);

	 	return EFail;		

		}

	aHeapUsage=heap;

	INFO_PRINTF3(_L("State: %d heap usage: %d bytes\n"), aState,aHeapUsage);	

	return EPass;

	}

#endif //__ECOM_SERVER_PERFORMANCE__

/*

 Retrieves startup state timing from the ECom server and tests that the time spent during the different startup states is within a set of maximum bounds

 @return EPass if the test succeeds and the measured times are within the maximumum, EFail otherwise

 */

TVerdict CEComStartupStatePerfTest::doTestStepL()

	{

#ifdef __ECOM_SERVER_PERFORMANCE__

	// get the registry counts from the server

	// the DLL count is used to set the test limits for the startup tests

	INFO_PRINTF1(_L("RO Internal Registry Counts"));

	RegistryCounts::TRegistryCounts roIntCounts;

	RetrieveRegistryCountL(RegistryCounts::TRegistryCounts::ERoInternal, roIntCounts, _L("RO internal drives"));

	INFO_PRINTF1(_L("Non RO Internal Registry Counts"));

	RegistryCounts::TRegistryCounts nonRoIntCounts;

	RetrieveRegistryCountL(RegistryCounts::TRegistryCounts::ENonRoInternal, nonRoIntCounts, _L("Non RO internal drives"));

	INFO_PRINTF1(_L("All Registry Counts"));

	RegistryCounts::TRegistryCounts allCounts;

	RetrieveRegistryCountL(RegistryCounts::TRegistryCounts::EAll, allCounts, _L("All drives"));

	//set configuration-dependent timing limits

	TReal CriticalStaticLimit = 0;

	TReal NonCriticalLimit = 0;

	TReal CriticalDynamicLimit = 0;

	TReal InitialisationLimit = 0;

	THardwareConfiguration hardware_configuration = EComTestUtils::GetHardwareConfiguration();

	switch (hardware_configuration)

		{

		case EPlatformH2RAM:

	    	CriticalStaticLimit = KStartupLimitBaseH2RAM + (KStartupLimitMultiplierH2RAM * roIntCounts.iDlls);

			NonCriticalLimit = KStartupLimitBaseH2RAM + (KStartupLimitMultiplierH2RAM * nonRoIntCounts.iDlls);

			CriticalDynamicLimit = KCriticalDynamicLimitH2RAM;

			InitialisationLimit = KInitialisationLimitH2RAM;

			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:

			CriticalStaticLimit = KStartupLimitBaseH4RAM + (KStartupLimitMultiplierH4RAM * roIntCounts.iDlls);

			NonCriticalLimit = KStartupLimitBaseH4RAM + (KStartupLimitMultiplierH4RAM * nonRoIntCounts.iDlls);

			CriticalDynamicLimit = KCriticalDynamicLimitH4RAM;

			InitialisationLimit = KInitialisationLimitH4RAM;

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

			break;

		case EPlatformH4NAND:		

			CriticalStaticLimit = KStartupLimitBaseH4NAND + (KStartupLimitMultiplierH4NAND * roIntCounts.iDlls);

			NonCriticalLimit = KStartupLimitBaseH4NAND + (KStartupLimitMultiplierH4NAND * nonRoIntCounts.iDlls);

			CriticalDynamicLimit = KCriticalDynamicLimitH4NAND;

			InitialisationLimit = KInitialisationLimitH4NAND;

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

			break;

		case EPlatformH4NANDDP:	

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

			break;

		case EPlatformH6RAM:

			CriticalStaticLimit = KStartupLimitBaseH6RAM + (KStartupLimitMultiplierH6RAM * roIntCounts.iDlls);

			NonCriticalLimit = KStartupLimitBaseH6RAM + (KStartupLimitMultiplierH6RAM * nonRoIntCounts.iDlls);

			CriticalDynamicLimit = KCriticalDynamicLimitH6RAM;

			InitialisationLimit = KInitialisationLimitH6RAM;

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

			break;

		case EPlatformH6NAND:		

			CriticalStaticLimit = KStartupLimitBaseH6NAND + (KStartupLimitMultiplierH6NAND * roIntCounts.iDlls);

			NonCriticalLimit = KStartupLimitBaseH6NAND + (KStartupLimitMultiplierH6NAND * nonRoIntCounts.iDlls);

			CriticalDynamicLimit = KCriticalDynamicLimitH6NAND;

			InitialisationLimit = KInitialisationLimitH6NAND;

			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;		

		}

	// get all the timer results from the server

	RStartupStateTimerResults timerResults;

	timerResults.GetAllTimerResults();

	// Get ecom start time and state. The state is a test state and should be -1 

	TInt idx = timerResults.FindInOrderTimerResult(-1);

	if(idx == KErrNotFound)

	 	{

 		INFO_PRINTF1(_L("Something went wrong......whoops\n"));

	 	SetTestStepResult(EFail);

	 	return TestStepResult();

	 	}

	TStartupStateTimerResult timerResult = timerResults.At(idx);

	TReal ecomStartTime = timerResult.iStartTime;

	TReal ecomComplTime = timerResult.iEndTime;

	TReal stateStartTime = 0.0;

	TReal stateComplTime = 0.0;

	TReal accumulatedTime = 0.0;

	TReal initialisationTime = 0.0;

	//Test for Critical Static state

	INFO_PRINTF1(_L("Critical Static"));

	TVerdict result = ProcessState(timerResults, EStartupStateCriticalStatic, stateStartTime, stateComplTime);

	if(result != EPass && result != EIgnore)

		{

		return TestStepResult();

		}

	accumulatedTime += (stateComplTime - stateStartTime);

	CheckPerformance(stateComplTime - stateStartTime, CriticalStaticLimit, _L("Critical static state"));

	//Test for initialisation

	initialisationTime = ecomComplTime - ecomStartTime - accumulatedTime;

	INFO_PRINTF2(_L("Initialisation Elapsed: %f mSecs\n"), ecomComplTime - ecomStartTime);

	accumulatedTime += initialisationTime;

	CheckPerformance(initialisationTime, InitialisationLimit, _L("Initialisation Time"));

	//Test for Critical Dynamic state

	result = ProcessState(timerResults, EStartupStateCriticalDynamic, stateStartTime, stateComplTime);

	if(result != EPass && result != EIgnore)

		{

		return TestStepResult();

		}

	accumulatedTime += (stateComplTime - stateStartTime);

	CheckPerformance(stateComplTime - stateStartTime, CriticalDynamicLimit, _L("Critical dynamic state"));

	//Test for Non Critical state

	result = ProcessState(timerResults, EStartupStateNonCritical, stateStartTime, stateComplTime);

	if(result != EPass && result != EIgnore)

		{

		return TestStepResult();

		}

	accumulatedTime += (stateComplTime - stateStartTime);

	CheckPerformance(stateComplTime - stateStartTime, NonCriticalLimit, _L("Non critical state"));

	//Test for overall time

	INFO_PRINTF2(_L("Ecom Stop Time: %f mSecs\n"), stateComplTime);

	INFO_PRINTF2(_L("Total Elapsed Time: %f mSecs\n"), stateComplTime - ecomStartTime);

	INFO_PRINTF2(_L("Total Accumulated Time: %f mSecs\n"), 	accumulatedTime);

	// CheckPerformance(accumulatedTime, 1000); Test unecessary as individual times that make up accumulated are already tested

	// Now get all the heap results from the server

	REComHeapUsageRecords heapResults;

	heapResults.OpenL();	

	//Test for Critical Static state

	TInt CSUsage=0;

	INFO_PRINTF1(_L("Critical Static state"));

	result=ProcessState(heapResults,EStartupStateCriticalStatic,CSUsage);

	if(result != EPass && result != EIgnore)

		{

		return TestStepResult();

		}

	//Test for initialisation

	INFO_PRINTF1(_L("Initialisation state(including Critical Static measurement)"));

	TInt heapUsage=0;

	result=ProcessState(heapResults,-1,heapUsage);

	TInt initialisationHeapUsage=heapUsage-CSUsage;

	if(result != EPass && result != EIgnore)

		{

		return TestStepResult();

		}

	INFO_PRINTF1(_L("Initialisation state(excluding Critical Static measurement)"));	

	INFO_PRINTF3(_L("State: %d heap usage: %d bytes\n"), -1,initialisationHeapUsage);			

	//Test for Critical Dynamic state

	INFO_PRINTF1(_L("Critical Dynamic state"));	

	result=ProcessState(heapResults,EStartupStateCriticalDynamic,heapUsage);

	if(result != EPass && result != EIgnore)

		{

		return TestStepResult();

		}	

	//Test for Non Critical State

	INFO_PRINTF1(_L("Non Critical sate"));

	result=ProcessState(heapResults,EStartupStateNonCritical,heapUsage);

	if(result != EPass && result != EIgnore)

		{

		return TestStepResult();

		}

	heapResults.Close();	

#else

	MacroNotDefinedError();

#endif // __ECOM_SERVER_PERFORMANCE__

	return TestStepResult();

	}