diff -r 7fdc9a71d314 -r 8ad140f3dd41 stif/TestServer/inc/TestServer.h --- /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 +#include +#include "PrintQueue.h" +#include +#include "Logging.h" +#include +#include + +// 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* 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 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* 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 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