/*
* 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 
* TestCombiner module of STIF Test Framework.
*
*/

#ifndef TESTCOMBINER_H
#define TESTCOMBINER_H

//  INCLUDES
#include <e32std.h>

#include <StifParser.h>
#include <StifLogger.h>
#include <StifTestEventInterface.h>
#include <StifTestModule.h>
#include <stifinternal/TestServerClient.h>
#include "TestKeywords.h"
#include "TestCombinerEvent.h" 
#include "TestCombinerUtils.h" 
#include "STIFMeasurement.h"

// CONSTANTS
// Printing priorities
const TInt KPrintPriExec = 400;
const TInt KPrintPriLow  = 300;
const TInt KPrintPriNorm = 200;
const TInt KPrintPriHigh = 100;
// Log dir and file
_LIT( KTestCombinerLogDir, "\\Logs\\TestFramework\\TestCombiner\\" );
_LIT( KTestCombinerLogFile, "TestCombiner.txt" );
_LIT( KTestCombinerLogFileWithTitle, "TestCombiner_[%S].txt" );
// Configuration file tags
_LIT( KTestStartTag, "[Test]" );
_LIT( KTestEndTag, "[Endtest]" );
// Define tags
_LIT( KDefineStartTag, "[Define]" );
_LIT( KDefineEndTag, "[Enddefine]" );
// Initialization tags
_LIT( KInitStartTag, "[Init]" );
_LIT( KInitEndTag, "[Endinit]" );
_LIT( KInitRcpTimeout, "rcptimeout" );

// Remote protocol timeout 
const TInt KRemoteProtocolTimeout = 30000000;
// Remote protocol Master id
const TUint32 KRemoteProtocolMasterId = 0xdeadbeef;

// Loop counter macro
_LIT( KLoopCounter, "LOOP_COUNTER" );

// MACROS
// None

// DATA TYPES
// None

// FUNCTION PROTOTYPES
// None

// FORWARD DECLARATIONS
class CTestRunner;
class CTestCase;
class CTCTestCase;
class CRemoteTestCase;
class CTCTestModule;
class CRemoteTimer;
class CRemoteReceiver;
class CRemoteSendReceive;
class TTestMeasurement;
    
// CLASS DECLARATION

// DESCRIPTION
// CTestCombiner contains the Test Module interface of TestCombiner 
// for STIF Test Framework

NONSHARABLE_CLASS(CTestCombiner) 
    :public CTestModuleBase
    {
    public: // Enumerations

    private: // Enumerations

    public: // Constructors and destructor
        /**
        * Two-phased constructor.
        */
        static CTestCombiner* NewL();

        /**
        * Destructor.
        */
        ~CTestCombiner();

    public: // New functions
        /**
        * Test Case completion from CTCTestCase.
        */
        void Complete( CTestCase* aTestCase, TInt aError=KErrNone );

        /**
        * Set event request pending.
        */
         void SetEventPendingL( TEventIf aEvent );

        /**
        * Handles timeouts.
        */
        void RemoteTimeout();

        /**
        * Handles responce received from slave
        */
        void ReceiveResponse( TDesC& aMsg );

    public: // Functions from base classes
        /**
        * Test module initialization.
        */ 
        TInt InitL( TFileName& aIniFile, TBool aFirstTime );

        /**
        * GetTestCasesL is used to inquire testcases. 
        */
        TInt GetTestCasesL( const TFileName& aConfigFile, 
                            RPointerArray<TTestCaseInfo>& aTestCases );
        /**
        * RunTestCase is used to run an individual test case specified 
        * by aTestCase. 
        */
        TInt RunTestCaseL( const TInt aCaseNumber, 
                           const TFileName& aConfig, 
                           TTestResult& aResult );

    protected: // New functions

    protected: // Functions from base classes

    private:
        /**
        * C++ default constructor.
        */
        CTestCombiner();

        /**
        * By default Symbian OS constructor is private.
        */
        void ConstructL();

        /**
        * GetTestCaseL gets the specified test case section 
        * from the configfile.
        */
        CStifSectionParser* GetTestCaseL( TInt aCaseNumber, 
                                            const TFileName& aConfig );

        /**
        * RunTestL runs the testcase specified in section.
        */
        void RunTestL();
      
        /**
        * StartTestL starts a specified testcase from another test module.
        */
        TInt StartTestL( CStartInfo& aStartInfo );

        /**
        * GetTestModuleL returns a specified test module description.
        */
        CTCTestModule* GetTestModuleL( TDesC& aModule,
                                       TDesC& aIniFile,
                                       const TDesC& aConfigFile  );

        /**
        * Gets a testcase identified with testid from test case array.
        */
        CTestCase* GetTest( TDesC& aTestId );
     
        /**
        * Gets a running testcase identified with testid from test case array.
        */
        CTestCase* GetRunningTest( TDesC& aTestId );
        
        /**
        * Gets a testcase identified with testid from test case array.
        */
        CTCTestCase* GetLocalTest( TDesC& aTestId );
     
        /**
        * Gets a running testcase identified with testid from test case array.
        */
        CTCTestCase* GetLocalRunningTest( TDesC& aTestId );

        /**
        * Gets a testcase identified with aSlaveId from slave array.
        */
        CRemoteTestCase* GetRemoteTest( TDesC& aTestId );

        /**
        * Gets a testcase identified with aSlaveId from slave array.
        */
        CRemoteTestCase* GetRemoteTest( TUint32 aSlaveId );
        
        CRemoteTestCase* GetRemoteTestRunSent( TUint32 aSlaveId );
        /**
        * Gets a running testcase identified with aSlaveId from slave array.
        */
        CRemoteTestCase* GetRunningRemoteTest( TUint32 aSlaveId );

        /**
        * Gets a testcase running on slave with aSlaveDevId.
        */
        CRemoteTestCase* GetRemoteRunningTestOnSlave( TUint32 aSlaveDevId );

        /**
        * Gets a correct CRemoteSendReceive object on slave with aSlaveId.
        */
        CRemoteSendReceive* GetRemoteSendReceive( TUint32 aSlaveId );        

        /**
        * Get running slave.
        */
        CSlaveInfo* CTestCombiner::GetSlave( TUint32 aSlaveId );
        CSlaveInfo* CTestCombiner::GetSlave( TDesC& aSlaveName );

        /**
        * Check requested events and send unset to first requested.
        */
        TBool UnsetEvent( TEventIf& aEvent, TRequestStatus& aStatus );

        /**
        * Read initialization from file.
        */
        void ReadInitializationL( const TDesC& aIniFile );

        /**
        * Executes measurement script line.
        */
        void ExecuteMeasurementL( CStifItemParser* aItem );

        /**
        * Starts measurement.
        */
        void StartMeasurementL( const TDesC& aType, CStifItemParser* aItem );

        /**
        * Stops measurementplugin's measurement.
        */
        void StopMeasurementL( const TDesC& aType );
        
        /**
        * 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);
       
        /**
        * Append to TC's result description (if possible due to length)
        * limitation provided text in [] brackets.
        */
        void AppendTestResultToResultDes(TDes& aResultDescr, const TDesC& aTestCaseResultDescr);


    public:     // Data
        // Logger 
        CStifLogger*                    iLog;

    protected:  // Data
          
    private:    // Data
        // Test case array of running/runned test cases 
        RPointerArray<CTestCase>        iTestCases;

        // SendReceive array(asynchronous sendreveive)
        RPointerArray<CRemoteSendReceive> iSendReceive;

        // Array of test modules
        RPointerArray<CTCTestModule>    iTestModules;

        // TestId of the waited (by complete keyword) test case 
        TName                           iWaitTestCase;

        // Flag to indicate that activescheduler is started    
        TBool                           iSchedulerActive;

        // Number of currently running test cases
        TInt                            iRunningTests;

        // Test case result of the TestCombiner
        TInt                            iResult;

        // Error code in case when execution of script fails
        TInt                            iScriptFailed;
        
        // Error description in case when execution of script fails
        TName                           iScriptFailedDescription;
        
        // Sectionparser for the current testcase
        CStifSectionParser*             iSectionParser;

        // Pointer to used testrunner
        CTestRunner*                    iTestRunner;

        // Pointer to used testrunner
        CRemoteReceiver*                iRemoteReceiver;

        // Event for async NotifyEvent
        TEventIf                        iEvent;
        TEventIfPckg                    iEventPckg;

        RPointerArray<TEventTc>         iEventArray;

         // Predefined values are listed here
        RPointerArray<CDefinedValue>    iDefined;

        // CSlaveInfo 
        RPointerArray<CSlaveInfo>       iSlaveArray;

        // Remote protocol timeout
        TInt                            iRemoteTimeout;

        // Variable for abortimmediately keyword @js
        TBool                           iCancelIfError;

        // Number of the failed test case, needed when using 
        // abortimmediately keyword @js
        TInt                            iFailedTestCase;

        // CStifTestMeasurement object
        RPointerArray<TTestMeasurement> iTestMeasurementArray;

        // Indicate that loop is used in test case file.
        // This is used for reseting and allowing allocated id's etc.
        // (E.g. testid values can be same in loop).
        TBool                           iLoopIsUsed;
        RArray<TAny*>                   iLoopAllocationArray;

        // Standard Logger 
        CStifLogger*                    iStdLog;

        // Test case Logger 
        CStifLogger*                    iTCLog;

        // Flag which says if test case title should be appended to the
        // log file name. This is read from SettingServer
        TBool                               iAddTestCaseTitleToLogName;
        
        // Counter for created TCModuleControllers
        TInt                            iIndexTestModuleControllers;

        // Is this UI testing?
        // If yes, then Test Engine works in a specific way.
        // It creates new process for every test scripter's test case
        // and deletes it after test case has finished.
        TBool                           iUITestingSupport;
        
        // Should every test case be executed in separate process?
        // This option is similar to iUITestingSupport, however
        // it does not delete the process after test case is finished.
        TBool                           iSeparateProcesses;

    public:     // Friend classes

    protected:  // Friend classes

    private:    // Friend classes
        friend class CTestRunner;
        friend class CTestEventNotifier;

    };

// CLASS DECLARATION

// DESCRIPTION
// CTestRunner parses the TestCombiner configuration file and 
// runs a testcase. CTestRunner is the friend of CTestCombiner
// and uses its private member variables directly.

NONSHARABLE_CLASS(CTestRunner) 
    :public CActive
    {
    public: // Enumerations

    private: // Enumerations
        enum TRunnerState{
            ERunnerIdle,
            ERunnerRunning,
            ERunnerWaitTestCase,
            ERunnerWaitEvent,
            ERunnerWaitUnset,
            ERunnerWaitTimeout,
            ERunnerCancel,
            ERunnerError,
            ERunnerAllocate,
            ERunnerFree,
            ERunnerRemote,
            ERunnerReady,
            };

    public:  // Constructors and destructor  
        /**
        * Two-phased constructor.
        */
        static CTestRunner* NewL( CTestCombiner* aTestCombiner );

        /**
        * Destructor.
        */
        ~CTestRunner();

    public: // New functions
        /**
        * Calls SetActive() from CActive.
        */
        void SetRunnerActive();

        /**
        * Handles received response from slave.
        */
        TBool ReceiveResponseL( TDesC& aMsg );

        /**
        * Cancel testcases.
        */
        void CancelTestCases();

    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

    protected:  // Functions from base classes

    private:
        /**
        * C++ default constructor.
        */
        CTestRunner( CTestCombiner* aTestCombiner );

        /**
        * By default Symbian OS constructor is private.
        */
        void ConstructL();

        /**
        * Executes one script line.
        */
        TBool ExecuteLineL( CStifItemParser* aItem );

        /**
        * Executes run script line.
        */
        TBool ExecuteRunL( CStifItemParser* aItem );

        /**
        * Parses run parameters.
        */
        void ParseRunParamsL( CStifItemParser* aItem, CStartInfo& aStartInfo );

        /**
        * Executes test control script line.
        */
        TBool ExecuteTestCtlL( CStifItemParser* aItem, 
                               TTCKeywords::TKeywords aKeyword );
                               
        /**
        * Executes pause in combiner
        */
        TBool ExecuteCombinerPauseL( CStifItemParser* aItem );

        /**
        * Executes pause script line.
        */
        TBool ExecutePauseL( CStifItemParser* aItem, CTestCase* aTestCase );

        /**
        * Executes complete script line.
        */
        TBool ExecuteCompleteL( CStifItemParser* aItem, CTestCase* aTestCase );

        /**
        * Executes event set script line.
        */
        TBool ExecuteEventSetL( CStifItemParser* aItem );

        /**
        * Executes event unset script line.
        */
        TBool ExecuteEventUnsetL( CStifItemParser* aItem );

        /**
        * Executes event control command.
        */
        TBool ExecuteEventCtlL( CStifItemParser* aItem, 
                                TTCKeywords::TKeywords aKeyword );

        /**
        * Executes allocate script line.
        */
        TBool ExecuteAllocateL( CStifItemParser* aItem );

        /**
        * Executes free script line.
        */
        TBool ExecuteFreeL( CStifItemParser* aItem );

        /**
        * Frees slave.
        */
        void ExecuteFreeL( CSlaveInfo* aSlave );

        /**
        * Executes remote script line.
        */
        TBool ExecuteRemoteL( CStifItemParser* aItem );

        /**
        * Executes remote run script line.
        */
        TBool ExecuteRemoteRunL( CStifItemParser* aItem, CSlaveInfo* aSlave,
                                 HBufC *aSetUnsetEvent = NULL,
                                 TInt aCaseNumber = 0 );

        /**
        * Executes remote test control script line.
        */
        TBool ExecuteRemoteTestCtlL( CStifItemParser* aItem, 
                                     CTestCase* aTestCase, 
                                     TInt aCmd  );

        /**
        * Executes remote event control script line.
        */
        TBool ExecuteRemoteEventCtlL( CStifItemParser* aItem, 
                                      CSlaveInfo* aSlave, 
                                      TInt aCmd  );
                                      
        /**
        * Executes remote event set unset line
        */
        TBool ExecuteRemoteSetUnsetEventL( CStifItemParser* aItem,
                                      CSlaveInfo* aSlave,
                                      TInt aCmd  );

        /**
        * Executes asynchronous remote sendreceive control script line.
        */
        TBool ExecuteRemoteSendReceiveL( CStifItemParser* aItem, 
                                      CSlaveInfo* aSlave );

        /**
        * Executes remote unknown control script line.
        */
        TBool ExecuteRemoteUnknownL( CStifItemParser* aItem, 
                                     CSlaveInfo* aSlave,
                                     TDesC& aCommand );
        /**
        * Handles received run responses from slave.
        */
        TBool ReceiveResponseRunL( CStifTFwIfProt& aMsg );

        /**
        * Handles received test control responses from slave.
        */
        TBool ReceiveResponseTestCtlL( CStifTFwIfProt& aMsg );

        /**
        * Handles received Event system control responses from slave.
        */
        TBool ReceiveResponseEventCtlL( CStifTFwIfProt& aMsg );

        /**
        * Handles received asynchronous sendreceive responses from slave.
        */
        TBool ReceiveResponseSendReceiveL( CStifTFwIfProt& aMsg );

        /**
        * Handles received responses for unspecified commands from slave.
        */
        TBool ReceiveResponseUnknownL( CStifTFwIfProt& aMsg );

        /**
        * Check unset event we are waiting.
        */
        TBool CheckUnsetEvent();

        /**
        * Parses optional argument.
        */
        void ParseOptArgL( const TDesC& aOptArg, TPtrC& aArg, TPtrC& aVal);

        /**
        * Preprocess hardcoded values in test case.
        */                    
        CStifItemParser* PreprocessLineL( TDesC& line );

        /**
        * Checks if aWord is defined value.
        */                    
        TInt CheckDefined( TPtrC& aWord );

        /**
        * Handle the loop keyword operations.
        */                    
        void ExecuteLoopL( CStifItemParser* aItem );

        /**
        * Handle the endloop keyword operations.
        */                    
        TBool ExecuteEndLoopL();

    public:     //Data

    protected:  // Data

    private:    // Data
        // Runner state
        TRunnerState                iState;

        // Backpointer to CTestCombiner
        CTestCombiner*              iTestCombiner;

        // Event system control
        TEventIf                    iEvent;

        // Pause timer
        RTimer                      iPauseTimer;
        TName                       iPausedTestCase;
        TInt                        iPauseTime;

        // Temporary line buffer 
        HBufC*                      iLine;

        // Remote control protocol timer
        CRemoteTimer*               iRemoteTimer;

        // Loop times, counter and start position
        TInt                    iLoopTimes;
        TInt                    iLoopCounter;
        TInt                    iLoopStartPos;
        TBuf<10>                iLoopCounterDes;
        TInt                    iEndLoopStartPos;

        // Loop passlimit (endurance) feature
        TInt                    iPasslimit;
        TBool                   iPasslimitEnabled;
        TInt                    iPassedIterationCnt;
        
        // Loop (timed loop option)
        TBool                   iTimedLoop;
        TTime                   iStartTime;
        TTimeIntervalMicroSeconds iExpectedLoopTime;

		// Message displayed when leave occurs during script parsing
		TBuf<256> iRunErrorMessage;
    public:      // Friend classes

    protected:  // Friend classes

    private:     // Friend classes
        friend class CTestCombiner;

    };

// CLASS DECLARATION
typedef TBuf<0x200> TRemoteProtMsg;

// DESCRIPTION
// CTestRemoteReceiver handles remote protocol receiving
NONSHARABLE_CLASS(CRemoteReceiver) 
    :public CActive
    {
    public: // Enumerations
         
    private: // Enumerations
        enum TReceiverState
            {
            EReceiverIdle,
            EReceiverPending,
            };

    public:  // Constructors and destructor  
        /**
        * Two-phased constructor.
        */
        static CRemoteReceiver* NewL( CTestCombiner* aTestCombiner );

        /**
        * Destructor.
        */
        ~CRemoteReceiver();

    public: // New functions
        /**
        * Calls SetActive() from CActive.
        */
        void Start();

    public: // Functions from base classes     
        /**
        * RunL derived from CActive handles the completed requests.
        */
        void RunL();

        /**
        * DoCancel derived from CActive handles the Cancel.
        */
        void DoCancel();

    protected:  // New functions

    protected:  // Functions from base classes

    private:
        /**
        * C++ default constructor.
        */
        CRemoteReceiver( CTestCombiner* aTestCombiner );

        /**
        * By default Symbian OS constructor is private.
        */
        void ConstructL();

    public:     //Data

    protected:  // Data

    private:    // Data
        // Runner state
        TReceiverState              iState;

        // Backpointer to CTestCombiner
        CTestCombiner*              iTestCombiner;

        // Remote protocol message
        TRemoteProtMsg              iRemoteMsg;

    public:     // Friend classes

    protected:  // Friend classes

    private:    // Friend classes

    };

// CLASS DECLARATION

// DESCRIPTION
// CRemoteTimer handles remote protocol timeouts
NONSHARABLE_CLASS(CRemoteTimer) 
    :public CActive
    {
    public: // Enumerations
         
    private: // Enumerations
        enum TTimerState
            {
            ETimerIdle,
            ETimerPending,
            };

    public:  // Constructors and destructor  
        /**
        * Two-phased constructor.
        */
        static CRemoteTimer* NewL( CTestCombiner* aTestCombiner );

        /**
        * Destructor.
        */
        ~CRemoteTimer();

    public: // New functions
        /**
        * Starts timer.
        */
        void SetTimerActive( TTimeIntervalMicroSeconds32 anInterval );

    public: // Functions from base classes     
        /**
        * RunL derived from CActive handles the completed requests.
        */
        void RunL();

        /**
        * DoCancel derived from CActive handles the Cancel.
        */
        void DoCancel();

    protected:  // New functions
          
    protected:  // Functions from base classes

    private:
        /**
        * C++ default constructor.
        */
        CRemoteTimer( CTestCombiner* aTestCombiner );

        /**
        * By default Symbian OS constructor is private.
        */
        void ConstructL();

    public:     //Data
     
    protected:  // Data

    private:    // Data
        // Runner state
        TTimerState     iState;

        // Backpointer to CTestCombiner
        CTestCombiner*  iTestCombiner;

        // Pause timer
        RTimer          iTimer;

    public:      // Friend classes

    protected:  // Friend classes

    private:     // Friend classes

    };


// DESCRIPTION
// TTestMeasurement contains test measurement module information
class TTestMeasurement
    {
    public: 
        TTestMeasurement(){ iMeasurement = NULL; };
        ~TTestMeasurement(){ delete iMeasurement; };

    public:

    public:
        // "object" name given in test case file.
        TName                   iName;
        // MSTIFTestInterference object.
        CSTIFTestMeasurement*  iMeasurement;

    private:

    };

#endif        // TESTCOMBINER_H

// End of File
