/*

* 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