FCL/sf/os/osrndtools: comparison stif/TestScripter/src/TestScripter.cpp

equal deleted inserted replaced

-:7fdc9a71d314
+:8ad140f3dd41
+/*
+* Copyright (c) 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: This file contains TestScripter implementation.
+*
+*/
+// INCLUDE FILES
+#include <StifTestEventInterface.h>
+#include <StifLogger.h>
+#include "TestScripter.h"
+#include "TestKeywords.h"
+#include "Logging.h"
+#include "TestEngineClient.h"
+#include "SettingServerClient.h"
+#include <stifinternal/UiEnvProxy.h>
+// EXTERNAL DATA STRUCTURES
+// None
+// EXTERNAL FUNCTION PROTOTYPES
+// None
+// CONSTANTS
+// None
+// MACROS
+#ifdef LOGGER
+#undef LOGGER
+#endif
+#define LOGGER iLog
+// LOCAL CONSTANTS AND MACROS
+// None
+// MODULE DATA STRUCTURES
+// None
+// LOCAL FUNCTION PROTOTYPES
+// None
+// FORWARD DECLARATIONS
+// None
+// ==================== LOCAL FUNCTIONS =======================================
+/*
+-------------------------------------------------------------------------------
+Class: -
+Method: CallBack
+Description: (Function pointer) Called from CScriptBase class. Generic
+method for call back operations from Test Script Class to
+TestScripter.
+Parameters: CTestScripter* aTestScripter: in: Pointer to TestScripter
+TStifTSCallBackType aCallType: in: Call back type
+const TDesC& aLine: in Script line
+Return Values: TInt: Symbian error code
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CallBack( CTestScripter* aTestScripter,
+TStifTSCallBackType aCallType,
+const TDesC& aLine )
+{
+TInt ret( 0 );
+switch( aCallType )
+{
+case EStifTSCallClass:
+{
+ret = aTestScripter->CallTestClass( aLine );
+break;
+}
+case EStifTSGetObject:
+{
+ret = aTestScripter->GetTestScriptObject( aLine );
+break;
+}
+default:
+{
+ret = KErrArgument;
+break;
+}
+}
+return ret;
+}
+/*
+-------------------------------------------------------------------------------
+DESCRIPTION
+This module contains the implementation of CTestScripter class
+member functions.
+-------------------------------------------------------------------------------
+*/
+// ================= MEMBER FUNCTIONS =========================================
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: CTestScripter
+Description: Default constructor
+C++ default constructor can NOT contain any code, that
+might leave.
+Parameters:    None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CTestScripter::CTestScripter()
+{
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: ConstructL
+Description: Symbian OS second phase constructor
+Symbian OS default constructor can leave.
+Parameters:    None
+Return Values: None
+Errors/Exceptions: None.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestScripter::ConstructL()
+{
+__TRACE( KPrint, ( _L("New TestScripter") ) );
+iStdLog = CStifLogger::NewL( KTestScripterLogDir,
+KTestScripterLogFile );
+iLog = iStdLog;
+iOOMIgnoreFailure = EFalse; // OFF for default
+iCheckHeapBalance = EFalse; // No checking heap balance by default
+//Read logger settings to check whether test case name is to be
+//appended to log file name.
+RSettingServer settingServer;
+TInt ret = settingServer.Connect();
+if(ret != KErrNone)
+{
+User::Leave(ret);
+}
+// Struct to StifLogger settigs.
+TLoggerSettings loggerSettings;
+// Parse StifLogger defaults from STIF initialization file.
+ret = settingServer.GetLoggerSettings(loggerSettings);
+if(ret != KErrNone)
+{
+User::Leave(ret);
+}
+// Close Setting server session
+settingServer.Close();
+iAddTestCaseTitleToLogName = loggerSettings.iAddTestCaseTitle;
+// Initialize parser variables
+iCurrentParser = NULL;
+iCurrentParserReadFirstLine = EFalse;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: NewL
+Description: Two-phased constructor.
+Parameters:    None
+Return Values: CTestScripter*: new object
+Errors/Exceptions: Leaves if new or ConstructL leaves.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CTestScripter* CTestScripter::NewL()
+{
+CTestScripter* self = new (ELeave) CTestScripter();
+CleanupStack::PushL( self );
+self->ConstructL();
+CleanupStack::Pop();
+return self;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: ~CTestScripter
+Description: Destructor
+Parameters:    None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CTestScripter::~CTestScripter()
+{
+iTestObjects.ResetAndDestroy();
+iTestModules.ResetAndDestroy();
+iDefinedIni.ResetAndDestroy();
+iDefinedRuntime.ResetAndDestroy();
+iDefinedLocal.ResetAndDestroy();
+iParserStack.ResetAndDestroy();
+iTestObjects.Close();
+iTestModules.Close();
+iDefinedIni.Close();
+iDefinedRuntime.Close();
+iDefinedLocal.Close();
+iParserStack.Close();
+iCurrentParser = NULL;
+delete iSectionParser;
+delete iTestRunner;
+iLog = NULL;
+delete iStdLog;
+iStdLog = NULL;
+delete iTCLog;
+iTCLog = NULL;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: InitL
+Description: InitL is used to initialize the Test Module.
+Parameters: const TFileName& aIniFile: in: Initialization file
+TBool aFirstTime: in: First time flag
+Return Values: Symbian OS error code
+Errors/Exceptions: Leaves if ReadInitializationL leaves
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestScripter::InitL( TFileName& aIniFile,
+TBool /*aFirstTime*/ )
+{
+__TRACEFUNC();
+if( aIniFile.Length() > 0 )
+{
+// Read initialization from test case file
+ReadInitializationL( aIniFile, iDefinedIni );
+}
+return KErrNone;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetTestCases
+Description: GetTestCases is used to inquired test cases
+Parameters:    const TFileName& aConfigFile: in: Test case file
+RPointerArray<RTestEngine::TTestCaseInfo>& aTestCases: out:
+Array of TestCases
+Return Values: KErrNone: Success
+Symbian OS error code
+Errors/Exceptions: Leaves if CStifParser::SectionL leaves
+Leaves if CStifParser::NextSectionL leaves
+Leaves if memory allocation fails
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestScripter::GetTestCasesL( const TFileName& aConfigFile,
+RPointerArray<TTestCaseInfo>& aTestCases )
+{
+__TRACEFUNC();
+if( aConfigFile.Length() == 0 )
+{
+__TRACE( KError, (_L("No test case script file given") ) );
+__RDEBUG( (_L("No test case script file given") ) );
+return KErrNotFound;
+}
+CStifParser* parser = NULL;
+// Open test case file
+TRAPD( err,
+parser = CStifParser::NewL( _L(""),
+aConfigFile,
+CStifParser::ECStyleComments ) );
+if( err != KErrNone )
+{
+__TRACE( KError, (_L("Given test case script file [%S] not found"),
+&aConfigFile ) );
+__RDEBUG( (_L("Given test case script file [%S] not found"),
+&aConfigFile ) );
+return err;
+}
+CleanupStack::PushL( parser );
+CStifSectionParser* section;
+TPtrC tmp;
+TInt index = 0;
+TInt ret = KErrNone;
+// Find first section
+section = parser->SectionL( KTestStartTag, KTestEndTag );
+if( section == NULL )
+{
+ret = KErrNotFound;
+}
+else
+{
+// Parse all sections
+while( section )
+{
+CleanupStack::PushL( section );
+// Get title line
+if( section->GetLine( TTestKeywords::Keyword( TTestKeywords::ETitle ),
+tmp, ENoTag ) != KErrNone )
+{
+__TRACE( KError, (_L("Title not given for test case")));
+User::Leave( KErrNotFound );
+}
+else
+{
+if( tmp.Length() > KMaxName )
+{
+tmp.Set( tmp.Left( KMaxName ) );
+}
+TTestCaseInfo* tc = new ( ELeave ) TTestCaseInfo();
+CleanupStack::PushL( tc );
+__TRACE( KVerbose, (_L("TestCase: %S"), &tmp));
+tc->iTitle.Copy( tmp );
+tc->iCaseNumber = ++index;
+// Get timeout if defined
+CStifItemParser* item = section->GetItemLineL(
+TTestKeywords::Keyword( TTestKeywords::ETimeout ) );
+if( item )
+{
+TInt timeout; // In milliseconds
+ret = item->GetInt(
+TTestKeywords::Keyword( TTestKeywords::ETimeout ),
+timeout );
+if( ret != KErrNone )
+{
+__TRACE( KError, (_L("Illegal timeout")));
+User::Leave( ret );
+}
+// Type cast timeout to TInt64
+tc->iTimeout = TInt64( timeout ) * 1000;
+__TRACE( KMessage, (_L("Timeout: %i"), tc->iTimeout.Int64() ));
+}
+// Get priority if defined
+item = section->GetItemLineL(
+TTestKeywords::Keyword( TTestKeywords::EPriority ) );
+if( item )
+{
+// First try to interpret as integer
+ret = item->GetInt(
+TTestKeywords::Keyword( TTestKeywords::EPriority ),
+tc->iPriority );
+if( ret != KErrNone )
+{
+TPtrC priority;
+// If priority was not given as integer, it must be
+// one of the predefined values
+ret = item->GetString(
+TTestKeywords::Keyword( TTestKeywords::EPriority ),
+priority );
+if( ret != KErrNone )
+{
+__TRACE( KError, (_L("Illegal priority")));
+User::Leave( ret );
+}
+switch( TTestKeywords::Parse( priority,
+TTestKeywords::Priority ) )
+{
+case TTestKeywords::EPriHigh:
+tc->iPriority = TTestCaseInfo::EPriorityHigh;
+break;
+case TTestKeywords::EPriNormal:
+tc->iPriority = TTestCaseInfo::EPriorityNormal;
+break;
+case TTestKeywords::EPriLow:
+tc->iPriority = TTestCaseInfo::EPriorityLow;
+break;
+default:
+__TRACE( KError, (_L("Illegal priority")));
+User::Leave( KErrArgument );
+}
+}
+__TRACE( KMessage, (_L("Priority: %i"), tc->iPriority ));
+}
+aTestCases.Append(tc);
+CleanupStack::Pop( tc );
+}
+CleanupStack::PopAndDestroy( section );
+section = parser->NextSectionL( KTestStartTag, KTestEndTag );
+}
+}
+CleanupStack::PopAndDestroy( parser );
+__TRACE( KPrint, (  _L( "Configfile '%S', testcases %d" ),
+&aConfigFile, index ));
+return ret;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetConstantValue
+Description: Internal fuction to get const value defined in
+[Define]...[Enddefine] section of script file
+GetConstantValue gets const value defined in [Define]...[Enddefine]
+section of script file
+Parameters:    const TDesC& aName: in: constant name
+TDes& avalue: out: constant value
+Return Values: KErrNone: Value is returned succesfully.
+KErrNotFound: Constant was not found
+Any other SymbianOS error
+-------------------------------------------------------------------------------
+*/
+EXPORT_C TInt CTestScripter::GetConstantValue( const TDesC& aName, TDes& aValue )
+	{
+	__TRACEFUNC();
+TInt count = iDefinedLocal.Count();
+for(TInt i = 0; i < count; i++)
+{
+if(iDefinedLocal[i]->Name() == aName)
+{
+aValue.Copy(iDefinedLocal[i]->Value());
+return KErrNone;
+}
+}
+	  count = iDefinedIni.Count();
+for( TInt i = 0; i < count; i++ )
+{
+if( iDefinedIni[i]->Name() == aName )
+{
+aValue.Copy( iDefinedIni[i]->Value() );
+return KErrNone;
+}
+}
+count = iDefinedRuntime.Count();
+for( TInt i = 0; i < count; i++ )
+{
+if( iDefinedRuntime[i]->Name() == aName )
+{
+aValue.Copy( iDefinedRuntime[i]->Value() );
+return KErrNone;
+}
+}
+return KErrNotFound;
+	}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: RunTestCaseL
+Description: Run a specified testcase.
+RunTestCaseL is used to run an individual test case.
+Parameters:    const TInt aCaseNumber: in: Testcase number
+const TFileName& aConfig: in: Test case file
+TTestResult& aResult: out: test case result
+Return Values: KErrNone: Test case started succesfully.
+KErrNotFound: Testcase not found
+KErrUnknown: Unknown TestScripter error
+Any other SymbianOS error
+Errors/Exceptions: Leaves if GetTestCaseL leaves
+Leaves if RunTestL leaves
+Leaves if memory allocation fails
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestScripter::RunTestCaseL( const TInt aCaseNumber,
+const TFileName& aConfig,
+TTestResult& aResult )
+{
+// Heap is checked by test server
+//__UHEAP_MARK;
+__TRACEFUNC();
+//Open new log file with test case title in file name
+if(iAddTestCaseTitleToLogName)
+{
+//Delete test case logger if exists
+if(iTCLog)
+{
+delete iTCLog;
+iTCLog = NULL;
+}
+TFileName logFileName;
+TName title;
+TestModuleIf().GetTestCaseTitleL(title);
+logFileName.Format(KTestScripterLogFileWithTitle, &title);
+iTCLog = CStifLogger::NewL(KTestScripterLogDir, logFileName);
+iLog = iTCLog;
+}
+__TRACE( KMessage, (_L("\n\n***Testcase started***")));
+// Remove locally defined variables
+iDefinedLocal.ResetAndDestroy();
+// Remove existing function parsers (there shouldn't be any)
+iParserStack.ResetAndDestroy();
+// Keep file name of config file
+iConfig = aConfig;
+// Read initialization from test case file
+ReadInitializationL( aConfig, iDefinedRuntime );
+// Get case from test case file
+iSectionParser = GetTestCaseL( aCaseNumber, aConfig );
+iCurrentParser = iSectionParser;
+iCurrentParserReadFirstLine = EFalse;
+// Check parsing result
+if( iSectionParser == NULL )
+{
+__TRACE( KError, (_L("***Parsing testcase failed***\n\n")));
+// Delete runtime defines
+iDefinedRuntime.ResetAndDestroy();
+//__UHEAP_MARKEND;
+return KErrNotFound;
+}
+// When option is set in cfg file, on EKA2 env memory leaking is enabled
+	TInt memCellsBef = 0; //memory in current thread allocated before the test case is run
+	TInt memCellsAft = 0; //memory in current thread allocated after the test case has run
+	memCellsBef = User::Heap().Count();
+	__TRACE(KMessage, (_L("Allocated memory cells before the test case: %d"), memCellsBef));
+CActiveScheduler* activeScheduler =
+new ( ELeave ) CActiveScheduler();
+CleanupStack::PushL( activeScheduler );
+if ( CActiveScheduler::Current() == NULL )
+	{
+	CActiveScheduler::Install( activeScheduler );
+	}
+// Run the given testcase described in iSectionParser section
+RunTestL();
+iTestObjects.ResetAndDestroy();
+iTestModules.ResetAndDestroy();
+// TestScripter must stop Active Scheduler after test
+// object is destroyed. Otherwise if unexpected error occurs
+// handling is erronous.
+CleanupStack::PopAndDestroy( activeScheduler );
+	// Check for memory leak.
+	// It is reported in log always, but result of test case is changed only
+	// when option in cfg file is enabled.
+	memCellsAft = User::Heap().Count();
+	__TRACE(KMessage, (_L("Allocated memory cells after the test case: %d"), memCellsAft));
+	// if there is a difference report memory leak
+	if(memCellsAft != memCellsBef)
+		{
+		__TRACE(KError, (_L("Memory leak, %d cell(s) is missing"), memCellsAft - memCellsBef));
+		if(iCheckHeapBalance)
+			{
+			// Memory leaks detection is disabled for UI components testing
+			if ( !( TestModuleIf().UITesting() ) )
+				{
+				UpdateTestCaseResult(KErrGeneral, _L("Memory leak has occured"));
+				}
+			}
+		}
+// Delete parser and set current parser to NULL
+iCurrentParser = NULL;
+delete iSectionParser;
+iSectionParser = NULL;
+// Erase config file name
+iConfig = KNullDesC;
+// Return result
+aResult = iResult;
+if( iResult.iResult == KErrNone )
+{
+__TRACE( KPrint, (_L("***Testcase PASSED***\n\n")));
+TestModuleIf().Printf( KPrintPriNorm, _L("TestScripter"),
+_L("***Testcase PASSED***\n\n"));
+}
+else
+{
+__TRACE( KPrint, (_L("***Testcase FAILED***\n\n")));
+TestModuleIf().Printf( KPrintPriNorm, _L("TestScripter"),
+_L("***Testcase FAILED***\n\n"));
+}
+User::After(300000);
+// Delete runtime defines
+iDefinedRuntime.ResetAndDestroy();
+//__UHEAP_MARKEND;
+//If log was replaced then restore it
+if(iAddTestCaseTitleToLogName)
+{
+iLog = iStdLog;
+delete iTCLog;
+iTCLog = NULL;
+}
+return KErrNone;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: ReadInitializationL
+Description: Read initialization from file.
+Parameters:    const TDesC& aIniFile: in: File that contains initialization
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestScripter::ReadInitializationL(
+const TDesC& aIniFile,
+RPointerArray<CDefinedValue>& aDefines )
+{
+CStifParser* parser = NULL;
+// Open file
+TRAPD( err,
+parser = CStifParser::NewL( _L(""),
+aIniFile,
+CStifParser::ECStyleComments ) );
+if( ( err == KErrNone ) && parser )
+{
+CleanupStack::PushL( parser );
+__TRACE( KMessage, (_L("Read initialization from [%S]"),
+&aIniFile ) );
+CStifSectionParser* section = parser->SectionL( KDefineStartTag,
+KDefineEndTag );
+while(section)
+{
+CleanupStack::PushL( section );
+__TRACE( KMessage, (_L("Read defines")) );
+TPtrC name;
+TPtrC value;
+CStifItemParser* item = section->GetItemLineL( _L("") );
+while( item )
+{
+CleanupStack::PushL( item );
+if( item->GetString( _L(""), name ) != KErrNone )
+{
+__TRACE( KError, (_L("No define name given")) );
+User::Leave( KErrGeneral );
+}
+if( item->Remainder( value ) != KErrNone )
+{
+__TRACE( KError, (_L("No define value given")) );
+User::Leave( KErrGeneral );
+}
+TInt count = aDefines.Count();
+TInt i = 0;
+for( ; i < count; i++ )
+{
+if( aDefines[i]->Name() == name )
+{
+// Update existing
+aDefines[i]->SetValueL( value );
+__TRACE(KMessage, (_L("Update define [%S]: [%S]"), &name, &value));
+break;
+}
+}
+if( i == count)
+{
+// New define, store it
+CDefinedValue* define = CDefinedValue::NewL( name, value );
+CleanupStack::PushL( define );
+User::LeaveIfError( aDefines.Append( define ) );
+CleanupStack::Pop( define );
+}
+CleanupStack::PopAndDestroy( item );
+item = section->GetNextItemLineL();
+}
+CleanupStack::PopAndDestroy( section );
+section = parser->NextSectionL(KDefineStartTag, KDefineEndTag);
+}
+		//Read StifSettings section and find value for CheckHeapBalance.
+		//(In cfg file in settings section User may also set CapsModifier
+		// option. This is handled in TestServerClient.cpp in
+		// RTestServer::GetCapsModifier method).
+		section = parser->SectionL(KStifSettingsStartTag, KStifSettingsEndTag);
+		if(section)
+			{
+			CleanupStack::PushL(section);
+			__TRACE(KMessage, (_L("Read stif settings")));
+			TPtrC value;
+			CStifItemParser* item = section->GetItemLineL(_L(""));
+			while(item)
+				{
+				CleanupStack::PushL(item);
+				__TRACE( KMessage, (_L("Got settings line")));
+				if(item->GetString(_L("CheckHeapBalance="), value) == KErrNone)
+					{
+					__TRACE(KMessage, (_L("Got CheckHeapBalance item, value=%S"), &value));
+					if(value.Compare(_L("off")) == 0)
+		       			{
+		       			iCheckHeapBalance = EFalse;
+		       			}
+					else if(value.Compare(_L("on")) == 0)
+						{
+						iCheckHeapBalance = ETrue;
+		       			}
+					else
+						{
+						__TRACE(KError, (_L("Value '%S' for CheckHeapBalance setting is not supported. Aborting"), &value));
+						User::Leave(KErrNotSupported);
+						}
+					}
+				CleanupStack::PopAndDestroy(item);
+				item = section->GetNextItemLineL();
+				}
+			CleanupStack::PopAndDestroy(section);
+			}
+CleanupStack::PopAndDestroy( parser );
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetTestCaseL
+Description: Get specified test case section from configfile.
+Parameters:    const TInt aCaseNumber: in: Test case number
+const TFileName& aConfig: in: Configfile name
+Return Values: CStifSectionParser*: pointer to test case section
+Errors/Exceptions: Leaves if CStifParser::NewL leaves
+Leaves if CStifParser::SectionL leaves
+Leaves if memory allocation fails
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CStifSectionParser* CTestScripter::GetTestCaseL( const TInt aCaseNumber,
+const TFileName& aConfig )
+{
+__TRACEFUNC();
+CStifParser* parser = NULL;
+TRAPD( err,
+parser = CStifParser::NewL( _L(""),
+aConfig,
+CStifParser::ECStyleComments ); );
+if( err != KErrNone )
+{
+__TRACE( KError, (_L("Test case file [%S] not found"), &aConfig ));
+User::Leave( err );
+}
+CleanupStack::PushL( parser );
+CStifSectionParser* section = NULL;
+TRAP( err,
+section =parser->SectionL( KTestStartTag, KTestEndTag, aCaseNumber ););
+if( err != KErrNone )
+{
+__TRACE( KError,
+(_L("Section [%S/%d] not found"), &aConfig, aCaseNumber ));
+User::Leave( err );
+}
+CleanupStack::PopAndDestroy( parser );
+return section;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetSubL
+Description: Get specified function (sub) from stored config file.
+Parameters:    const TDesC& aSubName: in: function name
+Return Values: CStifSectionParser*: pointer to test function section
+Errors/Exceptions: Leaves if CStifParser::NewL leaves
+Leaves if CStifParser::SectionL leaves
+Leaves if memory allocation fails
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CStifSectionParser* CTestScripter::GetSubL(const TDesC& aSubName)
+{
+__TRACE(KMessage, (_L("Searching sub [%S]."), &aSubName));
+// Check if config file is set
+if(iConfig.Length() == 0)
+{
+__TRACE(KError, (_L("Searching sub [%S]. Config file is not set."), &aSubName));
+User::Leave(KErrBadName);
+}
+// Create parser
+CStifParser* parser = NULL;
+CStifSectionParser* section = NULL;
+TRAPD(err,
+parser = CStifParser::NewL(_L(""), iConfig, CStifParser::ECStyleComments);
+);
+if(err != KErrNone)
+{
+__TRACE(KError, (_L("Searching sub [%S]. Error [%d] when loading config file [%S]."), &aSubName, err, &iConfig));
+User::Leave(err);
+}
+CleanupStack::PushL(parser);
+// Set section tags
+_LIT(KEndSubTag, "[EndSub]");
+TName startSubTag;
+startSubTag.Copy(_L("[Sub "));
+startSubTag.Append(aSubName);
+startSubTag.Append(_L("]"));
+// Load section
+TRAP(err,
+section = parser->SectionL(startSubTag, KEndSubTag, 1);
+);
+if(err != KErrNone)
+{
+__TRACE(KError, (_L("Searching sub [%S]. Searching section %S%S ended with error [%d]."), &aSubName, &startSubTag, &KEndSubTag, err));
+User::Leave(err);
+}
+if(!section)
+{
+__TRACE(KError, (_L("Searching sub [%S]. Section %S%S not found."), &aSubName, &startSubTag, &KEndSubTag));
+User::Leave(err);
+}
+else
+{
+__TRACE(KMessage, (_L("Searching sub [%S]. Section %S%S found."), &aSubName, &startSubTag, &KEndSubTag));
+}
+CleanupStack::PopAndDestroy(parser);
+return section;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: RunTestL
+Description: Run a testcase specified by iSectionParser.
+Parameters:    None
+Return Values: None.
+Errors/Exceptions: Leaves if CSectionParser::GetItemLineL leaves
+Leaves if CTestRunner::NewL leaves
+Leaves if memory allocation fails
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestScripter::RunTestL()
+{
+__TRACEFUNC();
+iResult.iResult = KErrNone;
+iResult.iResultDes.Zero();
+// "title" keyword must be in the first line
+TPtrC title;
+if( iCurrentParser->GetLine(
+TTestKeywords::Keyword( TTestKeywords::ETitle ), title, ENoTag )
+!= KErrNone )
+{
+__TRACE( KError, (_L("title not found from section")));
+User::Leave( KErrNotFound );
+}
+iCurrentParserReadFirstLine = ETrue;
+__TRACE( KMessage, (_L("RunTest: %S"), &title ));
+iTestRunner = CTestRunner::NewL( this );
+TestModuleIf().Printf( KPrintPriNorm, _L("RunTest"), _L("%S"), &title );
+// Rest of the job is done by test runner
+iTestRunner->SetRunnerActive();
+// Start activeScheduler looping testcase lines
+__TRACE( KMessage, (_L("Start CActiveScheduler")));
+CActiveScheduler::Current()->Start();
+delete iTestRunner;
+iTestRunner = NULL;
+__TRACE( KMessage, ( _L("RunTestL: Done")));
+// Destroy locally defined variables
+iDefinedLocal.ResetAndDestroy();
+// Destroy function parsers (there shouldn't be any)
+iParserStack.ResetAndDestroy();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetTestModuleL
+Description: Load testmodule if not already loaded, otherwise return
+description of the loaded testmodule.
+Parameters:    TDesC& aModule: in: module name
+TDesC& aIniFile: in: ini file name
+Return Values: CTCTestModule*: pointer to testmodules description
+Errors/Exceptions: Leaves if CTCTestModule::NewL leaves
+Leaves if RPointerArray::Append fails
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TTestModule* CTestScripter::LoadTestModuleL( TDesC& aModule )
+{
+__TRACEFUNC();
+TInt count = iTestModules.Count();
+for( TInt i=0; i < count; i++ )
+{
+if( iTestModules[i]->ModuleName() == aModule )
+{
+// Found test module, return description
+__TRACE( KMessage,
+(_L("GetTestModuleL: Use already loaded TestModule (%S)"),
+&aModule ));
+return iTestModules[i];
+}
+}
+__TRACE( KMessage, (_L("GetTestModuleL: Load new TestModule (%S)"),
+&aModule ));
+TTestModule* module = new (ELeave) TTestModule();
+CleanupStack::PushL( module );
+module->ModuleName() = aModule;
+User::LeaveIfError( iTestModules.Append( module ) );
+CleanupStack::Pop( module );
+TInt ret = module->iLibrary.Load ( aModule );
+if( ret != KErrNone )
+{
+__TRACE( KMessage, (_L("GetTestModuleL: %S loading failed"),
+&aModule ));
+TestModuleIf().Printf( KMessage, _L("Load dll"), _L("%S failed"),
+&aModule );
+User::Leave( ret );
+}
+// Get pointer to first exported function
+module->iLibEntry = (CInterfaceFactory) module->iLibrary.Lookup(1);
+return module;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: CreateObjectL
+Description: Load testmodule if not already loaded, otherwise return
+description of the loaded testmodule.
+Parameters:    TDesC& aModule: in: module name
+TDesC& aObjectId: in: object id name
+Return Values: None
+Errors/Exceptions: Leaves on error
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestScripter::CreateObjectL( TDesC& aModule, TDesC& aObjectId )
+{
+__TRACEFUNC();
+// Load module and get pointer
+TTestModule* module = LoadTestModuleL( aModule );
+TTestObject* object = new (ELeave) TTestObject();
+CleanupStack::PushL( object );
+object->ObjectId() = aObjectId;
+User::LeaveIfError( iTestObjects.Append( object ) );
+CleanupStack::Pop( object );
+// Create object
+object->iScript = module->iLibEntry( TestModuleIf() );
+//User::LeaveIfNull ( object->iScript );
+if( object->iScript == NULL )
+{
+User::Leave( KErrGeneral );
+}
+// Create continue callback
+object->iContinue = CTestContinue::NewL( this, object );
+// Create function pointer operation to possible
+object->iScript->SetScripter( &CallBack, this );
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: CreateKernelObjectL
+Description: Load testdriver if not already loaded, otherwise return
+description of the loaded testdriver.
+Parameters:    TDesC& aDriver: in: driver name
+TDesC& aObjectId: in: object id name
+Return Values: None
+Errors/Exceptions: Leaves on error
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestScripter::CreateKernelObjectL( TDesC& aDriver, TDesC& aObjectId )
+{
+__TRACEFUNC();
+if( ( aDriver.Length() > KMaxName ) ||
+( aObjectId.Length() > KMaxName ) )
+{
+__TRACE( KError, (_L("CreateKernelObjectL: Max lenght exceeded") ) );
+User::Leave( KErrArgument );
+}
+TInt ret = User::LoadLogicalDevice( aDriver );
+if( ( ret != KErrNone ) && ( ret != KErrAlreadyExists ) )
+{
+__TRACE( KError,
+(_L("CreateKernelObjectL: User::LoadLogicalDevice failed %d"),
+ret ) );
+User::Leave( ret );
+}
+TTestObjectKernel* object = new (ELeave) TTestObjectKernel();
+CleanupStack::PushL( object );
+object->ObjectId() = aObjectId;
+object->LddName().Copy( aDriver );
+ret = object->KernelTestClass().Open(
+object->KernelTestClass().VersionRequired(),
+aDriver );
+if( ret != KErrNone )
+{
+__TRACE( KError,
+(_L("CreateKernelObjectL: KernelTestClass().Open failed %d"),
+ret ) );
+User::Leave( ret );
+}
+User::LeaveIfError( iTestObjects.Append( object ) );
+CleanupStack::Pop( object );
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetTestModuleL
+Description: Load testmodule if not already loaded, otherwise return
+description of the loaded testmodule.
+Parameters:    TDesC& aModule: in: module name
+TDesC& aIniFile: in: ini file name
+Return Values: CTCTestModule*: pointer to testmodules description
+Errors/Exceptions: Leaves if CTCTestModule::NewL leaves
+Leaves if RPointerArray::Append fails
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestScripter::DeleteObjectL( TDesC& aObjectId )
+{
+__TRACEFUNC();
+TInt count = iTestObjects.Count();
+for( TInt i=0; i < count; i++ )
+{
+if( iTestObjects[i]->ObjectId() == aObjectId )
+{
+TTestObjectBase* object = iTestObjects[i];
+iTestObjects.Remove( i );
+delete object;
+return KErrNone;
+}
+}
+return KErrNone;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetTest
+Description: Get test case from testcase array.
+Parameters:    TDesC& aTestId: in: TestId for testcase
+Return Values: CTCTestCase*: running/runned testcase
+NULL: Testcase with aTestId not running/runned
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TTestObjectBase* CTestScripter::GetObject( const TDesC& aObjectId )
+{
+__TRACEFUNC();
+TInt count = iTestObjects.Count();
+for( TInt i=0; i < count; i++ )
+{
+if( iTestObjects[i]->ObjectId() == aObjectId )
+{
+// Found testcase with specified TestId
+return iTestObjects[i];
+}
+}
+// Object with iTestObjects not found
+return NULL;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: CallTestClass
+Description: For sub classing operations.
+Parameters: const TDesC& aLine: in: script line
+Return Values: TInt: Symbian error code
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestScripter::CallTestClass( const TDesC& aLine )
+{
+CStifItemParser* item = CStifItemParser::NewL( aLine, 0, aLine.Length() );
+CleanupStack::PushL( item );
+TPtrC objectName;
+TInt ret( KErrNone );
+ret = item->GetString( _L( "" ), objectName );
+if( ret != KErrNone )
+{
+CleanupStack::PopAndDestroy( item);
+return ret;
+}
+TTestObjectBase* obj = GetObject( objectName );
+if( obj == NULL )
+{
+CleanupStack::PopAndDestroy(item );
+return KErrNotFound;
+}
+TRAPD( commandResult, commandResult = obj->RunMethodL( *item ) );
+CleanupStack::PopAndDestroy(item );
+return commandResult;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetTestScriptObject
+Description: Get object address.
+Parameters: const TDesC& aObjectName: in: object name
+Return Values: TInt: Symbian error code
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestScripter::GetTestScriptObject( const TDesC& aObjectName )
+{
+TTestObjectBase* objBase = GetObject( aObjectName );
+if( ( objBase == NULL ) ||
+( objBase->ObjectType() != TTestObjectBase::EObjectNormal ) )
+{
+return KErrNotFound;
+}
+TTestObject* object = ( TTestObject* )objBase;
+return (TInt) object->iScript;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: UpdateTestCaseResult
+Description: Updates result of test case. If there is already some
+description stored, it is put in the [] brackets.
+Parameters: const TInt aResult: in: error code
+const TDesC& aDescr: in: description
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestScripter::UpdateTestCaseResult(const TInt aResult, const TDesC& aDescr)
+{
+// Create buffer
+RBuf buf;
+TInt ret = buf.Create(iResult.iResultDes.Length() + aDescr.Length() + 5);
+if(ret != KErrNone)
+{
+__TRACE(KError, (_L("UpdateResultDescription: descriptor creation failed [%d]"), ret));
+return;
+}
+CleanupClosePushL(buf);
+// Update result
+iResult.iResult = aResult;
+if(iResult.iResultDes.Length() > 0)
+{
+buf.Format(_L("%S [%S]"), &aDescr, &iResult.iResultDes);
+}
+else
+{
+buf.Copy(aDescr);
+}
+SetResultDescription(buf);
+// Close buffer
+CleanupStack::PopAndDestroy(&buf);
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: SetResultDescription
+Description: Sets result description of test case.
+Parameters: const TDesC& aDescr: in: new description
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+EXPORT_C void CTestScripter::SetResultDescription(const TDesC& aDescr)
+{
+if(aDescr.Length() > KStifMaxResultDes)
+{
+iResult.iResultDes.Copy(aDescr.Mid(0, KStifMaxResultDes));
+}
+else
+{
+iResult.iResultDes.Copy(aDescr);
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: SetLocalValue
+Description: Internal fuction to set value of local variable defined in script
+Parameters:    const TDesC& aName: in: local variable name
+const TDesC& avalue: in: local variable value
+Return Values: KErrNone: Value is returned succesfully.
+KErrNotFound: Variable was not found
+Any other SymbianOS error
+-------------------------------------------------------------------------------
+*/
+EXPORT_C TInt CTestScripter::SetLocalValue(const TDesC& aName, const TDesC& aValue)
+{
+__TRACEFUNC();
+TInt count = iDefinedLocal.Count();
+for(TInt i = 0; i < count; i++)
+{
+if(iDefinedLocal[i]->Name() == aName)
+{
+iDefinedLocal[i]->SetValueL(const_cast<TDesC&>(aValue));
+return KErrNone;
+}
+}
+return KErrNotFound;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestScripter
+Method: GetLocalValue
+Description: Internal fuction to get value of local variable
+Parameters:    const TDesC& aName: in: local variable name
+const TDesC& avalue: in: local variable value
+Return Values: KErrNone: Value is returned succesfully.
+KErrNotFound: Variable was not found
+Any other SymbianOS error
+-------------------------------------------------------------------------------
+*/
+EXPORT_C TInt CTestScripter::GetLocalValue(const TDesC& aName, TDes& aValue)
+{
+__TRACEFUNC();
+TInt count = iDefinedLocal.Count();
+for(TInt i = 0; i < count; i++)
+{
+if(iDefinedLocal[i]->Name() == aName)
+{
+aValue.Copy(iDefinedLocal[i]->Value());
+return KErrNone;
+}
+}
+return KErrNotFound;
+}
+/*
+-------------------------------------------------------------------------------
+DESCRIPTION
+This module contains the implementation of CTestRunner class
+member functions. CTestRunner is used to execute TestScripter testcase by
+CTestScripter.
+-------------------------------------------------------------------------------
+*/
+// MACROS
+#ifdef LOGGER
+#undef LOGGER
+#endif
+#define LOGGER iTestScripter->iLog
+// ================= MEMBER FUNCTIONS =========================================
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: CTestRunner
+Description: Default constructor
+C++ default constructor can NOT contain any code, that
+might leave.
+Parameters: CTestScripter* aTestScripter: in: Backpointer to CTestScripter
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CTestRunner::CTestRunner( CTestScripter* aTestScripter ):
+CActive(  CActive::EPriorityHigh ), // Executed with highest priority
+iState( ERunnerIdle ),
+iTestScripter( aTestScripter ),
+iRemainingTimeValue( 0 )
+{
+CActiveScheduler::Add( this );
+__TRACEFUNC();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: ConstructL
+Description: Symbian OS second phase constructor
+Symbian OS default constructor can leave.
+Parameters:    None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::ConstructL()
+{
+iPauseTimer.CreateLocal();
+// Initiaze all OOM related variables to default.
+OOMHeapToNormal();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: NewL
+Description: Two-phased constructor.
+Parameters: CTestScripter* aTestScripter: in: Backpointer to CTestScripter
+Return Values: CTestRunner*: new object
+Errors/Exceptions: Leaves if new or ConstructL leaves
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CTestRunner* CTestRunner::NewL( CTestScripter* aTestScripter )
+{
+CTestRunner* self = new (ELeave) CTestRunner( aTestScripter );
+CleanupStack::PushL( self );
+self->ConstructL();
+CleanupStack::Pop();
+return self;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: ~CTestRunner
+Description: Destructor
+Parameters:    None
+Return Values: None
+Errors/Exceptions: None
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+CTestRunner::~CTestRunner()
+{
+__TRACEFUNC();
+Cancel();
+iPauseTimer.Close();
+delete iLine;
+iLine = NULL;
+TInt count = iEventArray.Count();
+TEventIf event( TEventIf::ERelEvent );
+for( TInt i = 0; i < count; i++ )
+{
+HBufC* tmp = iEventArray[0];
+event.SetName( iEventArray[0]->Des() );
+iEventArray.Remove(0);
+		if( iTestScripter != NULL )
+			{
+			iTestScripter->TestModuleIf().Event( event );
+			}
+delete tmp;
+}
+iTestCaseResults.Reset();
+iEventArray.ResetAndDestroy();
+iTestCaseResults.Close();
+iEventArray.Close();
+// Reset test case allow result to CTestModuleIf side too. This is
+// used in TAL-TA5L macro handling.
+	if( iTestScripter != NULL )
+		{
+		User::LeaveIfError(
+			iTestScripter->TestModuleIf().ResetAllowResult() );
+		}
+// Stop all remaining interference object
+TInt count_inter = iTestInterferenceArray.Count();
+for( TInt a = 0; a < count_inter; a++ )
+{
+		if( iTestInterferenceArray[a] != NULL )
+			{
+			iTestInterferenceArray[a]->iInterference->Stop();
+			}
+}
+iTestInterferenceArray.ResetAndDestroy();
+iTestInterferenceArray.Close();
+// Stop all remaining measurement modules
+const TInt count_meas = iTestMeasurementArray.Count();
+for( TInt b = 0; b < count_meas; b++ )
+{
+		if( iTestMeasurementArray[b] != NULL )
+			{
+			iTestMeasurementArray[b]->iMeasurement->Stop();
+			}
+}
+iTestMeasurementArray.ResetAndDestroy();
+iTestMeasurementArray.Close();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: RunL
+Description: Derived from CActive, handles testcase execution.
+Parameters:    None.
+Return Values: None.
+Errors/Exceptions: Leaves on error situations.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::RunL()
+{
+__TRACEFUNC();
+__TRACE( KMessage, (_L("CTestRunner::RunL: [%d] "), iStatus.Int() ));
+// Check if we need to Pause test case again
+if( iStatus == KErrNone && iRemainingTimeValue > 0 )
+{
+// Maximum time for one RTimer::After request
+TInt maximumTime = KMaxTInt / 1000;
+__TRACE( KMessage, (_L("CTestRunner::RunL: Going to reissue After request ") ) );
+__TRACE( KMessage, (_L("CTestRunner::RunL: iRemainingTimeValue = %d"), iRemainingTimeValue ) );
+if( iRemainingTimeValue < maximumTime )
+{
+iPauseTimer.After( iStatus, ( iRemainingTimeValue * 1000  ) );
+iRemainingTimeValue = 0;
+}
+else
+{
+iRemainingTimeValue -= maximumTime;
+iPauseTimer.After( iStatus, ( maximumTime * 1000 ) );
+}
+SetActive();
+}
+else
+{
+TBool continueTask = EFalse;
+User::LeaveIfError( iStatus.Int() );
+if( ( iTestScripter == NULL ) ||
+( iTestScripter->iCurrentParser == NULL ) )
+{
+__TRACE( KError, (_L("CTestRunner invalid arguments")));
+User::Leave( KErrGeneral );
+}
+iState = ERunnerIdle;
+// Get next execution line from configuration section
+TPtrC line;
+// If current parser already has read the first line, then read next line.
+// Otherwise read the first line.
+if(iTestScripter->iCurrentParserReadFirstLine && iTestScripter->iCurrentParser->GetNextLine(line) == KErrNone
+|| !iTestScripter->iCurrentParserReadFirstLine && iTestScripter->iCurrentParser->GetLine(KNullDesC, line) == KErrNone)
+{
+iTestScripter->iCurrentParserReadFirstLine = ETrue;
+// Got new execution line
+__TRACE( KMessage, (_L("Executing line [%S]"), &line));
+CStifItemParser* item = PreprocessLineL( line );
+CleanupStack::PushL( item );
+TPtrC keyword;
+// Get first word from line, i.e. keyword
+User::LeaveIfError( item->GetString( _L(""), keyword ) );
+__TRACE( KMessage, (_L("CTestRunner execute %S"), &keyword ));
+// Execute script line
+continueTask = ExecuteLineL( keyword, item );
+__TRACE( KMessage, (_L("CTestRunner %S executed"), &keyword ));
+if( continueTask )
+{
+__TRACE( KMessage, (_L("RunL: continueTask")));
+// Set CTestRunner active again to perform
+// next execution line
+// from testcase section
+SetRunnerActive();
+}
+CleanupStack::PopAndDestroy( item );
+}
+else // Stop execution if end of test case
+{
+__TRACE( KMessage, (_L("Executing line: no more lines from this section")));
+// There is no more lines in current parser, but it needs to be
+// checked if the parser is not taken for function (sub).
+// If this is true, then we have to get back to the parser which
+// has called the function.
+TInt lastParserIndex = iTestScripter->iParserStack.Count() - 1;
+if(lastParserIndex >= 0)
+{
+// Delete current (the last one) parser
+delete iTestScripter->iParserStack[lastParserIndex];
+iTestScripter->iParserStack.Remove(lastParserIndex);
+if(lastParserIndex >= 1) //There is some other parser on the stack
+{
+iTestScripter->iCurrentParser = iTestScripter->iParserStack[lastParserIndex - 1];
+}
+else //The parser stack is empty
+{
+iTestScripter->iCurrentParser = iTestScripter->iSectionParser;
+}
+__TRACE(KMessage, (_L("Returning to calling parser stored on section stack")));
+// Continue with the test case
+__TRACE(KMessage, (_L("RunL: continueTask (end of Sub reached)")));
+SetRunnerActive();
+return;
+}
+// No more execution lines in testcase section
+__TRACE( KMessage,
+(_L("CTestRunner::RunL: Testcase script done") ));
+iTestScripter->TestModuleIf().Printf( KPrintPriLow,
+_L("RunL"), _L("Script done"));
+__TRACE( KMessage,
+(_L("RunL: All TestCases done, stop CActiveScheduler")));
+CActiveScheduler::Current()->Stop();
+// Now testcase section is executed,
+// so CTestRunner has done its job and stops
+}
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: DoCancel
+Description: Derived from CActive handles the Cancel
+Parameters:    None.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::DoCancel()
+{
+__TRACEFUNC();
+__TRACE( KMessage, (_L("CTestRunner::DoCancel")));
+iTestScripter->TestModuleIf().Printf( KPrintPriLow, _L("Runner"), _L("DoCancel"));
+if( iState == ERunnerPaused )
+{
+iPauseTimer.Cancel();
+}
+CActiveScheduler::Current()->Stop();
+iState = ERunnerCancel;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: RunError
+Description: Derived from CActive handles errors from active handler.
+Parameters:    TInt aError: in: error from CActive
+Return Values: KErrNone: success
+Errors/Exceptions: None.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestRunner::RunError( TInt aError )
+{
+__TRACEFUNC();
+__TRACE( KMessage, (_L("CTestRunner::RunError %d"), aError));
+if ( iRunErrorMessage.Length() != 0 )
+	{
+	    iTestScripter->TestModuleIf().Printf( KPrintPriLow, _L("Runner"),
+	            _L("RunError : %S"), &iRunErrorMessage );
+	    iRunErrorMessage = KNullDesC;
+	}
+else
+	{
+	    iTestScripter->TestModuleIf().Printf( KPrintPriLow, _L("Runner"),
+	            _L("RunError"));
+	}
+iState = ERunnerError;
+// Return error from here, if none given from execution
+if( iTestScripter->iResult.iResult == KErrNone )
+{
+iTestScripter->UpdateTestCaseResult(aError, _L("CTestRunner::RunError"));
+}
+CActiveScheduler::Current()->Stop();
+return KErrNone;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: PreprocessLineL
+Description: Preprocesses script line
+Parameters:  TPtrC& line: in: script line
+CStifItemParser*& aItem: out: New CItemParser for script line.
+Return Values: HBufC* pointer if new memory that has been allocated
+Errors/Exceptions: Leaves on error situations.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CStifItemParser* CTestRunner::PreprocessLineL( TDesC& line )
+{
+CStifItemParser* item = NULL;
+TPtrC tmp;
+TInt len = 0;
+TInt ret = 0;
+// Decide how long buffer should be allocated
+if( line.Length() < KMaxName/2 )
+{
+len = KMaxName;
+}
+else
+{
+len = line.Length() + KMaxName;
+}
+delete iLine;
+iLine = 0;
+iLine = HBufC::NewL(len);
+TPtr parsedLine(iLine->Des());
+len = 0;
+HBufC* sourceLine = line.AllocL();
+CleanupStack::PushL(sourceLine);
+//Check for local variable definitions
+item = CStifItemParser::NewL(sourceLine->Des(), 0, sourceLine->Length());
+CleanupStack::PushL(item);
+ret = item->GetString(KNullDesC, tmp);
+TBool isVarDefinition = (tmp == TTestKeywords::Keyword(TTestKeywords::EVar));
+if(!isVarDefinition)
+{
+while( ret == KErrNone )
+{
+len += CheckDefinedLocals(tmp);
+if((parsedLine.Length() + tmp.Length() + 1) > parsedLine.MaxLength())
+{
+// Allocate bigger buffer
+HBufC* tmpBuf = HBufC::NewL(parsedLine.MaxLength() + KMaxName);
+CleanupStack::PushL(tmpBuf);
+TPtrC ptr(iLine->Des());
+parsedLine.Set(tmpBuf->Des());
+parsedLine.Copy(ptr);
+delete iLine;
+iLine = tmpBuf;
+CleanupStack::Pop(tmpBuf);
+}
+parsedLine.Append(tmp);
+ret = item->GetNextString(tmp);
+if(ret == KErrNone)
+{
+// Add space only if we got new string
+parsedLine.Append(_L(" "));
+}
+}
+CleanupStack::PopAndDestroy(item);
+item = NULL;
+CleanupStack::PopAndDestroy(sourceLine);
+sourceLine = NULL;
+//Prepare data for checking for defines
+sourceLine = parsedLine.AllocL();
+CleanupStack::PushL(sourceLine);
+parsedLine.Zero();
+item = CStifItemParser::NewL(sourceLine->Des(), 0, sourceLine->Length());
+CleanupStack::PushL(item);
+ret = item->GetString(KNullDesC, tmp);
+}
+//Check for defines
+while(ret == KErrNone)
+{
+if(!isVarDefinition)
+{
+len += CheckDefined(tmp);
+}
+if((parsedLine.Length() + tmp.Length() + 1) > parsedLine.MaxLength())
+{
+// Allocate bigger buffer
+HBufC* tmpBuf = HBufC::NewL(parsedLine.MaxLength() + KMaxName);
+CleanupStack::PushL(tmpBuf);
+TPtrC ptr(iLine->Des());
+parsedLine.Set(tmpBuf->Des());
+parsedLine.Copy(ptr);
+delete iLine;
+iLine = tmpBuf;
+CleanupStack::Pop(tmpBuf);
+}
+parsedLine.Append(tmp);
+ret = item->GetNextString(tmp);
+if( ret == KErrNone )
+{
+// Add space only if we got new string
+parsedLine.Append(_L(" "));
+}
+}
+//Cleaning...
+CleanupStack::PopAndDestroy(item);
+item = NULL;
+CleanupStack::PopAndDestroy(sourceLine);
+sourceLine = NULL;
+__TRACE(KMessage, (_L("Preprocessed line [%S]"), &parsedLine));
+item = CStifItemParser::NewL( parsedLine, 0, parsedLine.Length() );
+return item;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: CheckDefined
+Description: Check if aWord is some defined word
+Parameters:  TPtrC& aWord: inout: Parsed word, defined or original returned
+Return Values: TInt: length diference between new and old word
+Errors/Exceptions: None.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestRunner::CheckDefined( TPtrC& aWord )
+{
+TInt len = 0;
+TInt i = 0;
+// KLoopCounter word changing to current loop count value.
+if( aWord == KLoopCounter )
+{
+iLoopCounterDes.Zero();
+iLoopCounterDes.AppendNum( iLoopCounter );
+len = iLoopCounterDes.Length() - aWord.Length();
+aWord.Set( iLoopCounterDes );
+return len;
+}
+// First, check values defined in test case file
+TInt count = iTestScripter->iDefinedRuntime.Count();
+for( i = 0; i < count; i++ )
+{
+if( iTestScripter->iDefinedRuntime[i]->Name() == aWord )
+{
+len = iTestScripter->iDefinedRuntime[i]->Value().Length() - aWord.Length();
+aWord.Set( iTestScripter->iDefinedRuntime[i]->Value() );
+return len;
+}
+}
+// Second, check values defined in test module initialization file
+count = iTestScripter->iDefinedIni.Count();
+for( i = 0; i < count; i++ )
+{
+if( iTestScripter->iDefinedIni[i]->Name() == aWord )
+{
+len = iTestScripter->iDefinedIni[i]->Value().Length() - aWord.Length();
+aWord.Set( iTestScripter->iDefinedIni[i]->Value() );
+return len;
+}
+}
+return len;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: CheckDefinedLocals
+Description: Check if aWord is a local variable
+Parameters:  TPtrC& aWord: inout: Parsed word, defined or original returned
+Return Values: TInt: length diference between new and old word
+Errors/Exceptions: None.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestRunner::CheckDefinedLocals( TPtrC& aWord )
+{
+TInt len = 0;
+TInt i = 0;
+TInt count = iTestScripter->iDefinedLocal.Count();
+for(i = 0; i < count; i++)
+{
+if(iTestScripter->iDefinedLocal[i]->Name() == aWord)
+{
+len = iTestScripter->iDefinedLocal[i]->Value().Length() - aWord.Length();
+aWord.Set(iTestScripter->iDefinedLocal[i]->Value());
+return len;
+}
+}
+return len;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: ExecuteLineL
+Description: Executes script line
+Parameters:    TDesC& aKeyword: in: keyword string
+CStifItemParser* aItem: in: script line
+Return Values: ETrue: continue script file execution
+EFalse: stop script file execution
+Errors/Exceptions: Leaves on error situations.
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+TBool CTestRunner::ExecuteLineL( TDesC& aKeyword,
+CStifItemParser* aItem )
+{
+_LIT( KErrMsgDeleteNoParam, "Delete: Name of object is not defined" );
+_LIT( KErrMsgDeleteObjNotFound, "Delete: Can't delete object %S. Object does not exists." );
+_LIT( KErrMsgPauseTimeoutNotDefined, "Pause: No timeout value given or value has invalid format" );
+_LIT( KErrMsgPauseTimeoutNotPositive, "Pause: Timeout value can't be <0" );
+_LIT( KErrMsgCreateTestModeleNotDefined, "Create: Name of test module is not defined" );
+_LIT( KErrMsgCreateObjectIdNotDefined, "Create: Name of test module object is not defined" );
+_LIT( KErrMsgCreateKernelDriverNotDefined, "CreateKernel: Kernel driver name is not defined" );
+_LIT( KErrMsgCreateKernelObjectNameNotDefined, "CreateKernel: Kernel driver object name is not defined" );
+_LIT( KErrMsgCreateKernelFailed, "CreateKernel: Can't creeate kernel driver %S" );
+_LIT( KErrMsgWaitTestClassNameNotDefined, "WaitTestClass: Test class object name is not defined" );
+_LIT( KErrMsgWaitTestClassObjNotFound, "WaitTestClass: Test class object %S does not exists" );
+_LIT( KErrMsgLoopNested, "Loop: Nested loop are not supported" );
+_LIT( KErrMsgLoopNoParam, "Loop: No loop iterations count given or value has invalid format" );
+_LIT( KErrMsgLoopInvalidParam, "Loop: Loop count must be >0" );
+_LIT( KErrMsgLoopUnknownUnexpectedOption, "Loop: Unknown or unexpected loop option");
+_LIT( KErrMsgEndLoopNotOpened, "Endloop: Can't execute endloop. No opened loop exists" );
+_LIT( KErrMsgBringToForegroundNotSupported, "BringToForeground: BringToForeground is not supported in non s60 environment" );
+_LIT( KErrMsgSendToBackgroundNotSupported, "SendToBackground: SendToBackground is not supported in non s60 environment" );
+_LIT( KErrMsgPressKeyNotSupported, "PressKey: PressKey is not supported in non s60 environment. Check if .cfg file name contains ui_ prefix and UITestingSupport= YES entry is defined in TestFrameworkd.ini" );
+_LIT( KErrMsgTypeTextNotSupported, "TypeText: TypeText is not supported in non s60 environment. Check if .cfg file name contains ui_ prefix and UITestingSupport= YES entry is defined in TestFrameworkd.ini" );
+_LIT( KErrMsgSendPointerEventNotSupported, "SendPointerEvent: SendPointerEvent is not supported in non s60 environment. Check if .cfg file name contains ui_ prefix and UITestingSupport= YES entry is defined in TestFrameworkd.ini" );
+_LIT( KErrVarNameError, "Variable: Could not get variable name");
+_LIT( KErrVarValueError, "Variable: Value too long");
+_LIT( KErrSubNameError, "Sub: Could not get name of Sub to be called");
+_LIT( KErrSubGetError, "Sub: Could not get Sub section");
+iRunErrorMessage = KNullDesC;
+TBool continueTask = ETrue;
+TInt key = TTestKeywords::Parse( aKeyword, TTestKeywords::Keyword );
+switch( key )
+{
+// Test case execution control cases
+case TTestKeywords::ECreate:
+case TTestKeywords::ECreateX:
+{
+TPtrC tmp;
+TName module;
+// Testmodule name
+TInt ret = aItem->GetNextString( tmp );
+if ( ret != KErrNone )
+	{
+	iRunErrorMessage = KErrMsgCreateTestModeleNotDefined;
+	User::Leave( KErrArgument );
+	}
+TParse p;
+p.Set( tmp, NULL, NULL );
+// Check if exists in module name
+if( p.ExtPresent() )
+{
+module.Copy( tmp );
+}
+else
+{
+// No extension in module name, add it here
+_LIT( KDllExtension, ".dll");
+module.Copy( tmp );
+module.Append( KDllExtension );
+}
+// objectid
+ret = aItem->GetNextString( tmp );
+if ( ret != KErrNone )
+	{
+	iRunErrorMessage = KErrMsgCreateObjectIdNotDefined;
+	User::Leave( KErrArgument );
+	}
+__TRACE( KMessage, (_L("%S %S"), &aKeyword, &tmp));
+iTestScripter->TestModuleIf().Printf( KPrintPriLow, _L("Runner"),
+_L("%S %S"), &aKeyword, &tmp);
+iTestScripter->CreateObjectL( module, tmp );
+}
+break;
+case TTestKeywords::ECreateKernel:
+{
+TPtrC obj;
+TPtrC driver;
+// Testdriver name
+TInt ret = aItem->GetNextString( driver );
+if ( ret != KErrNone )
+	{
+	iRunErrorMessage = KErrMsgCreateKernelDriverNotDefined;
+	User::Leave( ret );
+	}
+// objectid
+ret = aItem->GetNextString( obj );
+if ( ret != KErrNone )
+	{
+	iRunErrorMessage = KErrMsgCreateKernelObjectNameNotDefined;
+	User::Leave( ret );
+	}
+__TRACE( KMessage, (_L("%S %S"), &aKeyword, &obj));
+iTestScripter->TestModuleIf().Printf( KPrintPriLow, _L("Runner"),
+_L("%S %S"), &aKeyword, &obj);
+TInt leaveErr = KErrNone;
+TRAP( leaveErr, iTestScripter->CreateKernelObjectL( driver, obj ));
+if ( leaveErr != KErrNone )
+	{
+	iRunErrorMessage.Format( KErrMsgCreateKernelFailed, &driver );
+User::Leave( leaveErr );
+	}
+}
+break;
+case TTestKeywords::EDelete:
+{
+TPtrC tmp;
+// objectid
+TInt ret = aItem->GetNextString( tmp );
+if ( ret != KErrNone )
+	{
+iRunErrorMessage = KErrMsgDeleteNoParam;
+	User::Leave( ret );
+	}
+__TRACE( KMessage, (_L("%S %S"), &aKeyword, &tmp));
+iTestScripter->TestModuleIf().Printf( KPrintPriLow, _L("Runner"),
+_L("%S %S"), &aKeyword, &tmp);
+ret = iTestScripter->DeleteObjectL( tmp );
+if ( ret != KErrNone )
+	{
+	iRunErrorMessage.Format( KErrMsgDeleteObjNotFound, &tmp );
+	User::Leave( ret );
+	}
+}
+break;
+case TTestKeywords::ERequest:
+case TTestKeywords::EWait:
+case TTestKeywords::ERelease:
+case TTestKeywords::ESet:
+case TTestKeywords::EUnset:
+continueTask = ExecuteEventL( aKeyword, aItem );
+break;
+case TTestKeywords::EPrint:
+{
+__TRACE( KMessage, (_L("%S"), &aKeyword));
+iTestScripter->TestModuleIf().Printf( KPrintPriLow, _L("Runner"),
+_L("%S"), &aKeyword );
+RBuf buf;
+buf.CreateL(1024);
+CleanupClosePushL(buf);
+TPtrC tmp;
+while( aItem->GetNextString( tmp ) == KErrNone )
+{
+if( buf.Length() + tmp.Length() >= buf.MaxLength() )
+{
+buf.ReAllocL(buf.MaxLength() + tmp.Length() * 10);
+}
+buf.Append( tmp );
+buf.Append( _L(" ") );
+}
+iTestScripter->TestModuleIf().Printf( KPrintPriNorm,
+_L("Test"),
+_L("%S"), &buf);
+RDebug::Print( _L("Print : Test : %S"), &buf );
+CleanupStack::PopAndDestroy(&buf);
+}
+break;
+case TTestKeywords::EAllowNextResult:
+{
+AddTestCaseResultL( aItem );
+}
+break;
+case TTestKeywords::EWaitTestClass:
+{
+// Just stop script running, continue event is signaled
+// from test class with specified object name
+TPtrC objectName;
+// Get Object name
+TInt ret = aItem->GetNextString( objectName );
+if ( ret != KErrNone )
+	{
+	iRunErrorMessage = KErrMsgWaitTestClassNameNotDefined;
+	User::Leave( ret );
+	}
+TTestObjectBase* obj = iTestScripter->GetObject ( objectName );
+//User::LeaveIfNull( obj );
+if( obj == NULL )
+{
+	iRunErrorMessage.Format( KErrMsgWaitTestClassObjNotFound, &objectName );
+User::Leave( KErrGeneral );
+}
+continueTask = obj->Wait();
+if( continueTask )
+{
+// If OOM testing is ongoing ignore result check(given by user)
+if( !iTestScripter->iOOMIgnoreFailure )
+{
+if( iTestCaseResults.Count() == 0 )
+{
+// KErrNone is the default result expected
+// if nothing else is given
+User::LeaveIfError( iTestCaseResults.Append(
+KErrNone ) );
+}
+if( iTestCaseResults.Find( obj->iAsyncResult ) < 0 )
+{
+__TRACE( KError, ( _L("Command for [%S] failed (%d)"),
+&objectName, obj->iAsyncResult ));
+iTestScripter->UpdateTestCaseResult(obj->iAsyncResult, _L("CTestRunner::ExecuteLineL: asynchronous method returned error"));
+// Stops execution from CTestRunner::RunError
+User::Leave( KErrGeneral );
+}
+}
+else
+{
+__TRACE( KMessage, (
+_L( "OOM test: 'oomignorefailure' is ON, test case result will reset" ) ) );
+}
+iTestCaseResults.Reset();
+// Reset test case allow result to CTestModuleIf side too. This is
+// used in TAL-TA5L macro handling.
+User::LeaveIfError(
+iTestScripter->TestModuleIf().ResetAllowResult() );
+}
+}
+break;
+case TTestKeywords::EPause:
+{
+// Maximum time for one RTimer::After request
+TInt maximumTime = KMaxTInt / 1000;
+// Set iRemainingTimeValue to zero
+iRemainingTimeValue = 0;
+TInt timeout;
+// Read valid results to timeout
+if( aItem->GetNextInt( timeout ) != KErrNone )
+{
+__TRACE( KError, (_L("CTestRunner::ExecuteLineL: No timeout value given for pause")));
+iRunErrorMessage = KErrMsgPauseTimeoutNotDefined;
+User::Leave( KErrArgument );
+}
+// Test case file parsing was success
+__TRACE( KMessage, (_L("CTestRunner::ExecuteLineL: Pause for %d milliseconds"), timeout));
+if( timeout < 0 )
+{
+__TRACE( KError, (_L("CTestRunner::ExecuteLineL: Given pause value < 0")));
+iRunErrorMessage = KErrMsgPauseTimeoutNotPositive;
+User::Leave( KErrArgument );
+}
+else
+{
+// Check is pause value suitable for RTimer::After
+if( timeout < maximumTime )
+{
+iPauseTimer.After( iStatus, ( timeout * 1000  ) );
+}
+else
+{
+// Given pause value after multiplication with 1000 is
+// larger than KMaxTInt, so we need to split it and
+// re-request After with remaining value from RunL
+iRemainingTimeValue =  timeout - maximumTime;
+iPauseTimer.After( iStatus, maximumTime * 1000 );
+}
+SetActive();
+// Stop execution after paused for given timeout
+continueTask = EFalse;
+}
+}
+break;
+case TTestKeywords::ELoop:
+{
+if( iLoopTimes > 0 )
+{
+__TRACE( KError, (_L("ExecuteLineL: Nested loop are not supported")));
+iRunErrorMessage = KErrMsgLoopNested;
+User::Leave( KErrNotSupported );
+}
+iLoopTimes = 0;
+iLoopCounter = 0;
+iTimedLoop = EFalse;
+if( aItem->GetNextInt( iLoopTimes ) != KErrNone )
+{
+__TRACE( KError, (_L("ExecuteLineL: No loop count value given for loop")));
+iRunErrorMessage = KErrMsgLoopNoParam;
+User::Leave( KErrArgument );
+}
+if( iLoopTimes < 1 )
+	{
+__TRACE( KError, (_L("ExecuteLineL: Loop count must be >0")));
+iRunErrorMessage = KErrMsgLoopInvalidParam;
+User::Leave( KErrArgument );
+	}
+__TRACE( KMessage, (_L("ExecuteLineL: Loop for %d times" ), iLoopTimes ) );
+//Check loop options
+TPtrC option;
+TInt ret = aItem->GetNextString(option);
+if(ret == KErrNone)
+{
+if(option.Compare(_L("msec")) == 0) //time loop option
+{
+iTimedLoop = ETrue;
+iStartTime.HomeTime();
+iExpectedLoopTime = TInt64(iLoopTimes) * TInt64(1000); //convert to micro seconds
+__TRACE(KMessage, (_L("ExecuteLineL: Timed loop for %d msec" ), iLoopTimes));
+ret = aItem->GetNextString(option); //Get next option
+}
+}
+if(ret == KErrNone)
+{
+__TRACE( KError, (_L("ExecuteLineL: Unknown or unexpected loop option [%S]"), &option));
+iRunErrorMessage = KErrMsgLoopUnknownUnexpectedOption;
+User::Leave( KErrNotSupported );
+}
+iLoopStartPos = iTestScripter->iCurrentParser->GetPosition();
+}
+break;
+case TTestKeywords::EEndLoop:
+{
+if( iLoopTimes == 0 )
+	{
+	__TRACE( KError, (_L("ExecuteLineL: Can't execute endloop. No opened loop exists")));
+	iRunErrorMessage = KErrMsgEndLoopNotOpened;
+	User::Leave( KErrNotFound );
+	}
+iLoopCounter++;
+__TRACE( KMessage,
+(_L("ExecuteLineL: Loop executed for %d times" ),
+iLoopCounter ) );
+TTime currTime;
+currTime.HomeTime();
+if(((!iTimedLoop) && (iLoopCounter < iLoopTimes)) //Normal loop
+||
+iTimedLoop && (currTime.MicroSecondsFrom(iStartTime) < iExpectedLoopTime)) //Timed loop
+{
+// Go to beginning of the loop
+User::LeaveIfError(
+iTestScripter->iCurrentParser->SetPosition( iLoopStartPos ));
+}
+else
+{
+// End looping
+iLoopCounter = 0;
+iLoopTimes = 0;
+iLoopStartPos = 0;
+}
+}
+break;
+case TTestKeywords::ETimeout:
+case TTestKeywords::EPriority:
+// not used here
+break;
+case TTestKeywords::EOOMIgnoreFailure:
+{
+OOMIgnoreFailureL( aItem );  // Handle parsing
+break;
+}
+case TTestKeywords::EOOMHeapFailNext:
+{
+OOMHeapFailNextL( aItem );   // Handle parsing
+break;
+}
+case TTestKeywords::EOOMHeapSetFail:
+{
+OOMHeapSetFailL( aItem );    // Handle parsing
+break;
+}
+case TTestKeywords::EOOMHeapToNormal:
+{
+// Initialize all OOM related variables back to default.
+OOMHeapToNormal();
+__TRACE( KMessage, (
+_L( "'oomheaptonormal' called, OOM initialization or ending OOM test") ) );
+break;
+}
+case TTestKeywords::ETestInterference:
+{
+TestInterferenceL( aItem );  // Handle parsing
+break;
+}
+case TTestKeywords::EMeasurement:
+{
+MeasurementL( aItem );      // Handle parsing
+break;
+}
+case TTestKeywords::EAllowErrorCodes:
+{
+// Check is KErrNone already appended to iTestCaseResults array.
+if( iTestCaseResults.Find( KErrNone ) < 0 )
+{
+// 'allowerrorcodes' keyword sets KErrNone as a default
+User::LeaveIfError( iTestCaseResults.Append( KErrNone ) );
+// Set test case allow result to CTestModuleIf side too. This
+// is used in TAL-TA5L macro handling.
+User::LeaveIfError(
+iTestScripter->TestModuleIf().SetAllowResult( KErrNone ) );
+}
+// Set user given specific error code to be allowed.
+AddTestCaseResultL( aItem );
+}
+break;
+case TTestKeywords::EBringToForeground:
+	   {
+	   if ( iTestScripter->TestModuleIf().UITesting() == true )
+		   {
+		   iTestScripter->TestModuleIf().GetUiEnvProxy()->BringToForeground();
+		   }
+	   else
+		   {
+	           	__TRACE( KError, (_L("ExecuteLineL: Can't execute bringtoforeground in non s60 environment. Check if .cfg file name contains ui_ prefix and UITestingSupport= YES entry is defined in TestFrameworkd.ini")));
+	        	iRunErrorMessage = KErrMsgBringToForegroundNotSupported;
+	        	User::Leave( KErrNotSupported );
+		   }
+	   }
+		break;
+case TTestKeywords::ESendToBackground:
+	   {
+	   if ( iTestScripter->TestModuleIf().UITesting() == true )
+		   {
+		   iTestScripter->TestModuleIf().GetUiEnvProxy()->SendToBackground();
+		   }
+	   else
+		   {
+	           	__TRACE( KError, (_L("ExecuteLineL: Can't execute sendtobackground in non s60 environment. Check if .cfg file name contains ui_ prefix and UITestingSupport= YES entry is defined in TestFrameworkd.ini")));
+	        	iRunErrorMessage = KErrMsgSendToBackgroundNotSupported;
+	        	User::Leave( KErrNotSupported );
+		   }
+	   }
+		break;
+case TTestKeywords::EPressKey:
+	   {
+	   if ( iTestScripter->TestModuleIf().UITesting() == true )
+		   {
+		   continueTask = PressKeyL( aItem );
+		   }
+	   else
+		   {
+		   __TRACE( KError, (_L("ExecuteLineL: Can't execute presskey in non s60 environment. Check if .cfg file name contains ui_ prefix and UITestingSupport= YES entry is defined in TestFrameworkd.ini")));
+		   iRunErrorMessage = KErrMsgPressKeyNotSupported;
+		   User::Leave( KErrNotSupported );
+		   }
+	   // Check if it was global or local presskey
+	   if ( !continueTask )
+		   {
+	           // Stop execution after key is pressed and wait until it is handled
+	           SetActive();
+		   }
+	   }
+		break;
+case TTestKeywords::ETypeText:
+	   {
+	   if ( iTestScripter->TestModuleIf().UITesting() == true )
+		   {
+		   continueTask = TypeTextL( aItem );
+		   }
+	   else
+		   {
+		   __TRACE( KError, (_L("ExecuteLineL: Can't execute typetext in non s60 environment. Check if .cfg file name contains ui_ prefix and UITestingSupport= YES entry is defined in TestFrameworkd.ini")));
+		   iRunErrorMessage = KErrMsgTypeTextNotSupported;
+		   User::Leave( KErrNotSupported );
+		   }
+	   // Check if it was global or local typetext
+	   if ( !continueTask )
+		   {
+	           // Stop execution after key is pressed and wait until it is handled
+	           SetActive();
+		   }
+	   }
+		break;
+case TTestKeywords::EVar:
+{
+TName name;
+TName buf;
+TPtrC tmp;
+//Get variable name
+if(aItem->GetNextString(tmp) == KErrNone)
+{
+name.Copy(tmp);
+}
+else
+{
+//Error when getting variable name
+__TRACE(KError, (_L("ExecuteLineL: Could not read variable name")));
+iRunErrorMessage = KErrVarNameError;
+User::Leave(KErrArgument);
+}
+//Get value for variable
+while(aItem->GetNextString(tmp) == KErrNone)
+{
+if(buf.Length() + tmp.Length() >= buf.MaxLength())
+{
+//Error when getting variable name
+__TRACE(KError, (_L("ExecuteLineL: Variable value too long")));
+iRunErrorMessage = KErrVarValueError;
+User::Leave(KErrArgument);
+}
+buf.Append(tmp);
+buf.Append(_L(" "));
+}
+//Remove last space
+if(buf.Length() > 0)
+{
+buf.SetLength(buf.Length() - 1);
+}
+//Store local variable
+TInt count = iTestScripter->iDefinedLocal.Count();
+TInt i;
+for(i = 0; i < count; i++)
+{
+if(iTestScripter->iDefinedLocal[i]->Name() == name)
+{
+// Update existing
+iTestScripter->iDefinedLocal[i]->SetValueL(buf);
+__TRACE(KMessage, (_L("Update local variable [%S]: [%S]"), &name, &buf));
+break;
+}
+}
+if(i == count)
+{
+// New define, store it
+CDefinedValue* define = CDefinedValue::NewL(name, buf);
+CleanupStack::PushL(define);
+User::LeaveIfError(iTestScripter->iDefinedLocal.Append(define));
+CleanupStack::Pop(define);
+__TRACE(KMessage, (_L("Add local variable [%S]: [%S]"), &name, &buf));
+}
+}
+break;
+case TTestKeywords::ECallSub:
+{
+// Get sub name
+TPtrC subName;
+//Get sub name
+TInt err = aItem->GetNextString(subName);
+if(err != KErrNone)
+{
+//Error when getting sub name
+__TRACE(KError, (_L("ExecuteLineL: Could not read sub name [%d]"), err));
+iRunErrorMessage = KErrSubNameError;
+User::Leave(KErrArgument);
+}
+// Load section
+CStifSectionParser* subSection = NULL;
+TRAP(err,
+subSection = iTestScripter->GetSubL(subName);
+);
+if((err != KErrNone) || (!subSection))
+{
+//Error when getting sub name
+if(err == KErrNone)
+{
+err = KErrArgument;
+}
+__TRACE(KError, (_L("ExecuteLineL: Could not get section for sub [%d]"), err));
+iRunErrorMessage = KErrSubGetError;
+User::Leave(err);
+}
+// Handle new section parser
+CleanupStack::PushL(subSection);
+iTestScripter->iParserStack.AppendL(subSection);
+__TRACE(KMessage, (_L("ExecuteLineL: Section for sub [%S] appended to section stack"), &subName));
+CleanupStack::Pop(subSection);
+iTestScripter->iCurrentParser = subSection;
+iTestScripter->iCurrentParserReadFirstLine = EFalse; //Change it to false, becaue subSection is a new parser and it has nothing read
+}
+break;
+case TTestKeywords::ESetResultDescription:
+{
+__TRACE(KMessage, (_L("%S"), &aKeyword));
+iTestScripter->TestModuleIf().Printf(KPrintPriLow, _L("Runner"), _L("%S"), &aKeyword);
+TName buf;
+TPtrC tmp;
+while(aItem->GetNextString(tmp) == KErrNone)
+{
+if(buf.Length() + tmp.Length() >= buf.MaxLength())
+{
+break;
+}
+if(buf.Length() > 0)
+{
+buf.Append(_L(" "));
+}
+buf.Append(tmp);
+}
+iTestScripter->SetResultDescription(buf);
+RDebug::Print( _L("SetDescription to [%S]"), &buf );
+}
+break;
+case TTestKeywords::ESendPointerEvent:
+	   {
+	   if ( iTestScripter->TestModuleIf().UITesting() == true )
+		   {
+		   continueTask = SendPointerEventL( aItem );
+		   }
+	   else
+		   {
+		   __TRACE( KError, (_L("ExecuteLineL: Can't execute sendpointerevent in non s60 environment. Check if .cfg file name contains ui_ prefix and UITestingSupport= YES entry is defined in TestFrameworkd.ini")));
+		   iRunErrorMessage = KErrMsgSendPointerEventNotSupported;
+		   User::Leave( KErrNotSupported );
+		   }
+	   // Check if it was global or local sendpointerevent
+	   if ( !continueTask )
+		   {
+	           // Stop execution after pointer event is send and wait until it is handled
+	           SetActive();
+		   }
+	   }
+	   break;
+default:
+{
+continueTask = ExecuteCommandL( aKeyword, aItem );
+}
+break;
+}
+__TRACE( KMessage, (_L("ExecuteLineL: TestCase line executed")));
+return continueTask;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: PressKeyL
+Description: Send key press event to AppUi
+Parameters:    CStifItemParser* aItem: in: script line
+Return Values: None
+Errors/Exceptions: Leaves on error situations.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TBool CTestRunner::PressKeyL( CStifItemParser* aItem )
+	{
+_LIT( KErrMsgSendKeyEventInvalidParameterValue, "PressKey: Invalid parameter %s value " );
+_LIT( KErrMsgSendKeyEventInvalidParameter, "PressKey: Invalid parameter %s" );
+_LIT( KKeyCodeParameter, "keycode=" );
+_LIT( KKeyScanCodeParameter, "keyscancode=" );
+_LIT( KModifierParameter, "modifier=" );
+_LIT( KRepeatsParameter, "repeats=" );
+_LIT( KModeGlobal, "global" );
+_LIT( KModeLocal, "local" );
+TBool globalMode = EFalse;
+	TUint keyCode = 0;
+	TInt keyScanCode = 0;
+	TUint keyModifiers = 0;
+	TInt keyRepeats = 0;
+	TPtrC parameter;
+	CUiEnvProxy* uiEnvProxy = iTestScripter->TestModuleIf().GetUiEnvProxy();
+	while( aItem->GetNextString( parameter ) == KErrNone )
+		{
+		if ( parameter.Find( KKeyCodeParameter ) == 0 )
+			{
+			TPtrC parameterValue = parameter.Right( parameter.Length() - KKeyCodeParameter().Length() );
+			TLex parameterValueParser( parameterValue );
+			if ( parameterValueParser.Val( keyCode ) != KErrNone )
+				{
+					if ( uiEnvProxy->ParseKeyCode( parameterValue, keyCode ) != KErrNone )
+						{
+						__TRACE( KError, (_L("SendKeyEvent: Invalid parameter value")));
+						TBuf<128> errMsg;
+						errMsg.Format( KErrMsgSendKeyEventInvalidParameterValue, &KKeyCodeParameter() );
+						iRunErrorMessage = errMsg;
+						User::Leave( KErrArgument );
+						}
+				}
+			}
+		else if ( parameter.Find( KKeyScanCodeParameter ) == 0 )
+			{
+			TPtrC parameterValue = parameter.Right( parameter.Length() - KKeyScanCodeParameter().Length() );
+			TLex parameterValueParser( parameterValue );
+			if ( parameterValueParser.Val( keyScanCode ) != KErrNone )
+				{
+				if ( uiEnvProxy->ParseKeyScanCode( parameterValue, keyScanCode ) != KErrNone )
+					{
+					__TRACE( KError, (_L("SendKeyEvent: Invalid parameter value")));
+					TBuf<128> errMsg;
+					errMsg.Format( KErrMsgSendKeyEventInvalidParameterValue, &KKeyCodeParameter() );
+					iRunErrorMessage = errMsg;
+					User::Leave( KErrArgument );
+					}
+				}
+			}
+		else if ( parameter.Find( KModifierParameter ) == 0 )
+			{
+			TPtrC parameterValue = parameter.Right( parameter.Length() - KModifierParameter().Length() );
+			TLex parameterValueParser( parameterValue );
+			if ( parameterValueParser.Val( keyModifiers ) != KErrNone )
+				{
+				if ( uiEnvProxy->ParseModifier( parameterValue, keyModifiers ) != KErrNone )
+					{
+					__TRACE( KError, (_L("SendKeyEvent: Invalid parameter value")));
+					TBuf<128> errMsg;
+					errMsg.Format( KErrMsgSendKeyEventInvalidParameterValue, &KModifierParameter() );
+					iRunErrorMessage = errMsg;
+					User::Leave( KErrArgument );
+					}
+				}
+			}
+		else if ( parameter.Find( KRepeatsParameter ) == 0 )
+			{
+			TPtrC parameterValue = parameter.Right( parameter.Length() - KRepeatsParameter().Length() );
+			TLex parameterValueParser( parameterValue );
+			if ( parameterValueParser.Val( keyRepeats ) != KErrNone )
+				{
+				__TRACE( KError, (_L("SendKeyEvent: Invalid parameter value")));
+				TBuf<128> errMsg;
+				errMsg.Format( KErrMsgSendKeyEventInvalidParameterValue, &KRepeatsParameter() );
+				iRunErrorMessage = errMsg;
+				User::Leave( KErrArgument );
+				}
+			}
+		else if ( parameter == KModeGlobal )
+			{
+			globalMode = ETrue;
+			}
+		else if ( parameter == KModeLocal )
+			{
+			globalMode = EFalse;
+			}
+		else if ( uiEnvProxy->ParseKeyCode( parameter, keyCode ) == KErrNone )
+			{
+			}
+		else if ( parameter.Length() == 1 )
+			{
+			keyCode = parameter[ 0 ];
+			}
+		else
+			{
+			__TRACE( KError, (_L("PressKey: Invalid parameter")));
+			TBuf<128> errMsg;
+			errMsg.Format( KErrMsgSendKeyEventInvalidParameter, &parameter );
+			iRunErrorMessage = errMsg;
+			User::Leave( KErrArgument );
+			}
+		}
+	if ( globalMode )
+		{
+		uiEnvProxy->PressKeyL( keyCode, keyScanCode, keyModifiers, keyRepeats );
+		}
+	else
+		{
+		uiEnvProxy->PressKeyL( &iStatus, keyCode, keyScanCode, keyModifiers, keyRepeats );
+		}
+	return globalMode;
+	}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: TypeTextL
+Description: Sends text to AppUi
+Parameters:    CStifItemParser* aItem: in: script line
+Return Values: None
+Errors/Exceptions: Leaves on error situations.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TBool CTestRunner::TypeTextL( CStifItemParser* aItem )
+	{
+	_LIT( KErrMsgTypeTextInvalidParameter, "TypeText: Invalid parameter %S" );
+	_LIT( KErrMsgTypeTextNotEnoughParameters, "TypeText: Not enough parameters" );
+	TBool globalMode = EFalse;
+	TPtrC command;
+	TPtrC text;
+	aItem->SetParsingType( CStifItemParser::EQuoteStyleParsing );
+	// Read first parameter
+	TInt ret = aItem->GetNextString( command );
+	if ( ret != KErrNone )
+		{
+		__TRACE( KError, (_L("TypeText: Not enough parameters")));
+		iRunErrorMessage = KErrMsgTypeTextNotEnoughParameters;
+		User::Leave( ret );
+		}
+	// Read second parameter
+	ret = aItem->GetNextString( text );
+	// Check if second can be read. if yes then check if first parameters is
+	// 'global' parameter
+	if ( ret != KErrNone )
+		{
+		// normal type text
+		text.Set( command );
+		iTestScripter->TestModuleIf().GetUiEnvProxy()->TypeTextL( &iStatus, text );
+		globalMode = EFalse;
+		}
+	else if ( command == _L("global") )
+		{
+		iTestScripter->TestModuleIf().GetUiEnvProxy()->TypeTextL( text );
+		globalMode = ETrue;
+		}
+	else
+		{
+		__TRACE( KError, (_L("TypeText: Invalid parameter")));
+		TBuf<128> errMsg;
+		errMsg.Format( KErrMsgTypeTextInvalidParameter, &command );
+		iRunErrorMessage = errMsg;
+		User::Leave( KErrNotSupported );
+		}
+	return globalMode;
+	}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: SendPointerEventL
+Description: Send key press event to AppUi
+Parameters:    CStifItemParser* aItem: in: script line
+Return Values: None
+Errors/Exceptions: Leaves on error situations.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TBool CTestRunner::SendPointerEventL( CStifItemParser* aItem )
+	{
+	// Error messages
+_LIT( KErrMsgNotEnoughParameters, "SendPointerEvent: Not enough parameters" );
+_LIT( KErrMsgPointerEventTypeNotDefined, "SendPointerEvent: Pointer event type not defined" );
+_LIT( KErrMsgInvalidUnknownPointerEventType, "SendPointerEvent: Invalid/Unknown pointer event type %S" );
+_LIT( KErrMsgPositionXNotDefined, "SendPointerEvent: x co-ordinate is not defined" );
+_LIT( KErrMsgPositionYNotDefined, "SendPointerEvent: y co-ordinate is not defined" );
+_LIT( KErrMsgPositionXInvalidValue, "SendPointerEvent: Invalid value of x co-ordinate" );
+_LIT( KErrMsgPositionYInvalidValue, "SendPointerEvent: Invalid value of y co-ordinate" );
+// Parameters keywords
+_LIT( KModeGlobal, "global" );
+_LIT( KModeLocal, "local" );
+TBool globalMode = EFalse;
+	TUint eventType = 0;
+	TPoint position( 0, 0 );
+	TPoint parentPosition( 0, 0 );
+	TPtrC parameter;
+	CUiEnvProxy* uiEnvProxy = iTestScripter->TestModuleIf().GetUiEnvProxy();
+	// Get first parameter
+	if ( aItem->GetNextString( parameter ) != KErrNone )
+		{
+		__TRACE( KError, (_L("SendPointerEvent: Not enough parameters")));
+		iRunErrorMessage = KErrMsgNotEnoughParameters;
+		User::Leave( KErrArgument );
+		}
+	else
+		{
+		TBool modeSelected = EFalse;
+		// Check if global/local mode is defined
+		if ( parameter == KModeLocal )
+			{
+			globalMode = false;
+			modeSelected = ETrue;
+			}
+		else if ( parameter == KModeGlobal )
+			{
+			globalMode = true;
+			modeSelected = ETrue;
+			}
+		if ( modeSelected )
+			{
+			// First parameter was mode so we need get next parameter which should
+			// contain event type
+			if ( aItem->GetNextString( parameter ) != KErrNone )
+				{
+				__TRACE( KError, (_L("SendPointerEvent: Pointer event type not defined")));
+				iRunErrorMessage = KErrMsgPointerEventTypeNotDefined;
+				User::Leave( KErrArgument );
+				}
+			}
+		}
+	// Parse event type
+	if ( uiEnvProxy->ParsePointerEventType( parameter, eventType ) != KErrNone )
+		{
+		__TRACE( KError, (_L("PressKey: Invalid/Unknown pointer event type %S"), &parameter ));
+		iRunErrorMessage.Format( KErrMsgInvalidUnknownPointerEventType, &parameter );
+		User::Leave( KErrArgument );
+		}
+	if ( aItem->GetNextString( parameter ) != KErrNone )
+		{
+		__TRACE( KError, (_L("SendPointerEvent: x co-ordinate is not defined")));
+		iRunErrorMessage = KErrMsgPositionXNotDefined;
+		User::Leave( KErrArgument );
+		}
+	TLex parameterParser( parameter );
+	if ( parameterParser.Val( position.iX ) != KErrNone )
+		{
+		__TRACE( KError, (_L("SendPointerEvent: Invalid value of x co-ordinate")));
+		iRunErrorMessage = KErrMsgPositionXInvalidValue;
+		User::Leave( KErrArgument );
+		}
+	if ( aItem->GetNextString( parameter ) != KErrNone )
+		{
+		__TRACE( KError, (_L("SendPointerEvent: y co-ordinate is not defined")));
+		iRunErrorMessage = KErrMsgPositionYNotDefined;
+		User::Leave( KErrArgument );
+		}
+	parameterParser.Assign( parameter );
+	if ( parameterParser.Val( position.iY ) != KErrNone )
+		{
+		__TRACE( KError, (_L("SendPointerEvent: Invalid value of y co-ordinate")));
+		iRunErrorMessage = KErrMsgPositionYInvalidValue;
+		User::Leave( KErrArgument );
+		}
+	// Send pointer event
+	if ( globalMode )
+		{
+		uiEnvProxy->SendPointerEventL( eventType, position );
+		}
+	else
+		{
+		uiEnvProxy->SendPointerEventL( &iStatus, eventType, position );
+		}
+	return globalMode;
+	}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: ExecuteEventL
+Description: Executes event command script line
+Parameters:    TDesC& aKeyword: in: keyword string
+CStifItemParser* aItem: in: script line
+Return Values: ETrue: continue script file execution
+EFalse: stop script file execution
+Errors/Exceptions: Leaves on error situations.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TBool CTestRunner::ExecuteEventL( TDesC& aKeyword,
+CStifItemParser* aItem )
+{
+_LIT( KErrMsgEventNameNotDefined, "%S : Event name not defined" );
+_LIT( KErrMsgUnknowKeyword, "Unknow keyword %S" );
+TInt ret = KErrNone;
+TInt key = TTestKeywords::Parse( aKeyword, TTestKeywords::Keyword );
+TBool continueTask = ETrue;
+TPtrC eventName;
+// read eventname
+ret = aItem->GetNextString( eventName );
+if ( ret != KErrNone )
+	{
+	iRunErrorMessage.Format( KErrMsgEventNameNotDefined, &aKeyword );
+	User::Leave( ret );
+	}
+TEventIf event;
+event.SetName( eventName );
+__TRACE( KMessage, (_L("%S %S"), &aKeyword, &eventName));
+iTestScripter->TestModuleIf().Printf( KPrintPriLow, _L("Event"),
+_L("%S %S"), &aKeyword, &eventName);
+switch( key )
+{
+case TTestKeywords::ERequest:
+{
+HBufC* eName = eventName.AllocLC();
+User::LeaveIfError( iEventArray.Append( eName ) );
+CleanupStack::Pop( eName );
+event.SetType( TEventIf::EReqEvent );
+ret = iTestScripter->TestModuleIf().Event( event );
+}
+break;
+case TTestKeywords::EWait:
+{
+event.SetType( TEventIf::EWaitEvent );
+iTestScripter->TestModuleIf().Event( event, iStatus );
+SetActive();
+continueTask = EFalse;
+}
+break;
+case TTestKeywords::ERelease:
+{
+event.SetType( TEventIf::ERelEvent );
+ret = iTestScripter->TestModuleIf().Event( event );
+if( ret == KErrNone )
+{
+TPtrC eName;
+TInt count = iEventArray.Count();
+for( TInt i = 0; i < count; i++ )
+{
+eName.Set( iEventArray[i]->Des() );
+if( eName == eventName )
+{
+HBufC* tmp = iEventArray[i];
+iEventArray.Remove(i);
+delete tmp;
+break;
+}
+}
+}
+}
+break;
+case TTestKeywords::ESet:
+{
+event.SetType( TEventIf::ESetEvent );
+TPtrC tmp;
+// Get optional set argument
+if( aItem->GetNextString( tmp ) == KErrNone )
+{
+// Parse optional set argument
+if( tmp == _L("state") )
+{
+__TRACE( KMessage, (_L("State event")));
+event.SetEventType( TEventIf::EState );
+}
+else
+{
+__TRACE( KError,
+(_L("Unknown argument for set %S"),
+&tmp));
+}
+}
+ret = iTestScripter->TestModuleIf().Event( event );
+}
+break;
+case TTestKeywords::EUnset:
+{
+event.SetType( TEventIf::EUnsetEvent );
+event.SetEventType( TEventIf::EState );
+ret = iTestScripter->TestModuleIf().Event( event );
+}
+break;
+default:
+__TRACE( KError, (_L("Unknown keyword %S"), &aKeyword));
+iRunErrorMessage.Format( KErrMsgUnknowKeyword, &aKeyword );
+User::Leave( KErrGeneral );
+break;
+}
+if( ret != KErrNone )
+{
+TName resultDescr;
+resultDescr.Format(_L("Event %S returned error: %d"), &aKeyword, ret);
+iTestScripter->UpdateTestCaseResult(ret, resultDescr);
+// Stops execution from CTestRunner::RunError
+User::Leave( KErrGeneral );
+}
+return continueTask;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: ExecuteCommandL
+Description: Executes script line
+Parameters:    TDesC& aObject: in: object name
+CStifItemParser* aItem: in: script line
+Return Values: ETrue: continue script file execution
+EFalse: stop script file execution
+Errors/Exceptions: Leaves on error situations.
+Status: Proposal
+-------------------------------------------------------------------------------
+*/
+TBool CTestRunner::ExecuteCommandL( TDesC& aObject, CStifItemParser* aItem)
+{
+_LIT( KErrMsgUnknownObjOrKeyword, "Unknow keyword/object %S" );
+TTestObjectBase* obj = iTestScripter->GetObject ( aObject );
+if( obj == NULL )
+{
+iRunErrorMessage.Format( KErrMsgUnknownObjOrKeyword, &aObject );
+User::Leave( KErrGeneral );
+}
+if( iTestCaseResults.Count() == 0 )
+{
+// KErrNone is the default result expected if nothing else is given
+User::LeaveIfError( iTestCaseResults.Append( KErrNone ) );
+}
+// OOM heap testing with FAILNEXT
+if( iHeapFailNext > 0 )
+{
+__TRACE( KPrint, (
+_L( "OOM FAILNEXT is used with count value: %d " ),
+iHeapFailNext) );
+User::__DbgSetAllocFail( RHeap::EUser, RHeap::EFailNext, iHeapFailNext  );
+}
+// OOM heap testing with SETFAIL
+if( iHeapSetFailValue > 0 )
+{
+__TRACE( KPrint, (
+_L("OOM SETFAIL is used with type:[%d] and value(rate):[%d]"),
+iHeapSetFailType, iHeapSetFailValue ) );
+User::__DbgSetAllocFail( RHeap::EUser, iHeapSetFailType, iHeapSetFailValue );
+}
+TInt commandResult = KErrNone;
+TRAP( commandResult, commandResult = obj->RunMethodL( *aItem ) );
+// Reset OOM macro immediately(Otherwise other allocations
+// will be blocked)
+User::__DbgSetAllocFail( RHeap::EUser, RHeap::ENone, 1 );
+// OOM test class's build block handling
+if( iTestScripter->iOOMIgnoreFailure )
+{
+__TRACE( KPrint, (
+_L( "----------< OOM related test information >----------" ) ) );
+if( iHeapFailNext > 0 )
+{
+__TRACE( KPrint, (
+_L( "'oomignorefailure' is:[ON] and 'failnextvalue' count is:[%d]" ),
+iHeapFailNext ) );
+}
+if( iHeapSetFailValue > 0 )
+{
+__TRACE( KPrint, (
+_L( "'oomignorefailure' is:[ON], 'setfailtype' type is:[%d] and value is:[%d]" ),
+iHeapSetFailType, iHeapSetFailValue ) );
+}
+__TRACE( KPrint, (
+_L( "Test class build block execution with result:[%d]" ),
+commandResult ) );
+__TRACE( KPrint, (
+_L( "----------------------------------------------------" ) ) );
+// Continue testing, despite the memory error situations
+iTestCaseResults.Reset();
+return ETrue; // Continue script executions
+}
+// Normal test class's build block handling
+if( iTestCaseResults.Find( commandResult ) < 0 )
+{
+__TRACE( KError, ( _L("Command for [%S] failed (%d)"),
+&aObject, commandResult ));
+// Added more logging for this special case
+if( commandResult == KErrNone )
+{
+__TRACE( KError, (_L("Test fails with result KErrGeneral, because execution result was KErrNone and expected results given with 'allownextresult' were Symbian's error codes (<0)")));
+}
+iTestScripter->UpdateTestCaseResult(commandResult, _L("CTestRunner::ExecuteCommandL returned error"));
+// Stops execution from CTestRunner::RunError
+User::Leave( KErrGeneral );
+}
+iTestCaseResults.Reset();
+// Reset test case allow result to CTestModuleIf side too. This is
+// used in TAL-TA5L macro handling.
+User::LeaveIfError(
+iTestScripter->TestModuleIf().ResetAllowResult() );
+return ETrue;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: SetRunnerActive
+Description: Set CTestRunner active and complete.
+Parameters:    None.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::SetRunnerActive()
+{
+__TRACEFUNC();
+// Update state
+iState = ERunnerRunning;
+iStatus = KRequestPending;
+TRequestStatus* rs = &iStatus;
+SetActive();
+User::RequestComplete( rs, KErrNone );
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: OOMIgnoreFailure
+Description: Handles 'oomignorefailure' keyword parsing.
+Parameters: CStifItemParser* aItem: in: Item object for parsing.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Proposal
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::OOMIgnoreFailureL( CStifItemParser* aItem )
+{
+_LIT( KerrMsgOOMIgnoreFailureUnknownArgument, "OOMIgnoreFailure : Invalid argument %S" );
+_LIT( KerrMsgOOMIgnoreFailureNoArgument, "OOMIgnoreFailure : Parameter not defined" );
+__TRACEFUNC();
+TPtrC tmp;
+// Get result
+if( aItem->GetNextString( tmp ) == KErrNone )
+{
+if( tmp == _L("ON") || tmp == _L("on") )
+{
+__TRACE( KMessage, (_L("OOM related 'oomignorefailure': ON")));
+iTestScripter->iOOMIgnoreFailure = ETrue;
+}
+else if( tmp == _L("OFF") || tmp == _L("off") )
+{
+__TRACE( KMessage, (_L("OOM related 'oomignorefailure': OFF")));
+iTestScripter->iOOMIgnoreFailure = EFalse;
+}
+else
+{
+__TRACE( KError,
+(_L("Unknown argument for 'oomignorefailure': [%S]"),
+&tmp));
+iRunErrorMessage.Format( KerrMsgOOMIgnoreFailureUnknownArgument, &tmp );
+User::Leave( KErrArgument );
+}
+}
+else
+{
+__TRACE( KError, ( _L( "Unknown argument for 'oomignorefailure'" ) ) );
+iRunErrorMessage = KerrMsgOOMIgnoreFailureNoArgument;
+User::Leave( KErrArgument );
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: OOMHeapFailNext
+Description: Handles 'oomheapfailnext' keyword parsing.
+Parameters: CStifItemParser* aItem: in: Item object for parsing.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Proposal
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::OOMHeapFailNextL( CStifItemParser* aItem )
+{
+_LIT( KErrMsgHeapFailNextNoArgument, "HeapFailNext : Parameters is not defined or has invalid value" );
+_LIT( KErrMsgHeapFailNextInvalidValue, "HeapFailNext : Argument value can't be <0" );
+__TRACEFUNC();
+TInt heapfailNext( 0 );
+// If LOOP_COUNTER is used the GetNextInt returns a correct
+// value(Because of the LOOP_COUNTER implementation).
+if( aItem->GetNextInt( heapfailNext ) == KErrNone )
+{
+if( heapfailNext < 0 )
+	{
+	__TRACE( KError, ( _L( "Argument value must be >0" ) ) );
+iRunErrorMessage = KErrMsgHeapFailNextInvalidValue;
+User::Leave( KErrArgument );
+	}
+// OOM heap's FAILNEXT range is from 1 to n
+iHeapFailNext = heapfailNext + 1;
+__TRACE( KMessage, ( _L( "'oomheapfailnext' count value(rate): %d" ),
+iHeapFailNext ) );
+}
+else
+{
+__TRACE( KError, ( _L( "Unknown argument for 'oomheapfailnext'" ) ) );
+iRunErrorMessage = KErrMsgHeapFailNextNoArgument;
+User::Leave( KErrArgument );
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: OOMHeapSetFail
+Description: Handles 'oomheapsetfail' keyword parsing.
+Parameters: CStifItemParser* aItem: in: Item object for parsing.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Proposal
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::OOMHeapSetFailL( CStifItemParser* aItem )
+{
+_LIT( KErrMsgOOMHeapSetFailTypeNotDefined, "OOMHeapSetFail : Parameter type is not defined" );
+_LIT( KErrMsgOOMHeapSetFailRateNotDefined, "OOMHeapSetFail : Parameter rate is not defined" );
+_LIT( KErrMsgOOMHeapSetFailTypeInvalidValue, "OOMHeapSetFail : Parameter type has invalid value" );
+_LIT( KErrMsgOOMHeapSetFailRateInvalidValue, "OOMHeapSetFail : Parameter rate can't be <0" );
+__TRACEFUNC();
+TPtrC type;
+TInt value( 0 );
+// NOTE: If error in type or value parsing => return without changing
+//       iHeapSetFailType or iHeapSetFailValue valiables.
+// Get type
+if( aItem->GetNextString( type ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'oomheapsetfail' type" ) ) );
+iRunErrorMessage = KErrMsgOOMHeapSetFailTypeNotDefined;
+User::Leave( KErrArgument );
+}
+// Get value(rate)
+if( aItem->GetNextInt( value ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'oomheapsetfail' value(rate)" ) ) );
+iRunErrorMessage = KErrMsgOOMHeapSetFailRateNotDefined;
+User::Leave( KErrArgument );
+}
+// All parsing operations are passed, get type and value
+// Get type
+if( type == _L("random") )
+{
+__TRACE( KMessage, (_L("'oomheapsetfail' type: random")));
+iHeapSetFailType = RHeap::ERandom;
+}
+else if( type == _L("truerandom") )
+{
+__TRACE( KMessage, (_L("'oomheapsetfail' type: truerandom")));
+iHeapSetFailType = RHeap::ETrueRandom;
+}
+else if( type == _L("deterministic") )
+{
+__TRACE( KMessage, (_L("'oomheapsetfail' type: deterministic")));
+iHeapSetFailType = RHeap::EDeterministic;
+}
+else if( type == _L("none") )
+{
+__TRACE( KMessage, (_L("'oomheapsetfail' type: none")));
+iHeapSetFailType = RHeap::ENone;
+}
+else if( type == _L("failnext") )
+{
+__TRACE( KMessage, (_L("'oomheapsetfail' type: failnext")));
+iHeapSetFailType = RHeap::EFailNext;
+}
+else
+{
+__TRACE( KError,
+( _L( "Unknown argument for 'oomheapsetfail' type: [%S]" ),
+&type ) );
+iRunErrorMessage = KErrMsgOOMHeapSetFailTypeInvalidValue;
+User::Leave( KErrArgument );
+}
+if( value < 0 )
+	{
+__TRACE( KError, _L( "'oomheapsetfail' value(rate) can't be <0" ) );
+iRunErrorMessage = KErrMsgOOMHeapSetFailRateInvalidValue;
+User::Leave( KErrArgument );
+	}
+// Get value
+// OOM heap's SETFAIL range is from 1 to n
+iHeapSetFailValue = value + 1;
+__TRACE( KMessage, (
+_L( "'oomheapsetfail' value(rate): %d" ), iHeapSetFailValue ) );
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: OOMHeapToNormal
+Description: Initialize all OOM related variables.
+Parameters: None.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Proposal
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::OOMHeapToNormal()
+{
+__TRACEFUNC();
+if( iTestScripter )
+{
+// This should initialize also
+iTestScripter->iOOMIgnoreFailure = EFalse;
+}
+iHeapFailNext = 0;
+iHeapSetFailType = RHeap::ENone;
+iHeapSetFailValue = 0;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: TestInterference
+Description: Starts test interference.
+Parameters: CStifItemParser* aItem: in: Item object for parsing.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::TestInterferenceL( CStifItemParser* aItem )
+{
+_LIT( KErrMsgTestInterferenceNameNotDefined, "TestInterference : Parameter name is not defined" );
+_LIT( KErrMsgTestInterferenceCommandNotDefined, "TestInterference : Parameter command is not defined" );
+_LIT( KErrMsgTestInterferenceCommandInvalidValue, "TestInterference : Parameter command has invalid value" );
+__TRACEFUNC();
+TPtrC name;
+TPtrC command;
+// Get name
+if( aItem->GetNextString( name ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' name" ) ) );
+iRunErrorMessage = KErrMsgTestInterferenceNameNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+// Get command
+if( aItem->GetNextString( command ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' command" ) ) );
+iRunErrorMessage = KErrMsgTestInterferenceCommandNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+if( command == _L( "start" ) )
+{
+__TRACE( KMessage, ( _L( "'testinterference' called, starts test interference") ) );
+StartInterferenceL( name, aItem );
+}
+else if( command == _L( "stop" ) )
+{
+__TRACE( KMessage, ( _L( "'testinterference' called, stops and releases test interference") ) );
+StopInterferenceL( name );
+}
+else
+{
+__TRACE( KError, (
+_L( "Unknown command for 'testinterference'[%S]" ), &command ) );
+iRunErrorMessage = KErrMsgTestInterferenceCommandInvalidValue;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: StartInterference
+Description:
+Parameters: CStifItemParser* aItem: in: Item object for parsing.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::StartInterferenceL( TDesC& aName, CStifItemParser* aItem )
+{
+_LIT( KErrMsgStartInterferenceCategoryNotDefined, "TestInterference : Parameter category is not defined" );
+_LIT( KErrMsgStartInterferenceCategoryInvalidValue, "TestInterference : Parameter category has invalid value" );
+_LIT( KErrMsgStartInterferenceTypeNotDefined, "TestInterference : Parameter type is not defined" );
+_LIT( KErrMsgStartInterferenceTypeInvalidValue, "TestInterference : Parameter type has invalid value" );
+_LIT( KErrMsgStartInterferenceIdleNotDefined, "TestInterference : Parameter idle is not defined or has invalid value" );
+_LIT( KErrMsgStartInterferenceIdleInvalidValue, "TestInterference : Parameter idle has invalid value" );
+_LIT( KErrMsgStartInterferenceActiveNotDefined, "TestInterference : Parameter active is not defined or has invalid value" );
+_LIT( KErrMsgStartInterferenceActiveInvalidValue, "TestInterference : Parameter active has invalid value" );
+__TRACEFUNC();
+TPtrC category;
+TPtrC type;
+TInt idle( 0 );
+TInt active( 0 );
+TInt priority( 0 );
+// Get category
+if( aItem->GetNextString( category ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' category" ) ) );
+iRunErrorMessage = KErrMsgStartInterferenceCategoryNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+// Get type
+if( aItem->GetNextString( type ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' type" ) ) );
+iRunErrorMessage = KErrMsgStartInterferenceTypeNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+TPtrC timeStr;
+TReal time;
+// Get idle time
+if( aItem->GetNextString( timeStr ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' idle" ) ) );
+iRunErrorMessage = KErrMsgStartInterferenceIdleNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+if ( TLex( timeStr ).Val( time, '.' ) != KErrNone )
+	{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' idle" ) ) );
+iRunErrorMessage = KErrMsgStartInterferenceIdleNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+	}
+// Convert idle time from milli to micro seconds
+	idle = static_cast<TInt>( time * 1000.0);
+if( idle < 0 )
+	{
+__TRACE( KError, (
+_L( "Argument 'testinterference' idle can't be <0" ) ) );
+	iRunErrorMessage = KErrMsgStartInterferenceIdleInvalidValue;
+	User::Leave( KErrArgument );
+	}
+// Get active time
+if( aItem->GetNextString( timeStr ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' active" ) ) );
+iRunErrorMessage = KErrMsgStartInterferenceActiveNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+if ( TLex( timeStr ).Val( time, '.' ) != KErrNone )
+	{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' idle" ) ) );
+iRunErrorMessage = KErrMsgStartInterferenceIdleNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+	}
+// Convert active time from milli to micro seconds
+	active = static_cast<TInt>( time * 1000.0 );
+if( active < 0 )
+	{
+__TRACE( KError, (
+_L( "Argument 'testinterference' active can't be <0" ) ) );
+	iRunErrorMessage = KErrMsgStartInterferenceActiveInvalidValue;
+	User::Leave( KErrArgument );
+	}
+// Get priority
+if( aItem->GetNextInt( priority ) != KErrNone )
+{
+// Log information only do not return. Priority value is optional.
+__TRACE( KInit, (
+_L( "Unknown argument for 'testinterference' priority or value not given, default priority will be used" ) ) );
+}
+MSTIFTestInterference* interference = NULL;
+// Get category
+if( category == _L("activeobject") )
+{
+interference = MSTIFTestInterference::NewL( iTestScripter,
+MSTIFTestInterference::EActiveObject );
+}
+else if( category == _L("thread") )
+{
+interference = MSTIFTestInterference::NewL( iTestScripter,
+MSTIFTestInterference::EThread );
+}
+else
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' category[%S]" ), &category ) );
+iRunErrorMessage = KErrMsgStartInterferenceCategoryInvalidValue;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+// Create object that include test interference information and append this
+// to array.
+TTestInterference* object = new (ELeave) TTestInterference();
+object->iName = aName;
+object->iInterference = interference;
+// Array for handling test interference between different objects
+TInt ret = iTestInterferenceArray.Append( object );
+if( ret != KErrNone )
+{
+delete object;
+__TRACE( KError, (
+_L( "CTestRunner::StartInterference: iTestInterferenceArray.Append fails:[%d]" ), ret ) );
+User::Leave( ret );
+}
+// Set priority if user given
+if( priority != 0 )
+{
+interference->SetPriority( priority );
+}
+// Get type
+if( type == _L("cpuload") )
+{
+interference->StartL( MSTIFTestInterference::ECpuLoadMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemreadc") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemReadCMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemreadd") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemReadDMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemreade") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemReadEMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemreadz") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemReadZMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemwritec") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemWriteCMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemwrited") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemWriteDMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemwritee") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemWriteEMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemfillandemptyc") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemFillAndEmptyCMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemfillandemptyd") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemFillAndEmptyDMicroSeconds, idle , active );
+}
+else if( type == _L("filesystemfillandemptye") )
+{
+interference->StartL( MSTIFTestInterference::EFileSystemFillAndEmptyEMicroSeconds, idle , active );
+}
+else
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'testinterference' type[%S]" ), &type ) );
+iRunErrorMessage = KErrMsgStartInterferenceTypeInvalidValue;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: StopInterference
+Description: Stops test interference.
+Parameters: TDesC& aName: in: Indicates right test interference object.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::StopInterferenceL( TDesC& aName )
+{
+_LIT( KErrMsgStopInterference, "TestInterference : testinterference %S was not start" );
+__TRACEFUNC();
+TInt count = iTestInterferenceArray.Count();
+for( TInt i = 0; i < count; i++ )
+{
+if( iTestInterferenceArray[i]->iName == aName )
+{
+// Found test module, return description
+iTestInterferenceArray[i]->iInterference->Stop();
+// Delete data
+delete iTestInterferenceArray[i];
+// Remove pointer to deleted data(Append())
+iTestInterferenceArray.Remove( i );
+// iTestMeasurementArray can contain only one type of measurement
+// so we can break when type is removed.
+return;
+}
+}
+__TRACE( KError, (
+_L( "'testinterference' type[%S] was not start" ), &aName ) );
+iRunErrorMessage.Format( KErrMsgStopInterference, &aName );
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: MeasurementL
+Description: Starts test measurement.
+Parameters: CStifItemParser* aItem: in: Item object for parsing.
+Return Values: None.
+Errors/Exceptions: Leaves if StartBappeaMeasurementL() fails.
+Leaves if StopBappeaMeasurementL() fails.
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::MeasurementL( CStifItemParser* aItem )
+{
+_LIT( KErrMsgMeasurementCommandNotDefined, "TestMeasurement : Parameter command is not defined" );
+_LIT( KErrMsgMeasurementTypeNotDefined, "TestMeasurement : Parameter type is not defined" );
+_LIT( KErrMsgMeasurementUnknownType, "TestMeasurement : Unknown measurement type %S" );
+_LIT( KErrMsgMeasurementUnknownCommand, "TestMeasurement : Unknown command %S" );
+__TRACEFUNC();
+TPtrC type;
+TPtrC command;
+// Get command
+if( aItem->GetNextString( command ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'measurement' command" ) ) );
+iRunErrorMessage = KErrMsgMeasurementCommandNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+// Get name
+if( aItem->GetNextString( type ) != KErrNone )
+{
+__TRACE( KError, (
+_L( "Unknown argument for 'measurement' type" ) ) );
+iRunErrorMessage = KErrMsgMeasurementTypeNotDefined;
+User::Leave( KErrArgument ); // Error in parsing => Leave
+}
+// Verify measurement type
+if( !( type == KParamMeasurement01 ||
+type == KParamMeasurement02 ||
+type == KParamMeasurement03 ||
+type == KParamMeasurement04 ||
+type == KParamMeasurement05 ||
+type == KParamMeasurementBappea ) )
+{
+__TRACE( KError, (
+_L( "Unknown measurement type:[%S]" ), &type ) );
+iRunErrorMessage.Format( KErrMsgMeasurementUnknownType, &type );
+User::Leave( KErrArgument ); // Error in types => Leave
+}
+// Verify command
+if( command == _L( "start" ) )
+{
+// START measurement's process
+__TRACE( KMessage, ( _L( "Start 'measurement' with '%S'"), &type ) );
+StartMeasurementL( type, aItem );
+}
+else if( command == _L( "stop" ) )
+{
+// STOP measurement's process
+__TRACE( KMessage, ( _L( "'Stop 'measurement' with '%S'"), &type ) );
+StopMeasurementL( type );
+}
+else
+{
+__TRACE( KError, (
+_L( "Unknown command for 'measurement' command:[%S] or type:[%S]" ), &command, &type ) );
+iRunErrorMessage.Format( KErrMsgMeasurementUnknownCommand, &command );
+User::Leave( KErrArgument ); // Error in commands => Leave
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: StartMeasurementL
+Description: Start measurement
+Parameters: const TDesC& aType: in: Plugin type.
+CStifItemParser* aItem: in: Item object for parsing.
+Return Values: None.
+Errors/Exceptions: Leaves is measurement operation fails.
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::StartMeasurementL( const TDesC& aType,
+CStifItemParser* aItem )
+{
+_LIT( KErrMsgMeasurementUnknownPlugin, "Measurement : Unknown measurement plugin %S" );
+_LIT( KErrMsgMeasurementStartFail, "Measurement : Measurement start fails" );
+__TRACEFUNC();
+CSTIFTestMeasurement* testMeasurement = NULL;
+// Get Measurement configuration info
+TPtrC configurationInfo( KNullDesC() );
+if( aItem->Remainder( configurationInfo ) != KErrNone )
+{
+__TRACE( KInit, (
+_L( "Using default path and file name for measurement configure" ) ) );
+}
+if( aType == KParamMeasurement01 )
+{
+testMeasurement = CSTIFTestMeasurement::NewL(
+iTestScripter,
+CSTIFTestMeasurement::KStifMeasurementPlugin01,
+configurationInfo );
+}
+else if( aType == KParamMeasurement02 )
+{
+testMeasurement = CSTIFTestMeasurement::NewL(
+iTestScripter,
+CSTIFTestMeasurement::KStifMeasurementPlugin02,
+configurationInfo );
+}
+else if( aType == KParamMeasurement03 )
+{
+testMeasurement = CSTIFTestMeasurement::NewL(
+iTestScripter,
+CSTIFTestMeasurement::KStifMeasurementPlugin03,
+configurationInfo );
+}
+else if( aType == KParamMeasurement04 )
+{
+testMeasurement = CSTIFTestMeasurement::NewL(
+iTestScripter,
+CSTIFTestMeasurement::KStifMeasurementPlugin04,
+configurationInfo );
+}
+else if( aType == KParamMeasurement05 )
+{
+testMeasurement = CSTIFTestMeasurement::NewL(
+iTestScripter,
+CSTIFTestMeasurement::KStifMeasurementPlugin05,
+configurationInfo );
+}
+else if( aType == KParamMeasurementBappea )
+{
+testMeasurement = CSTIFTestMeasurement::NewL(
+iTestScripter,
+CSTIFTestMeasurement::KStifMeasurementBappeaProfiler,
+configurationInfo );
+}
+else
+{
+__TRACE( KError, ( _L( "Unknown plugin[%S] for 'measurement'" ), &aType ) );
+iRunErrorMessage.Format( KErrMsgMeasurementUnknownPlugin, &aType );
+User::Leave( KErrArgument );
+}
+// Start test measurement
+TInt start_ret( KErrNone );
+start_ret = testMeasurement->Start();
+if( start_ret != KErrNone )
+{
+delete testMeasurement;
+//CleanupStack::PopAndDestroy( setting_buf );
+__TRACE( KError, (
+_L( "CTestRunner::StartMeasurementL(): Measurement Start() fails:[%d]" ), start_ret ) );
+iRunErrorMessage = KErrMsgMeasurementStartFail;
+User::Leave( start_ret );
+}
+TTestMeasurement* object = new (ELeave) TTestMeasurement();
+object->iName = aType;
+object->iMeasurement = testMeasurement;
+// Array for handling test measurement between different objects
+TInt ret = iTestMeasurementArray.Append( object );
+if( ret != KErrNone )
+{
+delete object;
+__TRACE( KError, (
+_L( "CTestRunner::StartMeasurementL(): iTestMeasurementArray.Append fails:[%d]" ), ret ) );
+User::Leave( ret );
+}
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: StopMeasurementL
+Description: Stops test measurement.
+Parameters: None.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::StopMeasurementL( const TDesC& aType )
+{
+_LIT( KErrMsgMeasurementNotStarted, "Measurement : Measurement %S was not start" );
+__TRACEFUNC();
+TInt count = iTestMeasurementArray.Count();
+for( TInt i = 0; i < count; i++ )
+{
+if( iTestMeasurementArray[i]->iName == aType )
+{
+// Found measurement module, stop
+iTestMeasurementArray[i]->iMeasurement->Stop();
+// Delete data
+delete iTestMeasurementArray[i];
+// Remove pointer to deleted data(Append())
+iTestMeasurementArray.Remove( i );
+// iTestMeasurementArray can contain only one type of measurement
+// so we can break when type is removed.
+return;
+}
+}
+__TRACE( KError, (
+_L( "CTestRunner::StopMeasurementL(): Measurement %S was not start" ), &aType ) );
+iRunErrorMessage.Format( KErrMsgMeasurementNotStarted, &aType  );
+User::Leave( KErrArgument );
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestRunner
+Method: AddTestCaseResultL
+Description: Adds new test case result. Used with 'allownextresult'
+and 'allowerrorcodes' keywords.
+Parameters: CStifItemParser* aItem: in: Item object for parsing.
+Return Values: None.
+Errors/Exceptions: Leaves if iTestCaseResults.Append fails.
+Leaves if aItem->GetNextInt() fails.
+Status: Approved
+-------------------------------------------------------------------------------
+*/
+void CTestRunner::AddTestCaseResultL( CStifItemParser* aItem )
+{
+_LIT( KErrMsgAllowNextResultInvalidValue, "No expected result value given or value has invalid format" );
+TInt result;
+TPtrC codeBuf;
+TBool found = EFalse;
+while( aItem->GetNextString( codeBuf ) == KErrNone )
+	{
+	TLex codeParser( codeBuf );
+	if ( codeParser.Val( result ) != KErrNone )
+		{
+__TRACE( KError, (_L("ExecuteLineL: No expected result value given")));
+iRunErrorMessage = KErrMsgAllowNextResultInvalidValue;
+User::Leave( KErrArgument );
+		}
+	else
+		{
+	    User::LeaveIfError( iTestCaseResults.Append( result ) );
+	    // Set test case allow result to CTestModuleIf side too. This is
+	    // used in TAL-TA5L macro handling.
+	    User::LeaveIfError(
+	        iTestScripter->TestModuleIf().SetAllowResult( result ) );
+	    found = ETrue;
+		}
+	}
+if ( !found )
+	{
+__TRACE( KError, (_L("ExecuteLineL: No expected result value given")));
+iRunErrorMessage = KErrMsgAllowNextResultInvalidValue;
+User::Leave( KErrArgument );
+	}
+}
+/*
+-------------------------------------------------------------------------------
+DESCRIPTION
+This module contains the implementation of CTestContinue class
+member functions. CTestContinue handles ContinueScript calls from
+TestScripter.
+-------------------------------------------------------------------------------
+*/
+// MACROS
+#ifdef LOGGER
+#undef LOGGER
+#endif
+#define LOGGER iTestScripter->iLog
+// ================= MEMBER FUNCTIONS =========================================
+/*
+-------------------------------------------------------------------------------
+Class: CTestContinue
+Method: CTestContinue
+Description: Default constructor
+Parameters: CTestRunner* aTestRunner: in: Backpointer to CTestRunner
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CTestContinue::CTestContinue( CTestScripter* aTestScripter,
+TTestObject* aObject ):
+// Executed with lowest priority, must be lower than CTesRunner priority
+CActive(  CActive::EPriorityLow ),
+iTestScripter( aTestScripter ),
+iObject( aObject )
+{
+CActiveScheduler::Add( this );
+__TRACEFUNC();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestContinue
+Method: ConstructL
+Description: Symbian OS second phase constructor
+Parameters:    None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestContinue::ConstructL()
+{
+iObject->iScript->EnableSignal( iStatus );
+SetActive();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestContinue
+Method: NewL
+Description: Two-phased constructor.
+Parameters: CTestRunner* aTestRunner: in: Backpointer to CTestRunner
+Return Values: CTestContinue*: new object
+Errors/Exceptions: Leaves if new or ConstructL leaves
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CTestContinue* CTestContinue::NewL( CTestScripter* aTestScripter,
+TTestObject* aObject )
+{
+CTestContinue* self =
+new (ELeave) CTestContinue( aTestScripter, aObject );
+CleanupStack::PushL( self );
+self->ConstructL();
+CleanupStack::Pop();
+return self;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestContinue
+Method: ~CTestContinue
+Description: Destructor
+Parameters:    None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CTestContinue::~CTestContinue()
+{
+__TRACEFUNC();
+Cancel();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestContinue
+Method: RunL
+Description: Derived from CActive, handles testcase execution.
+Parameters:    None.
+Return Values: None.
+Errors/Exceptions: Leaves on error situations.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestContinue::RunL()
+{
+__TRACEFUNC();
+__TRACE( KMessage, (_L("CTestContinue::RunL: [%d] "), iStatus.Int() ));
+if( iObject->Signal() )
+{
+// If OOM testing is ongoing ignore result check(given by user).
+if( !iTestScripter->iOOMIgnoreFailure )
+{
+// Erronous case RunError will called and test handling continue
+// from there.
+if( iTestScripter->TestRunner().TestCaseResults().Count() == 0 )
+{
+// KErrNone is the default result expected
+// if nothing else is given
+User::LeaveIfError( iTestScripter->TestRunner().
+TestCaseResults().Append( KErrNone ) );
+}
+if( iTestScripter->TestRunner().TestCaseResults().
+Find( iStatus.Int() ) < 0 )
+{
+__TRACE( KError, ( _L("Command for [%S] failed (%d)"),
+&iObject->ObjectId(), iStatus.Int() ));
+if( iStatus.Int() == KErrNone )
+{
+User::Leave( KErrGeneral );
+}
+else
+{
+User::Leave( iStatus.Int() );
+}
+}
+}
+else
+{
+__TRACE( KMessage, (
+_L( "OOM test: 'oomignorefailure' is ON, signal result[%d] ignored" ),
+iStatus.Int() ));
+}
+iTestScripter->TestRunner().TestCaseResults().Reset();
+__TRACE( KMessage, (_L("CTestContinue::RunL: Set runner active ")));
+iTestScripter->iTestRunner->SetRunnerActive();
+}
+else
+{
+// Signal called from test side but 'waittestclass' not yet processed
+iObject->iAsyncResult = iStatus.Int();
+}
+iObject->iScript->EnableSignal( iStatus );
+SetActive();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestContinue
+Method: DoCancel
+Description: Derived from CActive handles the Cancel
+Parameters:    None.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CTestContinue::DoCancel()
+{
+__TRACEFUNC();
+__TRACE( KMessage, (_L("CTestContinue::DoCancel")));
+iObject->iScript->CancelSignal();
+}
+/*
+-------------------------------------------------------------------------------
+Class: CTestContinue
+Method: RunError
+Description: Derived from CActive handles the Cancel
+Parameters:    None.
+Return Values: None.
+Errors/Exceptions: None.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt CTestContinue::RunError( TInt aError )
+{
+// Return error from here, if none given from execution
+if( iTestScripter->iResult.iResult == KErrNone )
+{
+iTestScripter->UpdateTestCaseResult(aError, _L("CTestContinue::RunError"));
+}
+CActiveScheduler::Current()->Stop();
+return KErrNone;
+}
+/*
+-------------------------------------------------------------------------------
+DESCRIPTION
+This module contains the implementation of CDefinedValue class
+member functions.
+-------------------------------------------------------------------------------
+*/
+// ================= MEMBER FUNCTIONS =========================================
+/*
+-------------------------------------------------------------------------------
+Class: CDefinedValue
+Method: CDefinedValue
+Description: Default constructor
+C++ default constructor can NOT contain any code, that
+might leave.
+Parameters: None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CDefinedValue::CDefinedValue()
+{
+}
+/*
+-------------------------------------------------------------------------------
+Class: CDefinedValue
+Method: ConstructL
+Description: Symbian OS second phase constructor
+Symbian OS default constructor can leave.
+Parameters:    TDesC& aName: in: Define name
+TDesC& aValue: in: Define value
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CDefinedValue::ConstructL( TDesC& aName, TDesC& aValue )
+{
+iNameBuf = aName.AllocLC();
+iName.Set( iNameBuf->Des() );
+iValueBuf = aValue.AllocLC();
+iValue.Set( iValueBuf->Des() );
+CleanupStack::Pop( iValueBuf );
+CleanupStack::Pop( iNameBuf );
+}
+/*
+-------------------------------------------------------------------------------
+Class: CDefinedValue
+Method: NewL
+Description: Two-phased constructor.
+Parameters:    TDesC& aName: in: Define name
+TDesC& aValue: in: Define value
+Return Values: CDefinedValue*: new object
+Errors/Exceptions: Leaves if new or ConstructL leaves.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CDefinedValue* CDefinedValue::NewL( TDesC& aName, TDesC& aValue )
+{
+CDefinedValue* self = new (ELeave) CDefinedValue();
+CleanupStack::PushL( self );
+self->ConstructL( aName, aValue );
+CleanupStack::Pop();
+return self;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CDefinedValue
+Method: ~CDefinedValue
+Description: Destructor
+Parameters:    None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+CDefinedValue::~CDefinedValue()
+{
+delete iValueBuf;
+delete iNameBuf;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CDefinedValue
+Method: SetValueL
+Description: Set new define value
+Parameters:    TDesC& aValue: in: Define value
+Return Values: None
+Errors/Exceptions: Leaves on error.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+void CDefinedValue::SetValueL( TDesC& aValue )
+{
+delete iValueBuf;
+iValueBuf = 0;
+iValueBuf = aValue.AllocLC();
+iValue.Set( iValueBuf->Des() );
+CleanupStack::Pop( iValueBuf );
+}
+/*
+-------------------------------------------------------------------------------
+Class: CDefinedValue
+Method: Name
+Description: Returns define name.
+Parameters:  None
+Return Values: TDesC: Define name
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TDesC& CDefinedValue::Name()
+{
+return iName;
+}
+/*
+-------------------------------------------------------------------------------
+Class: CDefinedValue
+Method: Value
+Description: Returns define value.
+Parameters:  None
+Return Values: TDesC: Define value
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TDesC& CDefinedValue::Value()
+{
+return iValue;
+}
+/*
+-------------------------------------------------------------------------------
+DESCRIPTION
+This module contains the implementation of TTestObjectBase class
+member functions.
+-------------------------------------------------------------------------------
+*/
+// ================= MEMBER FUNCTIONS =========================================
+/*
+-------------------------------------------------------------------------------
+Class: TTestObjectBase
+Method: TTestObjectBase
+Description: Constructor
+Parameters: None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TTestObjectBase::TTestObjectBase( TObjectType aType ) :
+iAsyncResult( KErrNone ),
+iType( aType )
+{
+RDebug::Print( _L("TTestObjectBase::TTestObjectBase") );
+iName.Zero();
+}
+/*
+-------------------------------------------------------------------------------
+Class: TTestObjectBase
+Method: ~TTestObjectBase
+Description: Destructor
+Parameters: None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TTestObjectBase::~TTestObjectBase()
+{
+RDebug::Print( _L("TTestObjectBase::~TTestObjectBase") );
+}
+/*
+-------------------------------------------------------------------------------
+DESCRIPTION
+This module contains the implementation of TTestObject class
+member functions.
+-------------------------------------------------------------------------------
+*/
+// ================= MEMBER FUNCTIONS =========================================
+/*
+-------------------------------------------------------------------------------
+Class: TTestObject
+Method: TTestObject
+Description: Constructor
+Parameters: None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TTestObject::TTestObject() :
+TTestObjectBase( EObjectNormal ),
+iScript(0),
+iContinue(0),
+iCount(0)
+{
+RDebug::Print( _L("TTestObject::TTestObject") );
+}
+/*
+-------------------------------------------------------------------------------
+Class: TTestObject
+Method: ~TTestObject
+Description: Destructor
+Parameters: None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TTestObject::~TTestObject()
+{
+RDebug::Print( _L("TTestObject::~TTestObject") );
+delete iContinue;
+delete iScript;
+}
+/*
+-------------------------------------------------------------------------------
+Class: TTestObject
+Method: RunMethodL
+Description: Run specified method from testclass.
+Parameters: CStifItemParser* aItem: in: itemparser
+Return Values: Symbian OS error code
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt TTestObject::RunMethodL( CStifItemParser& aItem )
+{
+return iScript->RunMethodL( aItem );
+}
+/*
+-------------------------------------------------------------------------------
+DESCRIPTION
+This module contains the implementation of TTestObjectKernel class
+member functions.
+-------------------------------------------------------------------------------
+*/
+// ================= MEMBER FUNCTIONS =========================================
+/*
+-------------------------------------------------------------------------------
+Class: TTestObjectKernel
+Method: TTestObjectKernel
+Description: Constructor
+Parameters: None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TTestObjectKernel::TTestObjectKernel() :
+TTestObjectBase( EObjectKernel )
+{
+RDebug::Print( _L("TTestObjectKernel::TTestObjectKernel") );
+}
+/*
+-------------------------------------------------------------------------------
+Class: TTestObjectKernel
+Method: ~TTestObjectKernel
+Description: Destructor
+Parameters: None
+Return Values: None
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TTestObjectKernel::~TTestObjectKernel()
+{
+RDebug::Print( _L("TTestObjectKernel::~TTestObjectKernel") );
+iTestClass.Close();
+User::FreeLogicalDevice( iLddName );
+}
+/*
+-------------------------------------------------------------------------------
+Class: TTestObjectKernel
+Method: RunMethodL
+Description: Run specified method from kernel testclass.
+Parameters: CStifItemParser& aItem: in: itemparser
+Return Values: Symbian OS error code
+Errors/Exceptions: None
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+TInt TTestObjectKernel::RunMethodL( CStifItemParser& aItem )
+{
+TPtrC method;
+TPtrC params;
+User::LeaveIfError( aItem.GetNextString( method ) );
+aItem.Remainder( params );
+TInt result;
+TMethodResultDes resultDes;
+// Need to change descriptors from 16bit to 8bit for EKA2 kernel
+// because STIF Parser doesn't support 8bit parsing
+HBufC8 * myBuf1 = HBufC8::NewL( method.Length() );
+TPtr8 met8 = myBuf1->Des();
+met8.Copy( method );
+HBufC8 * myBuf2 = HBufC8::NewL( params.Length() );
+TPtr8 par8 = myBuf2->Des();
+par8.Copy( params );
+TInt ret =  iTestClass.RunMethod( met8, par8, result, resultDes );
+delete myBuf1;
+delete myBuf2;
+if( ret != KErrNone )
+{
+return ret;
+}
+return result;
+};
+// ================= OTHER EXPORTED FUNCTIONS =================================
+/*
+-------------------------------------------------------------------------------
+Function: LibEntryL
+Description: Polymorphic Dll Entry Point
+Parameters:    None.
+Return Values: CTestScripter*: pointer to new CTestScripter
+Errors/Exceptions: Leaves if NewL leaves.
+Status: Draft
+-------------------------------------------------------------------------------
+*/
+EXPORT_C CTestScripter* LibEntryL()
+{
+return CTestScripter::NewL();
+}
+// End of File

branch	RCL_3
changeset 59	8ad140f3dd41