// 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();
	}