--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/stif/TestServer/inc/TestServer.h Wed Oct 13 16:17:58 2010 +0300
@@ -0,0 +1,1685 @@
+/*
+* 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
+* CTestServer.
+*
+*/
+
+#ifndef TEST_SERVER_H
+#define TEST_SERVER_H
+
+
+// INCLUDES
+#include <e32std.h>
+#include <e32base.h>
+#include "PrintQueue.h"
+#include <StifLogger.h>
+#include "Logging.h"
+#include <StifTestModule.h>
+#include <StifTestInterface.h>
+
+// CONSTANTS
+
+// KDefaultHeapSize needed for creating server thread.
+const TUint KDefaultHeapSize = 0x10000;
+const TUint KMaxHeapSize = 0x20000;
+
+// MACROS
+
+// FUNCTION PROTOTYPES
+typedef CTestModuleBase*( *CTestInterfaceFactory )();
+
+// DATA TYPES
+
+// Panic reasons
+enum TTestServerPanic
+ {
+ EBadRequest,
+ EBadDescriptor,
+ EDescriptorNonNumeric,
+ EMainSchedulerError,
+ ESvrCreateServer,
+ ECreateTrapCleanup,
+ EBadRemove,
+ EBadSubsessionHandle,
+ ENoStartupInformation,
+ EEnumerateHasNotBeenCalled,
+ EClosingWhileTestRunning,
+ EPrintMutexNotFreed,
+ EThreadMutexNotFreed,
+ EEventMutexNotFreed,
+ EEventArrayMutexNotFreed,
+ ETestModuleMutexNotFreed,
+ EInvalidCTestExecution,
+ EPrintQueueBroken,
+ EInvalidRequestCancel,
+ EWrongEventQueueDeleteContext,
+ EReInitializingTestModule,
+ ETestModuleNotInitialized,
+ EInvalidTestModuleOperation,
+ EWrongHeapInUse,
+ ENullTestModuleFunction,
+ ENullTestModuleContainer,
+ ENullTestModule,
+ ECannotCreateEventArray,
+ EPreviousRequestStillOngoing,
+ ECannotOpenServerThread,
+ ENullModuleSession,
+ EInvalidThreadState,
+ EUnknownEventCmd,
+ EUnknownRemoteCmd,
+ ENullTestThreadContainer,
+ ENullExecution,
+ EAlreadyActive,
+ };
+
+
+// FUNCTION PROTOTYPES
+
+// FORWARD DECLARATIONS
+class TEvent;
+class CTestModule;
+class CTestModuleContainer;
+class CTestExecution;
+class CTestThreadContainer;
+class CErrorPrintHandler;
+class CTestThreadContainerRunnerFactory;
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// CUnderTaker class is an active object that handles thread death
+// notifications.
+class CUnderTaker
+ :public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CUnderTaker* NewL( CTestModuleContainer* aContainer );
+
+ /**
+ * Destructor of CUnderTaker.
+ */
+ virtual ~CUnderTaker();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ TInt StartL();
+
+ /**
+ * Is undertaker completed?
+ */
+ TBool Completed();
+
+ /**
+ * Sets or unsets local processing mode
+ */
+ void SetSynchronousMode(const TBool aMode);
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CUnderTaker();
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL( CTestModuleContainer* aContainer );
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestModuleContainer* iModuleContainer; // Pointer to parent
+ TBool iCancelNeeded; // Is cancel needed?
+ TBool iSynchronousMode; // In synchronous mode
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+
+
+
+// DESCRIPTION
+// CTestModuleContainer is a class, which contains the test execution thread
+// and interface functions to do operations in that thread context.
+class CTestModuleContainer
+ :public CActive
+ {
+
+ public: // Enumerations
+ enum TOperation
+ {
+ EInitializeModule,
+ EEnumerateInThread,
+ EExecuteTestInThread,
+ EFreeEnumerationData,
+ EExit,
+ };
+
+ enum TRequestType
+ {
+ ERqTestCase,
+ ERqErrorPrint,
+ };
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CTestModuleContainer* NewL( const TDesC& aName,
+ CTestModule* aSession,
+ const TDesC& aConfig );
+
+ /**
+ * Destructor of CTestModuleContainer.
+ */
+ virtual ~CTestModuleContainer();
+
+
+ public: // New functions
+
+ /**
+ * Initialize the test module
+ */
+ TInt Initialize( const TFileName& aName,
+ const TBool aFirstTime );
+
+ /**
+ * Enumerate test cases
+ */
+ TInt EnumerateTestCases( const TFileName& aName );
+
+
+ /**
+ * Frees the enumeration data
+ */
+ TInt FreeEnumerationData();
+
+ /**
+ * Run a test case
+ */
+ void RunTestCase( const TFileName& aName,
+ const TInt aCaseNumber,
+ const RMessage2& aMessage );
+
+
+ /**
+ * Changes the operation, can fail
+ */
+ TInt ChangeOperation( const TOperation aOperation,
+ const TFileName& aNameBuffer,
+ const TInt aInt );
+
+ /**
+ * Changes the operation
+ */
+ void ChangeOperationNoError( const TOperation aOperation,
+ const TInt aInt );
+
+ /**
+ * Return the operation
+ */
+ //@spe const TOperation Operation();
+ TOperation Operation();
+
+ /**
+ * Set a new execution subsession
+ */
+ void SetExecutionSubSession( CTestExecution* aExecution );
+
+ /**
+ * Pauses the thread
+ */
+ TInt PauseThread();
+
+ /**
+ * Resumes the thread
+ */
+ TInt ResumeThread();
+
+ /**
+ * Returns pointer to test cases
+ */
+ const RPointerArray<TTestCaseInfo>* TestCases() const;
+
+ /**
+ * Returns error code from operation
+ */
+ TInt& OperationErrorResult();
+
+ /**
+ * Returns error code from module
+ */
+ TInt& ModuleResult();
+
+ /**
+ * Kill the thread
+ */
+ void KillThread( const TInt aCode );
+
+ /**
+ * Error print handler.
+ */
+ void DoErrorPrint();
+
+ /**
+ * Make sure that any of the test interference thread's won't stay
+ * to run if test case is crashed of test interference object is not
+ * deleted.
+ */
+ void KillTestinterferenceThread();
+
+ /**
+ * Make sure that any of the test measurement process's won't stay
+ * to run if test case is crashed of test measurement object is not
+ * deleted.
+ */
+ void KillTestMeasurement();
+
+ public:
+
+ /**
+ * Get semaphore handles.
+ */
+ TInt OperationStartSemHandle(){ return iOperationStartSemaphore.Handle(); };
+ TInt OperationChangeSemHandle(){ return iOperationChangeSemaphore.Handle(); };
+
+ /**
+ * Access to "shared" memory.
+ * Called from test thread'
+ */
+ void SetThreadContainer( CTestThreadContainer* aThread )
+ { iThreadContainer = aThread; };
+
+ const TDesC& OperationName(){ return iOperationName; };
+
+ TDes& OperationText(){ return iOperationText; };
+
+ TInt& OperationIntBuffer(){ return iOperationIntBuffer; };
+
+ TOperation OperationType(){ return iOperationType; };
+
+ const TDesC& TestModuleName();
+ const TDesC& TestModuleIniFile();
+
+ CTestModuleIf::TExitReason& AllowedExitReason()
+ { return iAllowedExitReason; };
+
+ TInt& AllowedExitCode(){ return iAllowedExitCode; };
+
+ TThreadId ServerThreadId(){ return iServerThreadId; };
+
+ CTestExecution* TestExecution()
+ { return iCTestExecution; };
+
+ TRequestStatus* GetRequest( TRequestType aType );
+
+ TErrorNotification& ErrorNotification(){ return iErrorPrint; };
+
+ TInt ErrorPrintSemHandle(){ return iErrorPrintSem.Handle(); };
+
+ /**
+ * Get title of currently running test case
+ */
+ void GetTestCaseTitleL(TDes& aTestCaseTitle);
+
+ /**
+ * Gets pointer to test module
+ */
+ CTestModule* GetTestModule();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL( const TDesC& aName,
+ CTestModule* aSession,
+ const TDesC& aConfig );
+
+ private: // New functions
+
+ /**
+ * Start and wait until operation is completed.
+ */
+ TInt StartAndWaitOperation();
+
+ /**
+ * Completes operation from test execution thread or from undertaker
+ */
+ void Complete( const TInt aCompletionCode );
+
+ /**
+ * Function that initialise module in execution thread context.
+ */
+ TInt InitializeModuleInThread( RLibrary& aModule );
+
+ /**
+ * Function that enumerates test cases in execution thread context.
+ */
+ TInt EnumerateInThread();
+
+ /**
+ * Function that frees the enumeration data in execution thread context.
+ */
+ void FreeEnumerationDataInThread();
+
+ /**
+ * Function that executes test case in execution thread context.
+ */
+ TInt ExecuteTestCaseInThread();
+
+
+ /**
+ * Delete a test module instance
+ */
+ void DeleteTestModule();
+
+ /**
+ * Function that resolves test case completion code
+ */
+ TInt ResolveCompletionCode( TInt aLeaveCode,
+ TInt aErrorCode );
+
+ /**
+ * Test case execution thread thread function
+ */
+ static TInt ExecutionThread( TAny* aParams );
+
+ /**
+ * Parse stack and heap information for TestScripter's
+ * test case (config) file.
+ */
+ TInt ReadParametersFromScriptFileL( const TDesC& aConfig,
+ TInt& aStackSize,
+ TInt& aHeapMinSize,
+ TInt& aHeapMaxSize );
+
+ /**
+ * Loads dynamically testmodule and calls SetRequirements()-
+ * method for test module parameter handling.
+ */
+ TInt ReadParametersFromTestModule( const TDesC& aModuleName,
+ CTestModuleParam*& aTestModuleParam );
+
+ /**
+ * Load test module dynamically. If loading is done succesfully
+ * then get test module's parameters according to version.
+ * Verifies received parameters also.
+ */
+ TInt GetTestModuleParams( const TDesC& aModuleName,
+ const TDesC& aConfig,
+ TInt& aStackSize,
+ TInt& aHeapMinSize,
+ TInt& aHeapMaxSize );
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CTestModuleContainer();
+
+ public: // Data
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestExecution* iCTestExecution; // Handle to "parent" test execution
+ CTestModule* iCTestModule; // Handle to "parent" module
+ CUnderTaker* iUnderTaker; // Pointer to thread undertaker
+ CTestThreadContainer* iThreadContainer;// Pointer thread container
+
+ RThread iThread; // Thread where test module lives in
+ TBool iUpAndRunning; // Is the thread running
+ TOperation iOperationType; // What to do?
+
+ RSemaphore iOperationStartSemaphore; // Used to wait until something to do
+ RSemaphore iOperationChangeSemaphore; // Protects the operation changes
+
+ TPtr iOperationName; // Operation descriptor buffer
+ HBufC* iModuleNameBuffer; // HBuffer for module name file;
+
+ TInt iOperationIntBuffer; // Transfers operation int to thread
+
+ RMessage2 iMessage; // Message to complete, used in RunTestCase
+
+ // Results from test module
+ TInt iModuleResult; // Low priority result from test module
+ TInt iErrorResult; // High priority error from operation
+ TRequestStatus iOperationStatus; // Operation ongoing?
+ TThreadId iServerThreadId; // Server thread Id. Used in completion
+ TBuf<30> iOperationText; // Human readable current operation for
+
+ CTestModuleIf::TExitReason iAllowedExitReason; // Allowed exit reason
+ TInt iAllowedExitCode; // Allowed exit code
+
+ // Error print handler
+ CErrorPrintHandler* iErrorPrintHandler;
+
+ RSemaphore iErrorPrintSem; // Synchonize error messages
+ TErrorNotification iErrorPrint;
+
+ // Indicates is pause operation executed. This value will be checked
+ // when test case is executed. Resume operation will be reset this
+ // value.
+ TBool iIsPaused;
+
+ // This active scheduler is uses as a nested one
+ CActiveSchedulerWait* iNestedActiveScheduler;
+
+ public: // Friend classes
+ friend class CUnderTaker; // Handles the thread deaths
+ friend class CErrorPrintHandler;
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+ };
+
+
+// DESCRIPTION
+// CTestServer is a server class.
+// Contains an object container index which provides subsessions with object containers.
+class CTestServer
+ :public CServer2
+ {
+ public: // Enumerations
+ enum { ETestServerPriority = CActive::EPriorityHigh };
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CTestServer* NewL( const TFileName& aName );
+
+ /**
+ * Destructor of CTestServer.
+ */
+ ~CTestServer();
+
+ 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();
+
+ /**
+ * Removes a container. Needed to close session properly.
+ */
+ void DeleteContainer( CObjectCon* aContainer );
+
+ /**
+ * Inform Server that session is closed.
+ */
+ void SessionClosed();
+
+ /**
+ * Returns module name
+ */
+ const TDesC& ModuleName() const;
+
+ /**
+ * Is module inside this server already initialised?
+ */
+ //@spe const TBool FirstTime() const;
+ TBool FirstTime() const;
+
+ /**
+ * Clears the module first time flag.
+ */
+ void ClearFirstTime();
+
+ /**
+ * PanicServer panics the CTestServer
+ */
+ static void PanicServer( const TTestServerPanic aPanic );
+
+ /**
+ * GetServerThreadId for ServerStateHandler Active object usage
+ */
+ TInt GetServerThreadId ();
+
+ /**
+ * Gets CTestThreadContainerRunner pointer which is used in UI testing
+ */
+ CTestThreadContainerRunnerFactory* GetTestThreadContainerRunnerFactory();
+
+ /**
+ * Gets information that testserver supports UI testing or not
+ */
+ TBool UiTesting();
+
+ /**
+ * Gets pointer to UiEnvProxy.
+ */
+ CUiEnvProxy* GetUiEnvProxy();
+ public: // Functions from base classes
+
+ /**
+ * NewSessionL creates new CTestServer session.
+ */
+ CSession2* NewSessionL( const TVersion &aVersion,
+ const RMessage2& aMessage ) const;
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CTestServer();
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL( const TFileName& aName );
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CObjectConIx* iContainerIndex; // Pointer to container
+ TPtr iModuleName; // Server name
+ HBufC* iModuleNameBuffer; // HBuffer for module name file;
+ TBool iFirstTime; // Is module previously initialized?
+
+ // Container count
+ TInt iSessionCount;
+
+ TBool iUiTesting; // Indicates if it is testserver which supports UI testing
+ CTestThreadContainerRunnerFactory* iTestThreadContainerRunnerFactory; // Pointer to CTestThreadContainerRunnerFactory
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+// DESCRIPTION
+// CTestCasesList is a class, which contains list of test cases assosiated with
+// specified config file.
+NONSHARABLE_CLASS( CTestCasesList ): public CBase
+ {
+public:
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CTestCasesList* NewL( const TDesC& aConfigFileName );
+public:
+ /**
+ * Destructor of CTestServer.
+ */
+ ~CTestCasesList();
+
+ /**
+ * Appends test case.
+ */
+ void AppendTestCaseL( const TDesC& aTestCaseTitle );
+
+ /**
+ * Returns specified test case title.
+ */
+ const TDesC& GetTestCaseTitleL( TInt aIndex ) const;
+
+ /**
+ * Returns config file name.
+ */
+ const TDesC& GetConfigFileName() const;
+
+ /**
+ * Returns count of test cases.
+ */
+ TInt Count() const;
+
+ /**
+ * Resets list of test cases.
+ */
+ void ResetAndDestroy();
+private:
+ /**
+ * C++ default constructor.
+ */
+ CTestCasesList();
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL( const TDesC& aConfigFileName );
+private:
+ // Config file name
+ HBufC* iConfigFileName;
+ // List of test cases
+ RPointerArray<HBufC> iTestCases;
+ };
+
+
+// DESCRIPTION
+// CTestModule is a session class.
+// Session for the CTestServer server, to a single client-side session
+// a session may own any number of CCounter objects
+class CTestModule
+ :public CSession2
+ {
+ public:
+ // None
+
+ private: // Enumerations
+ // None
+
+ public: // Constructors and destructor
+
+ /**
+ * Construct a test module object.
+ */
+ static CTestModule* NewL( CTestServer* aServer );
+
+ /**
+ * Destructor
+ */
+ virtual ~CTestModule();
+
+ public: // New functions
+
+ /**
+ * Dispatch message
+ */
+ TInt DispatchMessageL( const RMessage2& aMessage );
+
+ /**
+ * Create Module Session
+ */
+ TInt CreateModuleSessionL( const RMessage2& aMessage );
+
+ /**
+ * Close the session to CTestServer.
+ */
+ TInt CloseSession( const RMessage2& aMessage );
+
+
+ /**
+ * Create CTestExecution subsession.
+ */
+ TInt NewTestExecutionL( const RMessage2& aMessage );
+
+ /**
+ * Destroy the created CTestExecution subsession.
+ * Cannot fail - can panic client.
+ */
+ void DeleteTestExecution( const TUint aHandle, const RMessage2& aMessage );
+
+ /**
+ * NumResources is used to provide reserver resources to client.
+ */
+ void NumResources( const RMessage2& aMessage );
+
+ /**
+ * Return the number of resources owned by the session.
+ */
+ TInt CountResources();
+
+ /**
+ * Enumerates test cases
+ */
+ TInt EnumerateTestCasesL( const RMessage2& aMessage );
+
+ /**
+ * Get test cases
+ */
+ TInt GetTestCasesL( const RMessage2& aMessage );
+
+ /**
+ * Handles error notifications
+ */
+ TInt HandleErrorNotificationL( const RMessage2& aMessage );
+
+ /**
+ * Get Server Thread Id
+ */
+ TInt GetServerThreadIdL( const RMessage2& aMessage );
+
+
+ /**
+ * Prints error notification
+ */
+ void ErrorPrint( const TInt aPriority,
+ TPtrC aError );
+
+ /**
+ * Cancels asynchronous request
+ */
+ TInt CancelAsyncRequestL( const RMessage2& aMessage );
+
+ /**
+ * Frees a test case specific data owned by module( i.e enumeration data )
+ */
+ TInt FreeCaseData();
+
+ /**
+ * Returns case corresponding handle
+ */
+ CTestExecution* CaseFromHandle( const TUint aHandle, const RMessage2& aMessage ) const;
+
+ /**
+ * Returns module initialisation file name
+ */
+ const TDesC& IniName() const;
+
+ /**
+ * Returns module name
+ */
+ const TDesC& Name() const;
+
+ /**
+ * Returns a test module.
+ */
+ TInt GetTestModule( CTestModuleContainer*& aContainer,
+ const TDesC& aConfig );
+
+ /**
+ * Frees a test module.
+ */
+ TInt FreeTestModule( CTestModuleContainer* aModule );
+
+ /**
+ * Write is utility method.
+ */
+ void Write( const TAny* aPtr, const TDesC8& aDes, TInt anOffset = 0 );
+
+ /**
+ * PanicClient panics the user of CTestModule( RTestModule user )
+ */
+ void PanicClient( TInt aPanic, const RMessage2& aMessage ) const;
+
+ /**
+ * Get title of currently running test case
+ */
+ void GetTestCaseTitleL(TInt aTestCaseNumber, const TDesC& aConfigFile, TDes& aTestCaseTitle);
+
+ /**
+ * Get pointer to test server
+ */
+ CTestServer* GetTestServer();
+
+ public: // Functions from base classes
+
+ /**
+ * ServiceL handles the messages to CTestServer
+ */
+ virtual void ServiceL( const RMessage2& aMessage );
+
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CTestModule();
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL( CTestServer* aServer );
+
+ public: //Data
+ // None
+
+
+ protected: // Data
+ // None
+
+ private: // Data
+ RPointerArray<CTestModuleContainer>* iTestModuleInstances; // List of FREE test modules
+ CTestServer* iTestServer; // Pointer to "parent"
+ CObjectCon* iContainer; // Object container for this session
+ CObjectIx* iTestExecutionHandle; // Object index( stores CTestExecutions,
+ // (Unclosed)subsession handle )
+
+ TInt iResourceCount; // Total number of resources allocated
+ TPtr iIni; // Module initialisation( file ) name
+ HBufC* iIniBuffer; // HBuffer for ini name file;
+
+ CTestModuleContainer* iEnumerateModule; // Module used in enumeration
+
+ RMessage2 iErrorMessage; // Error message
+
+ TBool iErrorMessageAvailable; // Error message available?
+
+ RPointerArray<CTestCasesList> iTestCaseTitlesMap; //Test case titles
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// CPrintHandler class is an active object that handles print
+// indication from test thread.
+class CPrintHandler
+ : public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CPrintHandler* NewL( CTestExecution& aExecution );
+
+ /**
+ * Destructor of CPrintHandler.
+ */
+ virtual ~CPrintHandler();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ void StartL();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CPrintHandler( CTestExecution& aExecution );
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestExecution& iExecution; // Pointer to parent
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// CEventHandler class is an active object that handles print
+// indication from test thread.
+class CEventHandler
+ : public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CEventHandler* NewL( CTestExecution& aExecution );
+
+ /**
+ * Destructor of CEventHandler.
+ */
+ virtual ~CEventHandler();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ void StartL();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CEventHandler( CTestExecution& aExecution );
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestExecution& iExecution; // Pointer to parent
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// CSndHandler class is an active object that handles print
+// indication from test thread.
+class CSndHandler
+ : public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CSndHandler* NewL( CTestExecution& aExecution );
+
+ /**
+ * Destructor of CSndHandler.
+ */
+ virtual ~CSndHandler();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ void StartL();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CSndHandler( CTestExecution& aExecution );
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestExecution& iExecution; // Pointer to parent
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// CRcvHandler class is an active object that handles print
+// indication from test thread.
+class CRcvHandler
+ : public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CRcvHandler* NewL( CTestExecution& aExecution );
+
+ /**
+ * Destructor of CRcvHandler.
+ */
+ virtual ~CRcvHandler();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ void StartL();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CRcvHandler( CTestExecution& aExecution );
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestExecution& iExecution; // Pointer to parent
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// CErrorPrintHandler class is an active object that handles print
+// indication from test thread.
+class CErrorPrintHandler
+ : public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CErrorPrintHandler* NewL( CTestModuleContainer& aContainer );
+
+ /**
+ * Destructor of CErrorPrintHandler.
+ */
+ virtual ~CErrorPrintHandler();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ void StartL();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CErrorPrintHandler( CTestModuleContainer& aContainer );
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestModuleContainer& iContainer; // Pointer to parent
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// CTestInterferenceHandler class is an active object that handles test
+// interference
+NONSHARABLE_CLASS( CInterferenceHandler )
+ : public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CInterferenceHandler* NewL( CTestExecution& aExecution );
+
+ /**
+ * Destructor of CInterferenceHandler.
+ */
+ virtual ~CInterferenceHandler();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ void StartL();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CInterferenceHandler( CTestExecution& aExecution );
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestExecution& iExecution; // Pointer to parent
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+
+// DESCRIPTION
+// CMeasurementHandler class is an active object that handles test
+// measurement
+NONSHARABLE_CLASS( CMeasurementHandler )
+ : public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CMeasurementHandler* NewL( CTestExecution& aExecution );
+
+ /**
+ * Destructor of CMeasurementHandler.
+ */
+ virtual ~CMeasurementHandler();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ void StartL();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError( TInt aError );
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CMeasurementHandler( CTestExecution& aExecution );
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+
+ // Pointer to test execution side
+ CTestExecution& iExecution;
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+/**
+* Check is module TestScripter. Does parsing and returns new module name and
+* error codes(Needed operations when creating server sessions to TestScripter).
+*/
+TInt CheckModuleName( TFileName aModuleName, TFileName& aNewModuleName );
+
+/**
+* Remove optional index appended to module name.
+* If it is found (@ char) then set new module name without it.
+* This feature is used when iSeparateProcesses is set in TestEngine.
+*/
+void RemoveOptionalIndex(const TDesC& aModuleName, TDes& aNewModuleName);
+
+// DESCRIPTION
+// CEventHandler class is an active object that handles print
+// indication from test thread.
+NONSHARABLE_CLASS(CCommandHandler)
+ : public CActive
+ {
+
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CCommandHandler* NewL(CTestExecution& aExecution);
+
+ /**
+ * Destructor of CCommandHandler.
+ */
+ virtual ~CCommandHandler();
+
+ public: // New functions
+
+ /**
+ * Start monitoring
+ */
+ void StartL();
+
+ public: // Functions from base classes
+
+ /**
+ * RunL derived from CActive handles the completed requests.
+ */
+ void RunL();
+
+ /**
+ * DoCancel derived from CActive handles the Cancel
+ */
+ void DoCancel();
+
+ /**
+ * RunError derived from CActive handles errors from active handler.
+ */
+ TInt RunError(TInt aError);
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CCommandHandler(CTestExecution& aExecution);
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL();
+
+ public: //Data
+ // None
+
+ protected: // Data
+ // None
+
+ private: // Data
+ CTestExecution& iExecution; // Pointer to parent
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ // None
+
+ };
+
+#endif // TEST_SERVER_H
+
+// End of File