diff -r 000000000000 -r 08ec8eefde2f traceservices/tracefw/integ_test/ost/TEF/te_ostv2integsuite_performance/src/te_perf.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/traceservices/tracefw/integ_test/ost/TEF/te_ostv2integsuite_performance/src/te_perf.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,634 @@
+// Copyright (c) 2007-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:
+// Example CTestStep derived implementation
+//
+
+
+
+/**
+ @file te_perf.cpp
+ @internalTechnology
+*/
+#include "te_perf.h"
+#include "te_ostv2integsuite_defs.h"
+#include <e32math.h>
+#include "te_perfresultscollector.h"
+#include <hal.h>
+#include "te_lightlogger.h"
+#include "lightlogger.h"
+#include "te_tracecontrolcmds.h"
+#include "te_perfcsvgenerator.h"
+using namespace Ulogger; //CA:added so can use old ulogger api
+
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+////////////////////// UPT OUTPUT PLUGIN CONFIG CLASS///////////////////
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+CPluginRunConfig::CPluginRunConfig()
+	{
+	/*Constructor*/
+	//iPluginName=0; // initialize to nothing so can tell if test worked? pickup defaults here?
+	//iPluginConfiguration=0; //set as default=file
+	//iPluginKey=0;
+	//iPluginValue=0;
+	//iTestType;
+	iDataSize=-1; //this is the amount of data to be sent through the output plugin
+	iIteration=1;
+	
+	}
+
+CPluginRunConfig::~CPluginRunConfig()
+	{
+	/*Destructor*/
+	}
+
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+
+CTCMPerformanceWrapper::~CTCMPerformanceWrapper()
+/**
+ * Destructor
+ */
+	{
+	delete iPluginRunConfig;
+	}
+
+CTCMPerformanceWrapper::CTCMPerformanceWrapper()
+/**
+ * Constructor
+ */
+	{
+	TRunConfigurer::Init(iApiRunConfig);
+	iPluginRunConfig = new(ELeave) CPluginRunConfig;
+	}
+
+
+CTCMPerformanceWrapper* CTCMPerformanceWrapper::NewLC()
+	{
+	CTCMPerformanceWrapper* self = new (ELeave)CTCMPerformanceWrapper();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+CTCMPerformanceWrapper* CTCMPerformanceWrapper::NewL()
+	{
+	CTCMPerformanceWrapper* self=CTCMPerformanceWrapper::NewLC();
+	CleanupStack::Pop(); // self;
+	return self;
+	}
+
+void CTCMPerformanceWrapper::ConstructL()
+	{
+	}
+
+TAny* CTCMPerformanceWrapper::GetObject()
+	{
+	return NULL;
+	}
+TBool CTCMPerformanceWrapper::DoCommandL(	const TTEFFunction& /*aCommand*/,
+					const TTEFSectionName& aSection, 
+					const TInt /*aAsyncErrorIndex*/)
+	{
+	if(BlockResult()==EPass)
+	  	{
+		TBool doapicalltests;
+		TBool dooutputplugintests;
+		TBool dothroughputtests;
+		TBool dobuffersizetests;//****to be implemented
+		TBool dobuffermodetests;//****to be implemented
+
+		//collect which testypes to run
+		if(!GetBoolFromConfig(aSection,_L("runapicalltests"), doapicalltests))
+			doapicalltests=ETrue;
+		if(!GetBoolFromConfig(aSection,_L("runoutputplugintests"), dooutputplugintests))
+			dooutputplugintests=ETrue;
+		if(!GetBoolFromConfig(aSection,_L("runthroughputtests"), dothroughputtests))
+			dothroughputtests=ETrue;
+		if(!GetBoolFromConfig(aSection,_L("runbuffersizetests"), dobuffersizetests))
+			dobuffersizetests=ETrue;
+		if(!GetBoolFromConfig(aSection,_L("runbuffermodetests"), dobuffermodetests))
+			dobuffermodetests=ETrue;
+
+		TInt pluginOnlyTests=0;
+	  	//run api tests
+		if(doapicalltests)
+			SetBlockResult(DoApiTests(aSection));
+
+		if(dooutputplugintests)
+			{
+			pluginOnlyTests=1;
+			SetBlockResult(DoPluginTests(pluginOnlyTests, aSection));
+			}
+		
+		if(dothroughputtests)
+			{
+			pluginOnlyTests=2;
+			SetBlockResult(DoPluginTests(pluginOnlyTests, aSection));
+			}
+
+		/*
+		 * Implement these in the next iteration
+		 *
+		 * if(dobuffersizetests)
+		SetBlockResult(DoBufferSizeTests());
+		if(dobuffermodetests)
+		SetBlockResult(DoBufferModeTests());
+		*
+		*
+		*
+		*/
+
+	  	}
+	 	return ETrue;
+	}
+
+TVerdict CTCMPerformanceWrapper::DoApiTests(const TTEFSectionName& aSection)
+	{
+	//initialize and create test run parameters
+  	//*******this is quite ugly and could be tidied up into a new routine so isnt in main test step
+  	TInt minapiidvalue=0;
+  	TInt maxapiidvalue=0;
+	TInt pcBool=0;
+	THasProgramCounter minpcvalue=ENoProgramCounter;
+	THasProgramCounter maxpcvalue=ENoProgramCounter;
+	TInt contextBool=0;
+	THasThreadIdentification mincontextvalue=ENoThreadIdentification;
+	THasThreadIdentification maxcontextvalue=ENoThreadIdentification;
+	TBool usesampleevp = EFalse;
+	TInt mindatasizevalue=0;
+	TInt maxdatasizevalue=0;
+	TInt dataincrement=1;
+	TBool minexecutionvalue=EFalse;
+	TBool typicalexecutionvalue=EFalse;
+	TBool testclassificationfiltering=EFalse;
+	TBool testmoduleidfiltering=EFalse;
+	TBool mintestclassificationmatch=ETrue;
+	TBool maxtestclassificationmatch=ETrue;
+	TBool mintestmoduleidmatch=EFalse;
+	TBool maxtestmoduleidmatch=EFalse;
+	TBool appendvalue=ETrue;
+	TInt testtype = 0;
+
+	TBool traceenabledvalue=EFalse;
+
+	if(BlockResult() == EPass)
+		{
+		//TInt error=KErrNotSupported;
+
+	 	//fetch user defined fields from config file (need to ensure there are defaults in the test suite)
+	 	//any missing fields, etc, assign default values
+	 	//*******remove magic numbers and set as KLit's
+	  	INFO_PRINTF1(_L("Fetch user-defined values from config file"));
+	
+		//initial api
+		if(!GetIntFromConfig(aSection,_L("minapiid"),minapiidvalue))
+			minapiidvalue=0;
+	
+		//final api
+		if(!GetIntFromConfig(aSection,_L("maxapiid"),maxapiidvalue))
+			maxapiidvalue=minapiidvalue;
+	
+  		//pc parameters
+  		if(!GetIntFromConfig(aSection,_L("pc"),pcBool))
+			{
+  			minpcvalue=EAddProgramCounter;
+  			maxpcvalue=ENoProgramCounter;
+			}
+		else
+			{
+  			if(pcBool == 1)
+   				{
+  				maxpcvalue=minpcvalue=EAddProgramCounter;
+   				}
+   			else
+   				{
+   				maxpcvalue=minpcvalue=ENoProgramCounter;
+   				}
+   			}
+		
+		//context paramaters
+		if(!GetIntFromConfig(aSection,_L("context"),contextBool))
+			{
+			mincontextvalue=EAddThreadIdentification;
+			maxcontextvalue=ENoThreadIdentification;
+			}
+		else
+			{
+			if(contextBool == 1)
+				{
+				maxcontextvalue=mincontextvalue=EAddThreadIdentification;
+				}
+			else
+				maxcontextvalue=mincontextvalue=ENoThreadIdentification;
+			}
+		//loop over data or use sample evp
+		if(!GetBoolFromConfig(aSection,_L("testsampleevp"),usesampleevp))
+			usesampleevp=ETrue;
+		 
+		//data size parameters
+		if(!GetIntFromConfig(aSection,_L("minevp"),mindatasizevalue))
+			mindatasizevalue=0;
+		if(!GetIntFromConfig(aSection,_L("maxevp"),maxdatasizevalue))
+			maxdatasizevalue=mindatasizevalue;
+		if(maxdatasizevalue!=mindatasizevalue)
+			{
+			if(!GetIntFromConfig(aSection,_L("evpincrement"),dataincrement))
+				dataincrement=(maxdatasizevalue-mindatasizevalue)/(10-1);
+			}
+	
+		//minimum execution test
+		if(!GetBoolFromConfig(aSection,_L("minexecutiontime"),minexecutionvalue))
+			minexecutionvalue=ETrue;
+	
+		//typical execution test
+		if(!GetBoolFromConfig(aSection,_L("reasonablemaxexecutiontime"),typicalexecutionvalue))
+			typicalexecutionvalue=ETrue;
+	
+		//testprimary filter
+		if(!GetBoolFromConfig(aSection,_L("testwithclassificationfilteringenabled"),testclassificationfiltering))
+			testclassificationfiltering=ETrue;
+	
+		//testsecondary filter
+		if(!GetBoolFromConfig(aSection,_L("testwithmoduleidfilteringenabled"),testmoduleidfiltering))
+			testmoduleidfiltering=ETrue;
+	
+		//testclassificationfiltermatch
+		if(!GetBoolFromConfig(aSection,_L("testwithclassificationfiltermatchestrace "),mintestclassificationmatch))
+			{
+			mintestclassificationmatch=ETrue;
+			maxtestclassificationmatch=EFalse;
+			}
+		else
+			maxtestclassificationmatch=mintestclassificationmatch;
+		
+		//testmoduleidfiltermatch
+			if(!GetBoolFromConfig(aSection,_L("testwithmoduleidfiltermatchestrace"),mintestmoduleidmatch))
+				{
+				mintestmoduleidmatch=ETrue;
+				maxtestmoduleidmatch=EFalse;
+				}
+			else
+				maxtestmoduleidmatch=mintestmoduleidmatch;
+			
+			
+		if(!GetBoolFromConfig(aSection,_L("append"),appendvalue))
+			appendvalue = EFalse;
+	
+		traceenabledvalue = EFalse;
+	
+	#ifdef TE_UPT_TRACE_ENABLED //or could ifdef on SYMBIAN_TRACE_EXECUTABLE_INCLUDE --especially if there's likely to be other configs
+		traceenabledvalue = ETrue;
+	#endif
+	
+		//mass of nested for loops... :(
+	
+		//do the test
+	
+		INFO_PRINTF1(_L("Do the API tests"));
+		CApiCallTest apitest;
+		CUptResults manageresults;
+	
+	
+		// write data to csv
+		INFO_PRINTF1(_L("Write the api results to csv"));
+		
+	
+		//create the ULogger session
+		RULogger logger;
+		CUptULogger loggerCommand;
+		TInt result= 0;
+        result =logger.Connect();
+        INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);
+        if (result!=KErrNone)
+            {
+            INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));
+            for (TInt i=2; i<12;i++)
+                {
+                User::After(1000);
+                result = logger.Connect();
+                INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);
+                if (result==KErrNone)
+                    {
+                    break;
+                    }
+                }
+            }
+		CClearConfig configIni;
+		configIni.Clear(logger);
+	
+		//put in test over API CALLS
+		testtype=0;
+		
+		if(usesampleevp==0)
+			{
+#define LOOP_EVP			
+			}
+	for(TInt runapiid=minapiidvalue; runapiid<=maxapiidvalue; runapiid++)
+			{
+			for(TInt runpc=minpcvalue; runpc<=maxpcvalue; runpc++)
+				{
+				for(TInt runcontext=mincontextvalue; runcontext<=maxcontextvalue; runcontext++)
+					{
+					TInt rundatasize=mindatasizevalue;
+#ifdef LOOP_EVP			
+						for(rundatasize=mindatasizevalue; rundatasize<=maxdatasizevalue; rundatasize=rundatasize+dataincrement)
+							{
+#endif
+							{
+							for(TBool runclassificationfiltermatch=mintestclassificationmatch; runclassificationfiltermatch<=maxtestclassificationmatch; runclassificationfiltermatch++)
+								{
+								for(TBool runmoduleidfiltermatch=mintestmoduleidmatch; runmoduleidfiltermatch<=maxtestmoduleidmatch; runmoduleidfiltermatch++)
+									{
+	
+									//now set the parameters to pass to the test step
+									TRunConfigurer::SetRunParams(iApiRunConfig, runapiid, (THasThreadIdentification) runcontext, (THasProgramCounter) runpc);
+									TRunConfigurer::SetRunConfigs(iApiRunConfig, testclassificationfiltering, testmoduleidfiltering, runclassificationfiltermatch, runmoduleidfiltermatch, minexecutionvalue, typicalexecutionvalue, EFalse, EFalse, EFalse);
+		
+									//start the ULogger session with filter settings as specified by the user
+									__TEST_LOG("about to start ulogger session");
+			
+									TInt error=loggerCommand.StartFileL(logger,testclassificationfiltering, testmoduleidfiltering, runclassificationfiltermatch, runmoduleidfiltermatch);
+									if(error)
+										{
+										INFO_PRINTF2(_L("start logger returns %d"), error);
+										SetBlockResult(EFail);
+										}
+									
+									TApiTestResult apitestresult;
+									apitestresult.iRunConfigs = iApiRunConfig; //shallow opy should suffice as we use it between kernel and user side as well.
+									apitestresult.iRunResults.iTraceEnabled = traceenabledvalue;
+		
+									//do the test
+									INFO_PRINTF2(_L("Testing API %d"), iApiRunConfig.iApiId);
+									error = apitest.CachedTraceTime(iApiRunConfig, apitestresult);
+									if(error)
+										{
+										INFO_PRINTF2(_L("ERROR: CachedTraceTime failed, error %d"), error);
+										SetBlockResult(EFail);
+										}
+									error = apitest.NonCachedTraceTime(iApiRunConfig, apitestresult);
+									if(error)
+										{
+										INFO_PRINTF2(_L("ERROR: NonCachedTraceTime failed, error %d"), error);
+										SetBlockResult(EFail);
+										}
+									error = apitest.StackUsage(iApiRunConfig, apitestresult);							
+									if(error)
+										{
+										INFO_PRINTF2(_L("ERROR: StackUsage failed, error %d"), error);
+										SetBlockResult(EFail);
+										}
+									
+									//(apitest.DoTestL(*iApiRunConfig))->Copy(apitestresult);
+									//stop the ULogger session
+									__TEST_LOG("about to stop ulogger session");
+									loggerCommand.StopAndDeleteFile(logger);
+			
+									//collect the results
+									//INFO_PRINTF1(_L("Collect the api results"));
+			
+									//store the API test result
+									manageresults.StoreApiResultsL(apitestresult);
+									//error = manageresults.StoreApiResultsL(apitestresult);
+									//if(error)
+										//{
+										//INFO_PRINTF1(_L("Write the api results"));
+										//SetBlockResult(EFail);
+										//}
+									__UHEAP_MARK;
+									manageresults.WriteUptResultsL(KApiCSVFile, appendvalue, testtype);
+									__UHEAP_MARKEND;
+									}
+			
+								}
+#ifdef LOOP_EVP			
+								}
+#endif
+							}
+					}
+					}
+				}
+		result = logger.Connect();
+        INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);
+        if (result!=KErrNone)
+            {
+            INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));
+            for (TInt i=2; i<12;i++)
+                {
+                User::After(1000);
+                result = logger.Connect();
+                INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);
+                if (result==KErrNone)
+                    {
+                    break;
+                    }
+                }
+            }
+		configIni.Clear(logger);
+		}
+	//put in all the error returns
+	//put in test step result returns
+	INFO_PRINTF1(_L("End of test run"));
+	return BlockResult();
+	}
+
+TVerdict CTCMPerformanceWrapper::DoPluginTests(const TInt& aPluginOnly, const TTEFSectionName& aSection)
+	{
+	//define default plugin configurations
+	_LIT(KDefaultPlugin,"uloggerfileplugin");
+	_LIT(KOutputPath, "output_path");
+	_LIT(KLogDefaultFileName, "C:\\logs\\defaultplugin.utf");
+	_LIT(KOutputCSVFile,"c:\\te_plugintestresults.csv");
+
+	//create lightlogger file for the timestamps
+	//NB this is a temporary solution until the next iteration
+	//where ulogger source itself will be instrumented with test code
+
+	__CREATE_LOG(false);
+	__LOG("About to record plugin timestamps");
+	__HIRES_RESOLUTION;
+
+	//initialize and create test run parameters
+	TInt plugindata=0;
+	TInt pluginiterations=0;
+	TBool appendvalue;
+	TInt testtype = 0;
+	TPtrC plugintempname(KDefaultPlugin);
+	TPtrC plugintempkey(KOutputPath);
+	TPtrC plugintempvalue(KLogDefaultFileName);
+	TPtrC8 plugintestype;
+
+	//first identify the testtype
+	if(aPluginOnly==1)
+		{
+		testtype=1;
+		plugintestype.Set(KOutputPluginTest);
+		__LOG("NB: recording plugin only timestamps");
+		}
+	else
+		{
+		testtype=2;
+		plugintestype.Set(KThroughputTest);
+		__LOG("NB: recording full throughput timestamps");
+		}
+
+
+	//TInt ConfigureOutputPlugin(const RPointerArray<TPluginConfiguration>& aSettings); if>0
+	//currently this test suite  assumes that there is only one set of configuration settings
+
+
+	//Collect the output plugin test run configuration
+
+	//plugin name
+	if(!GetStringFromConfig(aSection,_L("plugintestused"),plugintempname))
+		{
+		;
+		}
+
+	//the following three lines are an irritating get around to sort out the fact that
+	//the routine for GetStringFromConfig() only works with TPtrC16 and ULogger expects TPtrC8
+	TBuf8<0x100> pluginname;
+	pluginname.Copy(plugintempname);
+
+
+	//plugin configurations
+	if(!GetStringFromConfig(aSection,_L("plugintestconfigurationkey"),plugintempkey))
+		{
+		;
+		}
+	//the routine for GetStringFromConfig() only works with TPtrC16 and ULogger expects TPtrC8
+	TBuf8<0x100> pluginkey;
+	pluginkey.Copy(plugintempkey);
+
+	if(!GetStringFromConfig(aSection,_L("plugintestconfigurationvalue"),plugintempvalue))
+		{
+		;
+		}
+	//the routine for GetStringFromConfig() only works with TPtrC16 and ULogger expects TPtrC8
+	TBuf8<0x100> pluginvalue;
+	pluginvalue.Copy(plugintempvalue);
+
+	//datasize to pass through plugin in bytes
+	if(!GetIntFromConfig(aSection,_L("plugintestdatasize"),plugindata))
+		plugindata=1024;
+
+	//number of test iterations for stress test over time
+	if(!GetIntFromConfig(aSection,_L("plugintestiterations"), pluginiterations))
+		pluginiterations=1;
+
+	//option for appending to results file
+	if(!GetBoolFromConfig(aSection,_L("append"),appendvalue))
+		appendvalue=ETrue;
+
+	TBool traceon=ETrue;
+#ifndef TE_UPT_TRACE_ENABLED //or could ifdef on SYMBIAN_TRACE_EXECUTABLE_INCLUDE --especially if there's likely to be other configs
+	traceon=EFalse;
+	INFO_PRINTF1(_L("WARNING! Tracing is disabled so output plugin tests not run "));
+#endif
+
+	//mass of nested for loops... :(
+	if(traceon)
+		{
+		//do the test
+		INFO_PRINTF1(_L("Do the plugin tests"));
+		CPluginTestResult plugintestresult;
+		CPluginTests plugintest;
+		CUptResults manageresults;
+
+
+		//create the ULogger session
+		RULogger logger;
+		CUptULogger loggerCommand;
+
+		//set the run parameters
+
+		iPluginRunConfig->iPluginName.Set(pluginname);
+		iPluginRunConfig->iPluginConfiguration.SetKey(pluginkey);
+		iPluginRunConfig->iPluginConfiguration.SetValue(pluginvalue);
+		iPluginRunConfig->iPluginKey.Set(pluginkey);
+		iPluginRunConfig->iPluginValue.Set(pluginvalue);
+		iPluginRunConfig->iTestType.Set(plugintestype);
+		iPluginRunConfig->iDataSize=plugindata;
+		TBool classificationFiltering = ETrue;
+		TBool moduleIdFiltering = ETrue;
+		TBool classificationFilterMatch = ETrue;
+		TBool moduleIdFilterMatch = ETrue;
+	
+		//we force this to be hardcoded as it makes no sense to have a mismatch here
+		//i.e. to have trace compiled in but filters disabled
+
+		//iterates over tests for stress testing
+		TInt error=KErrNone;
+
+		for(TInt iterate=1; iterate<=pluginiterations; iterate++)
+			{
+
+				iPluginRunConfig->iIteration=iterate;
+
+				//start the ULogger session with filter settings as specified by the user
+				//__TEST_LOG("about to start ulogger session");
+				INFO_PRINTF1(_L("about to start logger"));
+
+				error=loggerCommand.StartGeneralL(logger, iPluginRunConfig->iPluginName, iPluginRunConfig->iPluginConfiguration, classificationFiltering, moduleIdFiltering, classificationFilterMatch, moduleIdFilterMatch);
+
+				INFO_PRINTF2(_L("start logger returns %d"), error);
+
+				//do the test
+				plugintestresult.Copy(*plugintest.DoTestL(*iPluginRunConfig));
+
+				//stop the ULogger session
+				//__TEST_LOG("about to stop ulogger session");
+				loggerCommand.Stop(logger);
+
+				//collect the results
+				INFO_PRINTF1(_L("Collect the plugin results"));
+
+				//store the plugin test result
+				manageresults.StorePluginResultsL(plugintestresult);
+				// write data to csv
+				INFO_PRINTF1(_L("Write the plugin results to csv"));
+				manageresults.WriteUptResultsL(KOutputCSVFile, appendvalue, testtype);
+
+			}
+		SetBlockResult(EFail);
+		if(error==KErrNone)
+			SetBlockResult(EPass);
+
+	}
+
+	return BlockResult();
+}
+
+
+TVerdict CTCMPerformanceWrapper::DoBufferSizeTests()
+	{
+	TInt error=KErrNone;
+	SetBlockResult(EFail);
+	if(error==KErrNone)
+		SetBlockResult(EPass);
+	return BlockResult();
+	}
+
+TVerdict CTCMPerformanceWrapper::DoBufferModeTests()
+	{
+	TInt error=KErrNone;
+	SetBlockResult(EFail);
+	if(error==KErrNone)
+		SetBlockResult(EPass);
+	return BlockResult();
+	}
+
+