/*

* 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 );