/*

 * 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 TestScripter 

 * module of STIF Test Framework.

 *

 */

#ifndef TESTSCRIPTERUTILS_H_

#define TESTSCRIPTERUTILS_H_

//  INCLUDES

#include <StifTestInterface.h>

#include <StifTFwIfProt.h>

// CONSTANTS

// None

// MACROS

// None

// DATA TYPES

typedef TBuf<0x200> TRemoteProtMsg;

// FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

class CTestRunner;

class CSubTestCaseRunner;

class CRemoteCallTimeoutMonitor;

class CStifTFwIfProt;

class CStifLogger;

class CSlave;

class CRemoteSubTestCaseRunner;

// DESCRIPTION

// Testcase starting information

NONSHARABLE_CLASS(CStartInfo): public CBase

    {

    public: // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CStartInfo* NewL();

        /**

        * Destructor.

        */

        virtual ~CStartInfo();

    public: // New functions

        /**

        * Sets module name.

        */

        void SetModuleNameL( const TDesC& aModule, TInt aExtLength = 0 );

        /**

        * Sets initialization file name.

        */

        void SetIniFileL( const TDesC& aIni );

        /**

        * Sets configuration file name.

        */

        void SetConfigL( const TDesC& aConfig );

        /**

        * Sets test identifier.

        */

        void SetTestIdL( const TDesC& aTestId );

        /**

        * Sets test case title.

        */

        void SetTitleL( const TDesC& aTitle);

        /**

         * Sets test case index.

         */

        void SetTestCaseNumber( TInt aTestCaseNumber );

        /**

         * Sets test case expected result.

         */

        void SetExpectedResult( TInt aExpectedResult );

        /**

         * Sets expected result category.

         */

        void SetExpectedResultCategory( TFullTestResult::TCaseExecutionResult aCategory );

        /**

         * Sets timeout value.

         */

        void SetTimeout( TInt aTimeout );

        /**

         * Gets test module name.

         */

        const TDesC& GetModuleName() const;

        /**

         * Gets ini file path.

         */

        const TDesC& GetIniFile() const;

        /**

         * Gets config file path

         */

        const TDesC& GetConfig() const;

        /**

         * Gets test case id.

         */

        const TDesC& GetTestId() const;

        /**

         * Gets test case title.

         */

        const TDesC& GetTitle() const;

        /**

         * Gets test case title.

         */

        TInt GetTestCaseNumber() const;

        /**

         * Gets expected result.

         */

        TInt GetExpectedResult() const;

        /**

         * Gets expected result category.

         */

        TFullTestResult::TCaseExecutionResult GetExpectedResultCategory() const;

        /**

         * Gets timeout value.

         */

        TInt GetTimeout() const;

        /**

         * Copy values from other CStartInfo instance.

         */

        void CopyL( const CStartInfo& aStartInfo );

    private:

        /**

        * C++ default constructor.

        */

        CStartInfo();

        /**

        * By default Symbian OS constructor is private.

        */

        void ConstructL();

    private:

        // Module name

        HBufC*  iModule;

        // Ini file path

        HBufC*  iIniFile;

        // Config file path

        HBufC*  iConfig;

        // Test id ( used for complete, pausetest, reasume

        HBufC*  iTestId;

        // Title of the test case

        HBufC*  iTitle;

        // Test case index

        TInt    iCaseNum;

        // Test case expected result

        TInt    iExpectedResult;

        // Test case expected result category

        TFullTestResult::TCaseExecutionResult iCategory;

        // Test case timeout value

        TInt    iTimeout;

    };

// TestScripter loop helper

NONSHARABLE_CLASS(CLoopHelper): public CActive

    {

    public:

        /**

        * Two-phased constructor.

        */

        static CLoopHelper* NewL( CTestRunner* aTestRunner );

    public:

        /**

        * Destrucktor.

        */

        ~CLoopHelper();

        /**

         * Should be to indicate loop start.

         */

        void LoopStartL();

        /**

         * Should be called to indicate end of iteration and begining of next iteration

         */

        void IterationEndStartNextIterationL();

        /**

         * Should be called to indicate loop end

         */

        void LoopEndL();

        /**

         * Should be called to register sub test case executed inside loop

         */

        void RegisterInLoopSubTestCaseL( CSubTestCaseRunner* aSubTestCaseRunner );

        /**

         * Should be called to unregister sub test case executed inside loop

         */

        void UnregisterInLoopSubTestCaseL( CSubTestCaseRunner* aSubTestCaseRunner );

        /**

         * Should be called to register remote event allocated inside loop

         */

        void RegisterInLoopSlaveL( CSlave* aSlave );

        /**

         * Should be called to unregister remote event allocated inside loop

         */

        void UnregisterInLoopSlaveL( CSlave* aSlave );

        /**

         * Returns array of registered in loop slaves.

         */

        RPointerArray<CSlave>& GetRegisteredInLoopSlaves();

        /**

         * Should be called to indicate end of sub test case executed inside loop

         */

        void NotifySubTestCaseEndL( CSubTestCaseRunner* aSubTestCaseRunner, TBool aPassed );

        /**

         * Indicates whether loop is in progress or not

         */

        TBool LoopInProgress() const;

    private:

        /**

         * Constructor

         */

        CLoopHelper( CTestRunner* aTestRunner );

        /**

        * By default Symbian OS constructor is private.

        */

        void ConstructL();

        /**

         * See CActive::DoCancel

         */

        void DoCancel();

        /**

         * See CActive::Runl

         */

        void RunL();

        /**

         * Indicate begining of the loop iteration

         */

        void IterationBeginL( TBool aFirstIteration );

        /**

         * Indicate end of the loop iteration

         */

        void IterationEndL( TBool aLastIteration );        

    private:

        // Pointer to CTestRunner

        CTestRunner* iTestRunner;

        // Indicates whether loop is in progress

        TBool iInProgress;

        // Indicates whether loop iteration is ongoing

        TBool iIterationOngoing;

        // Indicates whether current iteration is last iteration 

        TBool iLoopEnd;

        // Counter of passed iterations

        TInt iPassedIterationsCounter;

        // Indicates if current iteration should be count as passed or failed

        TBool iPassCurrentIteration;

        // Array of sub test cases executed in loop

        RPointerArray<CSubTestCaseRunner> iInLoopSubTestCases;    

        // Array of remote events allocated inside loop

        RPointerArray<CSlave> iInLoopSlaves;

    };   

// TestScripter remote event wrapper

class TEventTS: public TEventIf

    {

    public:  // Constructors and destructor

        /**

        * C++ default constructor.

        */

        TEventTS();

        /**

        * C++ parametric constructor.

        */

        TEventTS( TName& aEventName );

        /**

        * C++ destructor.

        */

        ~TEventTS();

    public: // New functions

        /**

        * Set request status member.

        */

        void SetRequestStatus( TRequestStatus* aStatus );

        /**

        * Set event pending.

        */

        void SetEvent( TEventType aEventType );

        /**

        * Wait event.

        */

        void WaitEvent( TRequestStatus& aStatus );

    private: // New functions

        /**

        * Complete request status member.

        */

        void Complete( TInt aError );

    private:    // Data

        /**

        * Request status.

        */

        TRequestStatus* iClientReqStatus; 

    };

// Interface for classes which can handle errors which may occure during remote

// message receive

NONSHARABLE_CLASS( MReceiveErrorHandler )

    {

    public:

		/**

		 * Handle error which occured during remote message receive

		 */

        virtual void HandleRemoteReceiveError( 

                TInt aError, const TDesC& aErrorDescription ) = 0;        

    };

// Interface for classes which should be notified about remote allocate 

// and free requests results

NONSHARABLE_CLASS( MSlaveAllocateFreeMonitor )

    {

    public:

		/**

		 * Notify slave is allocated

		 */

        virtual void NotifySlaveAllocatedL( TUint16 aSlaveId ) = 0;

        /**

         * Notify slave is freed

         */

        virtual void NotifySlaveFreedL( TUint16 aSlaveId ) = 0;

    };

// Interface for classes which should be notified about results of remote test 

// control requests 

NONSHARABLE_CLASS( MRemoteTestCasesMonitor )

    {

    public:

		/**

		 * Notify test case has been started.

		 */

        virtual void NotifyTestCaseStartedL( TUint16 aSlaveId, TUint16 aSlaveTestId ) = 0;

        /**

         * Notify test case can't be started.

         */

        virtual void NotifyTestCaseRunErrorL( TUint16 aSlaveId, const TFullTestResult& aTestCaseResult ) = 0;

        /**

         * Notify execution test case has finished

         */

        virtual void NotifyTestCaseFinishedL( TUint16 aSlaveId, TUint16 aSlaveTestId, const TFullTestResult& aTestCaseResult ) = 0;

        /**

         * Notify test case has been paused.

         */

        virtual void NotifyTestCasePausedL( TUint16 aSlaveId, TUint16 aSlaveTestId ) = 0;

        /**

         * Notify test case has been resumed.

         */

        virtual void NotifyTestCaseResumedL( TUint16 aSlaveId, TUint16 aSlaveTestId ) = 0;

        /**

         * Notify test case has been cancelled.

         */

        virtual void NotifyTestCaseCancelledL( TUint16 aSlaveId, TUint16 aSlaveTestId ) = 0;

    };

// Interface for classes which should be notified about results of remote events

// control requests.

NONSHARABLE_CLASS( MRemoteEventsMonitor )

    {

    public:

		/**

		 * Notify remote event has been requested

		 */

        virtual void NotifyEventRequestedL( TUint16 aSlaveId, 

                const TDesC& aEventName, 

                CStifTFwIfProt::TEventStatus aEventStatus,

                TEventIf::TEventType aEventType,

                TInt aResult ) = 0;

        /**

         * Notify remote event state has changed

         */

        virtual void NotifyEventStateChangedL( TUint16 aSlaveId, 

                const TDesC& aEventName, 

                CStifTFwIfProt::TEventStatus aEventStatus,

                TEventIf::TEventType aEventType,

                TInt aResult ) = 0;

        /**

         * Notify remote event has been released

         */

        virtual void NotifyEventReleasedL( TUint16 aSlaveId, 

                const TDesC& aEventName, TInt aResult ) = 0;

        /**

         * Notify remote event has been sucessfully set

         */

        virtual void NotifyEventSetCompletedL( TUint16 aSlaveId, 

                const TDesC& aEventName, TInt aResult ) = 0;

        /**

         * Notify remote event has been sucessfully unset

         */

        virtual void NotifyEventUnsetCompletedL( TUint16 aSlaveId, 

                const TDesC& aEventName, TInt aResult ) = 0;        

    };

// Interface for classes which should be notified about results of sendreceive 

// and send unknown requests 

NONSHARABLE_CLASS( MRemoteSendReceiveMonitor )

    {

    public:

		/**

		 * Notify sendreceive request has been started

		 */

        virtual void NotifySendReceiveStartedL( TUint16 aSlaveId ) = 0;

        /**

         * Notify sendreceive request has finished

         */

        virtual void NotifySendReceiveResultL( 

                TUint16 aSlaveId, 

                CStifTFwIfProt::TRunStatus aRunStatus,

                TInt aRunResult ) = 0;

        /**

         * Notify send unknown request has finished

         */

        virtual void NotifySendUnknownL( TUint16 aSlaveId, TInt aResult ) = 0;        

    };

// This class creates, execute and recive respons for master-slave requests

NONSHARABLE_CLASS( CRemoteCallsProxy ): public CActive

    {

    public:

		/**

		 * Two phase constructor.

		 */

        static CRemoteCallsProxy* NewL( CTestModuleIf& aTestModuleIf, CStifLogger* aLogger );

    public:

        /**

         * Destructor.

         */

        ~CRemoteCallsProxy();

        /**

         * Sends slave allocate request.

         */

        void AllocateL( TUint32 aMasterId, const TDesC& aType );

        /**

         * Sends slave free request.

         */

        void FreeL( TUint32 aMasterId, TUint16 aSlaveId );

        /**

         * Sends sendreceive request.

         */

        void SendReceiveL(  TUint32 aMasterId, TUint16 aSlaveId, const TDesC& aMessage );

        /**

         * Sends unknown request

         */        

        void SendUnknownL(  TUint32 aMasterId, TUint16 aSlaveId,

                const TDesC& aCommand, const TDesC& aMessage );