/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

* 

* Description: This file contains the header file of the CTestEngine.

*

*/

#ifndef TEST_ENGINE_H

#define TEST_ENGINE_H

//  INCLUDES

#include <e32std.h>

#include <e32base.h>

#include <StifLogger.h>

#include <StifParser.h>

#include <stifinternal/TestServerClient.h>

#include "TestEngineClient.h"

#include "TestEngineEvent.h"

#include "STIFTestFrameworkSettings.h"

#include "SettingServerClient.h"

#include "STIFMeasurement.h"

#include "TestModuleInfo.h"

// CONSTANTS

// Heap sizes needed for creating server thread.

const TUint KTestEngineMinHeapSize = 0x10000;

const TUint KTestEngineMaxHeapSize = 0x100000;

// MACROS

// None

// DATA TYPES

// Panic reasons

enum TTestEnginePanic

    {

    EBadRequest,

    EBadDescriptor,

    EMainSchedulerError,

    ESvrCreateServer,

    ECreateTrapCleanup,

    EBadSubsessionHandle,

    ENoStartupInformation,

    EInvalidModuleName,

    EReqPending,

    EDoCancelDisorder,

    ECancelAsyncIPCError,

    EEventPanic

    };

// Struct to Test report settings

class TTestReportSettings

    {

    public:

        TTestReportSettings(){ iCreateTestReport = ETrue;

                                iPath = NULL;

                                iName = NULL;

                                iFormat = CStifLogger::ETxt;

                                iOutput = CStifLogger::EFile;

                                iOverwrite = ETrue; 

                                iXML = EFalse;

                             }

       ~TTestReportSettings(){ delete iPath; delete iName; }

    public:

        TBool                   iCreateTestReport; // Test report creation mode

        HBufC*                  iPath;             // Test report path

        HBufC*                  iName;             // Test report name

        CStifLogger::TLoggerType iFormat;          // Test report file type

        CStifLogger::TOutput    iOutput;           // Test report output

        TBool                   iOverwrite;        // Test report overwrite

        TBool                   iXML;              // Test report in xml format

    };

class CRebootParams

    :public CBase

    {

    public:     // Constructors and destructor

        /**

        * NewL is two-phased constructor.

        */

        static CRebootParams* NewL();

        /**

        * Destructor of CTestEngineServer.

        */

        ~CRebootParams();

        // Setters

        void SetTestModuleNameL( const TDesC& aName ); 

        void SetTestCaseFileNameL( const TDesC& aName ); 

        void SetTestCaseTitleL( const TDesC& aName ); 

        void SetTestCaseStateL( const TDesC& aName ); 

     private:    // New functions

        /** 

        * C++ default constructor.

        */

        CRebootParams();

        /**

        * By default Symbian OS constructor is private.

        */

        void ConstructL();

      public: // Data

        TInt iCaseNumber;

        TInt iStateCode;

        TPtrC iTestModule;

        TPtrC iTestCaseFile;

        TPtrC iTestCaseTitle;

        TPtrC iStateName;

      private: // Data   

        HBufC* iTestModuleBuf;

        HBufC* iTestCaseFileBuf;

        HBufC* iTestCaseTitleBuf;

        HBufC* iStateNameBuf;

    };

// FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

class CTestModuleController;

class CTestReport;

// CLASS DECLARATION

// DESCRIPTION

// CTestEngineServer is a server class.

// Contains an object container index which provides subsessions with object

// containers.

class CTestEngineServer

        : public CServer2

    {

    public:     // Enumerations

        enum { ETestEngineServerPriority = CActive::EPriorityHigh };

    private:    // Enumerations

    public:     // Constructors and destructor

        /**

        * NewL is two-phased constructor.

        */

        static CTestEngineServer* NewL();

        /**

        * Destructor of CTestEngineServer.

        */

        ~CTestEngineServer();

    public:     // New functions

        /**

        * ThreadFunction is used to create new thread.

        */

        static TInt ThreadFunction( TAny* aStarted );

        /**

        * Return object container, guaranteed to produce object containers with

        * unique ids within the server.

        */

        CObjectCon* NewContainerL();

        /**

        * Delete container.

        */

        void DeleteContainer( CObjectCon* aContainer );

        /**

        * Inform Server that session is closed.

        */

        void SessionClosed();

        /**

        * PanicServer panics the CTestEngineServer

        */

        static void PanicServer( TTestEnginePanic aPanic );

        /**

        * Return the pointer to iLogger

        */

        CStifLogger* Logger();

    public:     // Functions from base classes

        /**

        * NewSessionL creates new CTestEngineServer session.

        */

        CSession2* NewSessionL( const TVersion &aVersion,

                                const RMessage2& aMessage ) const;

    protected:  // New functions

    protected:  // Functions from base classes

    private:    // New functions

        /** 

        * C++ default constructor.

        */

        CTestEngineServer();

        /**

        * By default Symbian OS constructor is private.

        */

        void ConstructL();

    public:     // Data

        // Test report settings

        TTestReportSettings     iTestReportSettings;

        // Logger overwrite settings

        TLoggerSettings         iLoggerSettings;

    protected:  // Data

    private:    // Data

        // The server has an object container index which

        // creates an object container for each session

        CObjectConIx*           iContainerIndex; 

        // Logger instance

        CStifLogger*            iLogger;

        // Container count

        TInt                    iSessionCount;

    public:     // Friend classes

    protected:  // Friend classes

    private:    // Friend classes

    };

// DESCRIPTION

// Class used to store version information of test module.

// iTestModuleName field keeps name of test module dll

// iVersion keeps version of test module dll

    struct TTestModuleVersionInfo

    {

    	TFileName iTestModuleName;

    	TInt iMajor;

    	TInt iMinor;

    	TInt iBuild;

    };

// DESCRIPTION

// CTestEngine is a session class.

// Session for the CTestEngineServer server, to a single client-side session

// a session may own any number of CCounter objects

class CTestCase;

class CTestEventController;

class CTestEngine

        : public CSession2

    {

    public:     // Enumerations

    private:    // Enumerations

    public:     // Constructors and destructor

        /**

        * NewL is two-phased constructor.

        */

        static CTestEngine* NewL( CTestEngineServer* aServer );

        /**

        * Leave with notify

        */

        void LeaveWithNotifyL( TInt aCode, const TDesC& aText );

        /**

        * If error leave with notify

        */

        void LeaveIfErrorWithNotify( TInt aCode, const TDesC& aText );

        /**

        * Leave with notify

        */

        void LeaveWithNotifyL( TInt aCode );

        /**

        * If error leave with notify

        */

        void LeaveIfErrorWithNotify( TInt aCode );

        /**

        * Close the session to CTestEngineServer.

        */

        void CloseSession();

    public:     // New functions

        /**

        * PanicClient panics the user of CTestEngine ( RTestEngine user )

        */

        void PanicClient( TTestEnginePanic aPanic, const RMessage2& aMessage ) const;

        /**

        * NumResources is used to provide reserver resources to client.

        */

        void NumResources( const RMessage2& aMessage );

        /**

        * Return the number of resources owned by the session. 

        * Required by CSession if derived class implements resource

        * mark-start and mark-end protocol.

        */

        TInt CountResources();

        /**

        * Callback to inform that enumeration of test cases is completed

        */

        void EnumerationCompleted( TInt aCount, TInt aError = KErrNone );

        /**

        * Callback to check state event status.

        */

        TBool IsStateEventAndSet( const TName& aEventName );

        /**

        * Callback to control events.

        */

        CTestEventController* CtlEventL( const TEventIf& aEvent, 

                                         TRequestStatus& aStatus );

        /**

        * Return the pointer to CStifLogger owned by CTestEngineServer

        */

        CStifLogger* Logger();

        /**

        * Return testcases.

        */

        RPointerArray<CTestCase>& TestCaseArray(){ return iTestCaseArray; }

        /**

        * Return client events.

        */

        RPointerArray<TEventMsg>& ClientEvents(){ return iClientEvents; }

        /**

        * ErrorPrint print errors. This version is used to print engine own

        * errors.

        */

        void ErrorPrint( const TInt aPriority, 

                         TPtrC aError );

        /**

        * ErrorPrint print errors. This version is used to forward errors.

        */

        void ErrorPrint( TErrorNotificationPckg aError );

        /**

        * Write the Reboot related information to file.

        */

        TInt WriteRebootParams( TTestInfo& aTestInfo,

                                TInt& aCode, TDesC& aName );

        /**

        * Read the Reboot related information from the file.

        */

        TInt ReadRebootParams( TTestInfo& aTestInfo, 

                               TDes& aStateDes,

                               TInt& aState );

        /**

        * Pause all test case(s) which are/is running.

        */

        void PauseAllTestCases();

        /**

        * Flush ATS logger buffers.

        */ 

        void FlushAtsLogger();

        /**

        * Get device reset module's DLL name.

        */

        TPtrC GetDeviceResetDllName();

        /**

        * Get measurements related information. Returns is measurement disable.

        */

        TInt StifMeasurement();

        /**

        * For Recovering from serious testmodulecrash situations (KErrserverTerminated (-15))

        * Clones TestModuleController

        */

        void TestModuleCrash( CTestModuleController* aTestModuleController );

        /**

        * Executes command received from test case.

        * It was created to allow test case to kill itself.

        */

        void ExecuteCommandL(TCommand aCommand, TDesC8& aParamsPckg);

        /**

        * Returns new index for test module controller.

        * This number is appended to module controller name.

        * This method is used when option to run every test case in separate

        * process is set to on.                        

        */

        TInt GetIndexForNewTestModuleController(void);

        /**

        * Return free module controller specified by given parameter.

        * If it can't be found, new one will be created.                        

        */

        CTestModuleController* GetFreeOrCreateModuleControllerL(TTestInfo& aTestInfo,

                                                                CTestModuleController** aRealModuleController);

    public:     // Functions from base classes

        /**

        * ServiceL handles the messages to CTestEngineServer

        */

        virtual void ServiceL( const RMessage2& aMessage );

    protected:  // New functions

    protected:  // Functions from base classes

    private:    // New functions

        /** 

        * C++ default constructor.

        */

        CTestEngine();

        /**

        * By default Symbian OS constructor is private.

        */

        void ConstructL( CTestEngineServer* aServer );

        /**

        * DispatchMessageL handles the messages to CTestEngineServer

        */

        void DispatchMessageL( const RMessage2& aMessage );

        /**

        * Get module controller by name

        */

        CTestModuleController* ModuleControllerByName(

                                                const TName& aModuleName );

        /**

        * Initialize test report and logger's overwrite variables

        */

        void InitTestReportAndLoggerVarL();

        /**

        * Initialize the Test Engine.

        */

        void InitEngineL( const RMessage2& aMessage );

        /**

        * Parse Test Engine defaults from STIF initialization

        * file.

        */

        void ReadEngineDefaultsL( CStifParser* aParser,

                                    CSTIFTestFrameworkSettings* aSettings );

        /**

        * Set parsed logger's settings to TestEngine side.

        */

        void SetLoggerSettings( TLoggerSettings& aLoggerSettings );

        /**

        * Parse Test modules and module information from STIFTestFramework

        * initialization file.

        */

        void ReadTestModulesL( CStifParser* aParser );

        /**

        * 

        */

        void TestModuleConfigFileL( CTestModuleController* aModule,

                                        CStifSectionParser* aSectionParser,

                                        TDesC& aTag );

        /**

        * Sets attributes to Test Framework

        */

        void SetAttributeL( const RMessage2& aMessage );

        /**

        * Adds new Test Module

        */

        void AddTestModuleL( const RMessage2& aMessage );

        /**

        * Removes Test Module

        */

        TInt RemoveTestModuleL( const RMessage2& aMessage );

        /**

        * Close Test Engine

        */