diff -r bbd31066657e -r 8bb370ba6d1d testexecfw/stf/stffw/testengine/inc/TestEngine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testexecfw/stf/stffw/testengine/inc/TestEngine.h Fri Apr 09 10:46:28 2010 +0800 @@ -0,0 +1,784 @@ +/* +* 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 the header file of the CTestEngine. +* +*/ + +#ifndef TEST_ENGINE_H +#define TEST_ENGINE_H + +// INCLUDES +#include +#include +#include +#include +#include +#include +#include "TestEngineCommon.h" +#include "TestEngineEvent.h" +#include "STIFTestFrameworkSettings.h" +#include "SettingServerClient.h" +#include "STIFMeasurement.h" +#include "TestModuleInfo.h" + +// CONSTANTS +// Heap sizes needed for creating server thread. +const TUint KTestEngineMinHeapSize = 0x10000; +const TUint KTestEngineMaxHeapSize = 0x100000; + +// MACROS +// None + + +class CRebootParams + :public CBase + { + public: // Constructors and destructor + + /** + * NewL is two-phased constructor. + */ + static CRebootParams* NewL(); + + /** + * Destructor of CTestEngineServer. + */ + ~CRebootParams(); + + // Setters + void SetTestModuleNameL( const TDesC& aName ); + void SetTestCaseFileNameL( const TDesC& aName ); + void SetTestCaseTitleL( const TDesC& aName ); + void SetTestCaseStateL( const TDesC& aName ); + + + private: // New functions + + /** + * C++ default constructor. + */ + CRebootParams(); + + /** + * By default Symbian OS constructor is private. + */ + void ConstructL(); + + public: // Data + TInt iCaseNumber; + TInt iStateCode; + + TPtrC iTestModule; + TPtrC iTestCaseFile; + TPtrC iTestCaseTitle; + TPtrC iStateName; + + private: // Data + HBufC* iTestModuleBuf; + HBufC* iTestCaseFileBuf; + HBufC* iTestCaseTitleBuf; + HBufC* iStateNameBuf; + + }; + +// FUNCTION PROTOTYPES +// None + +// DESCRIPTION +// Class used to store version information of test module. +// iTestModuleName field keeps name of test module dll +// iVersion keeps version of test module dll + + struct TTestModuleVersionInfo + { + TFileName iTestModuleName; + TInt iMajor; + TInt iMinor; + TInt iBuild; + }; + +// DESCRIPTION +// CTestEngine is a session class. +// Session for the CTestEngineServer server, to a single client-side session +// a session may own any number of CCounter objects + +class CTestCase; +class CTestEventController; +class CTestModuleController; +class CTestEngineServer; +class CTestReport; + +class CTestEngine + : public CSession2 + { + public: // Enumerations + + private: // Enumerations + + public: // Constructors and destructor + + /** + * NewL is two-phased constructor. + */ + static CTestEngine* NewL( CTestEngineServer* aServer ); + + /** + * Destructor. + */ + ~CTestEngine(); + + /** + * Leave with notify + */ + void LeaveWithNotifyL( TInt aCode, const TDesC& aText ); + + /** + * If error leave with notify + */ + void LeaveIfErrorWithNotify( TInt aCode, const TDesC& aText ); + + /** + * Leave with notify + */ + void LeaveWithNotifyL( TInt aCode ); + + /** + * If error leave with notify + */ + void LeaveIfErrorWithNotify( TInt aCode ); + + /** + * Close the session to CTestEngineServer. + */ + void CloseSession(); + + public: // New functions + + /** + * PanicClient panics the user of CTestEngine ( RTestEngine user ) + */ + void PanicClient( TTestEnginePanic aPanic, const RMessage2& aMessage ) const; + + /** + * NumResources is used to provide reserver resources to client. + */ + void NumResources( const RMessage2& aMessage ); + + /** + * Return the number of resources owned by the session. + * Required by CSession if derived class implements resource + * mark-start and mark-end protocol. + */ + TInt CountResources(); + + /** + * Callback to inform that enumeration of test cases is completed + */ + void EnumerationCompleted( TInt aCount, TInt aError = KErrNone ); + + + /** + * Callback to check state event status. + */ + TBool IsStateEventAndSet( const TName& aEventName ); + + /** + * Callback to control events. + */ + CTestEventController* CtlEventL( const TEventIf& aEvent, + TRequestStatus& aStatus ); + + /** + * Return the pointer to CStifLogger owned by CTestEngineServer + */ + CStifLogger* Logger(); + + /** + * Return testcases. + */ + RPointerArray& TestCaseArray(){ return iTestCaseArray; } + + /** + * Return client events. + */ + RPointerArray& ClientEvents(){ return iClientEvents; } + + /** + * ErrorPrint print errors. This version is used to print engine own + * errors. + */ + void ErrorPrint( const TInt aPriority, + TPtrC aError ); + + /** + * ErrorPrint print errors. This version is used to forward errors. + */ + void ErrorPrint( TErrorNotificationPckg aError ); + + /** + * Write the Reboot related information to file. + */ + TInt WriteRebootParams( TTestInfo& aTestInfo, + TInt& aCode, TDesC& aName ); + + /** + * Read the Reboot related information from the file. + */ + TInt ReadRebootParams( TTestInfo& aTestInfo, + TDes& aStateDes, + TInt& aState ); + + /** + * Pause all test case(s) which are/is running. + */ + void PauseAllTestCases(); + + /** + * Flush ATS logger buffers. + */ + void FlushAtsLogger(); + + /** + * Get device reset module's DLL name. + */ + TPtrC GetDeviceResetDllName(); + + /** + * Get measurements related information. Returns is measurement disable. + */ + TInt StifMeasurement(); + + /** + * For Recovering from serious testmodulecrash situations (KErrserverTerminated (-15)) + * Clones TestModuleController + */ + void TestModuleCrash( CTestModuleController* aTestModuleController ); + + /** + * Executes command received from test case. + * It was created to allow test case to kill itself. + */ + void ExecuteCommandL(TCommand aCommand, TDesC8& aParamsPckg); + + /** + * Returns new index for test module controller. + * This number is appended to module controller name. + * This method is used when option to run every test case in separate + * process is set to on. + */ + TInt GetIndexForNewTestModuleController(void); + + /** + * Return free module controller specified by given parameter. + * If it can't be found, new one will be created. + */ + CTestModuleController* GetFreeOrCreateModuleControllerL(TTestInfo& aTestInfo, + CTestModuleController** aRealModuleController); + TBool UITesting(); + + TBool SeparateProcesses(); + + public: // Functions from base classes + + /** + * ServiceL handles the messages to CTestEngineServer + */ + virtual void ServiceL( const RMessage2& aMessage ); + + protected: // New functions + + protected: // Functions from base classes + + private: // New functions + + /** + * C++ default constructor. + */ + CTestEngine(); + + /** + * By default Symbian OS constructor is private. + */ + void ConstructL( CTestEngineServer* aServer ); + + /** + * DispatchMessageL handles the messages to CTestEngineServer + */ + void DispatchMessageL( const RMessage2& aMessage ); + + /** + * Get module controller by name + */ + CTestModuleController* ModuleControllerByName( + const TName& aModuleName ); + + void SetTestEngineDefaultSettings(); + + /** + * Initialize the Test Engine. + */ + void LoadConfigurationL( const RMessage2& aMessage ); + /** + * Update Log Configuration. + */ + void UpdateLogConfigurationL( const RMessage2& aMessage ); + /** + * Update Engine Configuration . + */ + void UpdateEngineConfigurationL( const RMessage2& aMessage ); + + /** + * Parse Test Engine defaults from STIF initialization + * file. + */ + void ReadEngineDefaultsL( CStifParser* aParser, + CSTIFTestFrameworkSettings* aSettings ); + /** + * Parse Test Engine defaults from command line. + * + */ + void ReadEngineFromCommandLineL(const TDesC& aCommand); + + /** + * Parse Test modules and module information from STIFTestFramework + * initialization file. + */ + void ReadTestModulesL( CStifParser* aParser ); + + /** + * + */ + void TestModuleConfigFileL( CTestModuleController* aModule, + CStifSectionParser* aSectionParser, + TDesC& aTag ); + + /** + * Sets attributes to Test Framework + */ + void SetAttributeL( const RMessage2& aMessage ); + + /** + * Adds new Test Module + */ + void AddTestModuleL( const RMessage2& aMessage ); + + /** + * Removes Test Module + */ + TInt RemoveTestModuleL( const RMessage2& aMessage ); + + /** + * Close Test Engine + */ + void CloseTestEngineL(); + + /** + * Adds new config file to Test Module + */ + void AddConfigFileL( const RMessage2& aMessage ); + + /** + * Removes config file from test module + */ + void RemoveConfigFileL( const RMessage2& aMessage ); + + /** + * Enumerates test cases + */ + void EnumerateTestCasesL( const RMessage2& aMessage ); + + /** + * Get test cases + */ + void GetTestCasesL( const RMessage2& aMessage ); + + /** + * Cancel outstanding asynchronous request + */ + void CancelAsyncRequest( const RMessage2& aMessage ); + + /** + * Event system control. + */ + void EventControlL( const RMessage2& aMessage ); + + /** + * Update state event list. + */ + void UpdateEventL( const TEventIf& aEvent ); + + /** + * Handles error notifications + */ + void HandleErrorNotificationL( const RMessage2& iMessage ); + + /** + * Get Logger's overwrite parameters + */ + void LoggerSettings( const RMessage2& iMessage ); + + /** + * Close logger settings + */ + void CloseLoggerSettings(); + + /** + * Process error queue. + */ + void ProcessErrorQueue(); + + /** + * Resolve the correct CTestCase object + */ + CTestCase* TestCaseByHandle( TUint aHandle, const RMessage2& aMessage ); + + /** + * Create CTestCase subsession. + */ + void NewTestCaseL( const RMessage2& aMessage ); + + /** + * Destroy the created CTestCase subsession. + * Cannot fail - can panic client. + */ + void DeleteTestCase( TUint aHandle ); + + /** + * Parse the Reboot related information from the file. + */ + TInt ParseRebootParamsL(); + + /** + * Set measurements related information, enable measurement. + */ + TInt EnableStifMeasurement( const TDesC& aInfoType ); + + /** + * Set measurements related information, disable measurement. + */ + TInt DisableStifMeasurement( const TDesC& aInfoType ); + + /** + * Parse and search for module info and fill list of modules. + */ + void ParseTestModulesL(CStifParser* aParser, CTestModuleList* aModuleList, const TDesC& aSectionStart, const TDesC& aSectionEnd); + + /** + * Add test case info to test report. + */ + TInt AddTestCaseToTestReport(const RMessage2& aMessage); + + + /** + * CreateTestReport + */ + CTestReport* RetrieveTestReport(); + + public: // Data + + protected: // Data + + private: // Data + + // Test module array + RPointerArray iModules; + + // Object container for this session + CObjectCon* iContainer; + + // Object index which stores objects (CTestCase instances) + // for this session + CObjectIx* iTestCases; + + // Array of CTestCase instances + RPointerArray iTestCaseArray; + + // Pointer to owning server + CTestEngineServer* iTestEngineServer; + + // Device reset module's DLL name(Reboot) + HBufC* iDeviceResetDllName; + + // Total number of resources allocated + TInt iResourceCount; + + // Test Engine's initialization file + HBufC* iIniFile; + + // Test Report + CTestReport* iTestReport; + // Test Report Mode + TUint iReportMode; + // Test Report Output Type + TUint iReportOutput; + + // Test report settings + CTestReportSettings* iTestReportSettings; + + // RMessage for ongoing operation + RMessage2 iEnumerationMessage; + + // Test case count used in EnumerateTestCases + TInt iCaseCount; + // Error code used in EnumerateTestCases + TInt iEnumError; + + // Tell if message can be completed + TBool iComplete; + + // Error code for complete of message + TInt iReturn; + + // State event Array + RPointerArray iStateEvents; + + // Client event Array + RPointerArray iClientEvents; + + // Number of enumerated test modules currently + TInt iEnumerateModuleCount; + + // RMessage for error notifications + TBool iErrorMessageAvailable; + RMessage2 iErrorMessage; + RArray iErrorQueue; + + // Reboot path definition + HBufC* iRebootPath; + // Reboot file name definition + HBufC* iRebootFilename; + // Reboot default path definition + TPtrC iRebootDefaultPath; + // Reboot default file name definition + TPtrC iRebootDefaultFilename; + + // Handle to Setting server. + RSettingServer iSettingServer; + + CRebootParams* iRebootParams; + TBool iIsTestReportGenerated; + + // For indication is measurement disable + TInt iDisableMeasurement; + + // Default timeout value. 0 - no timeout value + TInt64 iDefaultTimeout; + + // Counter for created TestModuleControllers + TInt iIndexTestModuleControllers; + + // Is this UI testing? + // If yes, then Test Engine works in a specific way. + // It creates new process for every test scripter's test case + // and deletes it after test case has finished. + TBool iUITestingSupport; + + // Should every test case be executed in separate process? + // This option is similar to iUITestingSupport, however + // it does not delete the process after test case is finished. + TBool iSeparateProcesses; + + //RPointerArray of versions of test modules + RPointerArray iTestModulesVersionInfo; + + public: // Friend classes + + protected: // Friend classes + + private: // Friend classes + + }; + +// DESCRIPTION +// CTestCase represents a subsession object in the CTestEngineServer. +// A session may own any number of CTestCase objects + +class CTestProgressNotifier; +class CTestCaseController; +class CTestEventNotifier; +class CTestRemoteCmdNotifier; +class CTestCommandNotifier; +class CTestCase + : public CObject + { + public: // Enumerations + + private: // Enumerations + + public: // Constructors and destructor + + /** + * NewL is two-phased constructor. + */ + static CTestCase* NewL( CTestEngine* aEngine, + CTestModuleController* aModuleController, + CTestReport* aTestReport, + TTestInfo& aTestInfo, + CTestModuleController* aRealModuleController); + + /** + * Destructor of CTestCase. + */ + ~CTestCase(); + + /** + * Close Test Case. + */ + void CloseTestCase(); + + public: // New functions + + /** + * Run test case. + */ + void RunTestCaseL( const RMessage2& aMessage ); + + /** + * Suspend the test case execution. + */ + TInt Pause(); + + /** + * Resume the suspended test case execution. + */ + TInt Resume(); + + /** + * Notify progress from Test Module. + */ + void NotifyProgressL( const RMessage2& aMessage ); + + /** + * Notify remote commands from Test Module. + */ + void NotifyRemoteTypeL( const RMessage2& aMessage ); + + /** + * Notify remote commands from Test Module. + */ + void NotifyRemoteMsgL( const RMessage2& aMessage ); + + /** + * Cancel outstanding asynchronous request. + */ + void CancelAsyncRequest( const RMessage2& aMessage ); + + /** + * Return the name of Test Module. + */ + const TDesC& ModuleName(); + + /** + * For event control. + */ + void CtlEvent( const TEventIf& aEvent, TRequestStatus& aStatus ); + + /** + * Check if CtlEvent should be called + */ + TBool CheckCtlEvent( const TEventIf& aEvent ); + + /** + * Executes command received from test case. + */ + void ExecuteCommandL(TCommand aCommand, TDesC8& aParamsPckg); + + /** + * Return module controller and real module controller. + */ + CTestModuleController* GetModuleControllers(CTestModuleController** aRealModuleController); + + /** + * Set new module controller for test case (only in case when original controller crashed). + */ + void ResetModuleController(CTestModuleController* aModuleController); + + /** + * Set new real module controller for test case (only in case when original controller crashed). + */ + void ResetRealModuleController(CTestModuleController* aRealModuleController); + + public: // Functions from base classes + + protected: // New functions + + protected: // Functions from base classes + + private: // New functions + + /** + * C++ default constructor. + */ + CTestCase( CTestEngine* aEngine, + CTestModuleController* aModuleController, + TTestInfo& aTestInfo, + CTestModuleController* aRealModuleController); + + /** + * By default Symbian OS constructor is private. + */ + void ConstructL( CTestReport* aTestReport, TTestInfo& aTestInfo ); + + /** + * Return the pointer to CStifLogger owned by CTestEngineServer + */ + CStifLogger* Logger(); + + public: // Data + + protected: // Data + + // Session owning us + CTestEngine* iTestEngine; + + private: // Data + + // Test Module + CTestModuleController* iTestModule; + + // Test case controller + CTestCaseController* iTestCaseController; + + // Notifier for print + CTestProgressNotifier* iTestCasePrint; + + // Notifier for event + CTestEventNotifier* iTestCaseEvent; + + // Notifier for remote commands + CTestRemoteCmdNotifier* iTestCaseRemoteCmd; + + // Handle to RTestServer + RTestServer iTestServer; + + // Handle to RTestExecution + RTestExecution iTestExecution; + + // Notifier for commands + CTestCommandNotifier* iTestCaseCommand; + + // Real Test Module (when test module controller is testscripter) + CTestModuleController* iRealModuleController; + + public: // Friend classes + + protected: // Friend classes + + private: // Friend classes + + }; + +#endif // TEST_ENGINE_H + +// End of File