--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/stif/TestScripter/src/TestScripter.cpp Wed Oct 13 16:17:58 2010 +0300
@@ -0,0 +1,5169 @@
+/*
+* 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, ¶meter );
+ 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"), ¶meter ));
+ iRunErrorMessage.Format( KErrMsgInvalidUnknownPointerEventType, ¶meter );
+ 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