/*
* 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
// 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, 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<TDesC> iTestCaseTitles;    //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
