MCL/sf/os/osrndtools: comparison stif/TestEngine/inc/TestEngine.h

equal deleted inserted replaced

--1:000000000000
+:a03f92240627
+/*
+* 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 <e32std.h>
+#include <e32base.h>
+#include <StifLogger.h>
+#include <StifParser.h>
+#include <stifinternal/TestServerClient.h>
+#include "TestEngineClient.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
+// DATA TYPES
+// Panic reasons
+enum TTestEnginePanic
+{
+EBadRequest,
+EBadDescriptor,
+EMainSchedulerError,
+ESvrCreateServer,
+ECreateTrapCleanup,
+EBadSubsessionHandle,
+ENoStartupInformation,
+EInvalidModuleName,
+EReqPending,
+EDoCancelDisorder,
+ECancelAsyncIPCError,
+EEventPanic
+};
+// Struct to Test report settings
+class TTestReportSettings
+{
+public:
+TTestReportSettings(){ iCreateTestReport = ETrue;
+iPath = NULL;
+iName = NULL;
+iFormat = CStifLogger::ETxt;
+iOutput = CStifLogger::EFile;
+iOverwrite = ETrue;
+iXML = EFalse;
+}
+~TTestReportSettings(){ delete iPath; delete iName; }
+public:
+TBool                   iCreateTestReport; // Test report creation mode
+HBufC*                  iPath;             // Test report path
+HBufC*                  iName;             // Test report name
+CStifLogger::TLoggerType iFormat;          // Test report file type
+CStifLogger::TOutput    iOutput;           // Test report output
+TBool                   iOverwrite;        // Test report overwrite
+TBool                   iXML;              // Test report in xml format
+};
+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
+// FORWARD DECLARATIONS
+class CTestModuleController;
+class CTestReport;
+// CLASS DECLARATION
+// DESCRIPTION
+// CTestEngineServer is a server class.
+// Contains an object container index which provides subsessions with object
+// containers.
+class CTestEngineServer
+: public CServer2
+{
+public:     // Enumerations
+enum { ETestEngineServerPriority = CActive::EPriorityHigh };
+private:    // Enumerations
+public:     // Constructors and destructor
+/**
+* NewL is two-phased constructor.
+*/
+static CTestEngineServer* NewL();
+/**
+* Destructor of CTestEngineServer.
+*/
+~CTestEngineServer();
+public:     // New functions
+/**
+* ThreadFunction is used to create new thread.
+*/
+static TInt ThreadFunction( TAny* aStarted );
+/**
+* Return object container, guaranteed to produce object containers with
+* unique ids within the server.
+*/
+CObjectCon* NewContainerL();
+/**
+* Delete container.
+*/
+void DeleteContainer( CObjectCon* aContainer );
+/**
+* Inform Server that session is closed.
+*/
+void SessionClosed();
+/**
+* PanicServer panics the CTestEngineServer
+*/
+static void PanicServer( TTestEnginePanic aPanic );
+/**
+* Return the pointer to iLogger
+*/
+CStifLogger* Logger();
+public:     // Functions from base classes
+/**
+* NewSessionL creates new CTestEngineServer session.
+*/
+CSession2* NewSessionL( const TVersion &aVersion,
+const RMessage2& aMessage ) const;
+protected:  // New functions
+protected:  // Functions from base classes
+private:    // New functions
+/**
+* C++ default constructor.
+*/
+CTestEngineServer();
+/**
+* By default Symbian OS constructor is private.
+*/
+void ConstructL();
+public:     // Data
+// Test report settings
+TTestReportSettings     iTestReportSettings;
+// Logger overwrite settings
+TLoggerSettings         iLoggerSettings;
+protected:  // Data
+private:    // Data
+// The server has an object container index which
+// creates an object container for each session
+CObjectConIx*           iContainerIndex;
+// Logger instance
+CStifLogger*            iLogger;
+// Container count
+TInt                    iSessionCount;
+public:     // Friend classes
+protected:  // Friend classes
+private:    // Friend classes
+};
+// 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 CTestEngine
+: public CSession2
+{
+public:     // Enumerations
+private:    // Enumerations
+public:     // Constructors and destructor
+/**
+* NewL is two-phased constructor.
+*/
+static CTestEngine* NewL( CTestEngineServer* aServer );
+/**
+* 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<CTestCase>& TestCaseArray(){ return iTestCaseArray; }
+/**
+* Return client events.
+*/
+RPointerArray<TEventMsg>& 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);
+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 );
+/**
+* Initialize test report and logger's overwrite variables
+*/
+void InitTestReportAndLoggerVarL();
+/**
+* Initialize the Test Engine.
+*/
+void InitEngineL( const RMessage2& aMessage );
+/**
+* Parse Test Engine defaults from STIF initialization
+* file.
+*/
+void ReadEngineDefaultsL( CStifParser* aParser,
+CSTIFTestFrameworkSettings* aSettings );
+/**
+* Set parsed logger's settings to TestEngine side.
+*/
+void SetLoggerSettings( TLoggerSettings& aLoggerSettings );
+/**
+* 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( TUint aHandle );
+/**
+* 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);
+public:     // Data
+protected:  // Data
+private:    // Data
+// Test module array
+RPointerArray<CTestModuleController> iModules;
+// Object container for this session
+CObjectCon*                 iContainer;
+// Object index which stores objects (CTestCase instances)
+// for this session
+CObjectIx*                  iTestCases;
+// Object index which stores objects (CTestEngineSubSession instances)
+// for this session
+CObjectIx*                  iTestEngineSubSessions;
+// Array of CTestCase instances
+RPointerArray<CTestCase>    iTestCaseArray;
+// Pointer to owning server
+CTestEngineServer*          iTestEngineServer;
+// Test Report
+CTestReport*                iTestReport;
+// Test Report Mode
+TUint                       iReportMode;
+// Test Report Output Type
+TUint                       iReportOutput;
+// Device reset module's DLL name(Reboot)
+HBufC*                      iDeviceResetDllName;
+// Total number of resources allocated
+TInt                        iResourceCount;
+// Test Engine's initialization file
+HBufC*                      iIniFile;
+// 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<HBufC>        iStateEvents;
+// Client event Array
+RPointerArray<TEventMsg>    iClientEvents;
+// Number of enumerated test modules currently
+TInt                        iEnumerateModuleCount;
+// RMessage for error notifications
+TBool                       iErrorMessageAvailable;
+RMessage2                   iErrorMessage;
+RArray<TErrorNotification>    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<TTestModuleVersionInfo> iTestModulesVersionInfo;
+public:     // Friend classes
+protected:  // Friend classes
+private:    // Friend classes
+};
+// DESCRIPTION
+// CTestEngineSubSession represents a subsession object in the CTestEngineServer.
+// A session may own any number of CTestEngineSubSession objects
+class CTestEngineSubSession
+: public CObject
+{
+public:     // Enumerations
+private:    // Enumerations
+public:     // Constructors and destructor
+/**
+* NewL is two-phased constructor.
+*/
+static CTestEngineSubSession* NewL( CTestEngine* aEngine );
+/**
+* Destructor of CTestCase.
+*/
+~CTestEngineSubSession();
+public:     // New functions
+public:     // Functions from base classes
+protected:  // New functions
+protected:  // Functions from base classes
+private:    // New functions
+/**
+* C++ default constructor.
+*/
+	CTestEngineSubSession( CTestEngine* aEngine);
+/**
+* By default Symbian OS constructor is private.
+*/
+void ConstructL();
+public:     // Data
+protected:  // Data
+// Session owning us
+CTestEngine*            iTestEngine;
+private:    // Data
+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

changeset 0	a03f92240627
child 10	381827f66490