/*

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

#define TestScripter_H

//  INCLUDES

#include <e32std.h>

#include <StifParser.h>

#include <StifLogger.h>

#include <StifTestModule.h>

#include "TestScripterInternal.h"

#include "TestKeywords.h"

#include "StifKernelTestClass.h"

#include "StifTestInterference.h"

#include "STIFMeasurement.h"

#include "StfTestLibPluginInterface.h"

#include "StifTestModule.h"

#include "TestScripterUtils.h"

#include "SubTestCaseRunner.h"

// CONSTANTS

// Printing priorities

const TInt KPrintPriLow = 10;

const TInt KPrintPriNorm = 30;

const TInt KPrintPriHigh = 50;

// Log dir and file

_LIT( KTestScripterLogDir, "\\Logs\\TestFramework\\TestScripter\\" );

_LIT( KTestScripterLogFile, "TestScripter.txt" );

_LIT( KTestScripterLogFileWithTitle, "TestScripter_[%S].txt");

// Configuration file tags

_LIT( KTestStartTag, "[Test]" );

_LIT( KTestEndTag, "[Endtest]" );

// Define tags

_LIT( KDefineStartTag, "[Define]" );

_LIT( KDefineEndTag, "[Enddefine]" );

// Data tags

_LIT( KDataStartTag, "[Data]" );

_LIT( KDataEndTag, "[Enddata]" );

// Loop counter macro

_LIT( KLoopCounter, "LOOP_COUNTER" );

// ini flag

_LIT(KFileFlag,"$");

_LIT(KSectionFlag,"@");

_LIT(KKeyFlag,"#");

// Remote protocol timeout 

const TInt KRemoteProtocolTimeout = 30000000;

// Remote protocol Master id

const TUint32 KRemoteProtocolMasterId = 0xdeadbeef;

// MACROS

// None

// DATA TYPES

class CTestRunner;

typedef CScriptBase* (*CInterfaceFactory)(CTestModuleIf& aTestModuleIf);

// FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

class CTestRunner;

class CTestContinue;

class TTestModule;

class TTestObjectBase;

class TTestObject;

class TTestInterference;

class CStifTestMeasurement;

class TTestMeasurement;

class TSharedTestModule;

// CLASS DECLARATION

// DESCRIPTION

// Predefined value entry

class CDefinedValue : public CBase

    {

public:

    // Constructors and destructor

    /**

     * Two-phased constructor.

     */

    static CDefinedValue* NewL(TDesC& aName, TDesC& aValue);

    /**

     * Destructor.

     */

    virtual ~CDefinedValue();

public:

    // New functions

    /**

     * Returns define name.

     */

    TDesC& Name();

    /**

     * Returns define value.

     */

    TDesC& Value();

    /**

     * Returns new define value.

     */

    void SetValueL(TDesC& aValue);

private:

    /**

     * C++ default constructor.

     */

    CDefinedValue();

    /**

     * By default Symbian OS constructor is private.

     */

    void ConstructL(TDesC& aName, TDesC& aValue);

private:

    // Data

    // Define name

    HBufC* iNameBuf;

    TPtrC iName;

    // Define value

    HBufC* iValueBuf;

    TPtrC iValue;

    };

// CLASS DECLARATION

// DESCRIPTION

// CTestScripter contains the Test Module interface of TestScripter 

// for STIF Test Framework

class CTestScripter : public CTestModuleBase

    {

public:

    // Enumerations

private:

    // Enumerations

public:

    // Constructors and destructor

    /**

     * Two-phased constructor.

     */

    static CTestScripter* NewL();

    /**

     * Destructor.

     */

    ~CTestScripter();

public:

    // New functions

    /**

     * Call specified tst class object.

     */

    TInt CallTestClass(const TDesC& aLine);

    /**

     * Get pointer to test class object.

     */

    TInt GetTestScriptObject(const TDesC& aObjectName);

    /**

     * Return runner handle.

     */

    CTestRunner& TestRunner()

        {

        return *iTestRunner;

        }

    ;

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

    /**

     * Internal fuction to get const value defined in 

     * [Define]...[Enddefine] section of script file

     */

    IMPORT_C TInt GetConstantValue(const TDesC& aName, TDes& aValue);

    /**

     * Set result description of test case.

     */

    IMPORT_C void SetResultDescription(const TDesC& aDescr);

    /**

     * Internal fuction to set local value.

     */

    IMPORT_C TInt SetLocalValue(const TDesC& aName, const TDesC& aValue);

    /**

     * Internal fuction to get local value.

     */

    IMPORT_C TInt GetLocalValue(const TDesC& aName, TDes& aValue);

protected:

    // New functions

protected:

    // Functions from base classes

private:

    /**

     * C++ default constructor.

     */

    CTestScripter();

    /**

     * By default Symbian OS constructor is private.

     */

    void ConstructL();

    /**

     * GetTestCaseL gets the specified test case section 

     * from the onfigfile.

     */

    CStifSectionParser* GetTestCaseL(TInt aCaseNumber,

            const TFileName& aConfig);

    /**

     * RunTestL runs the testcase specified in section.

     */

    void RunTestL();

    /**

     * LoadTestModuleL loads test module.

     */

    TTestModule* LoadTestModuleL(TDesC& aModule);

    /**

     * LoadTestModuleL loads test module.

     */

    TTestModule* LoadSharedTestModuleL(TDesC& aModule);

    /**

     * CreateObjectL create new object.

     */

    void CreateObjectL(TDesC& aModule, TDesC& aObjectId);

    /**

     * CreateShareObjectL create new object.

     */

    void CreateShareObjectL(TDesC& aModule, TDesC& aObjectId);

    /**

     * RestoreShareObjectL create new object.

     */

    void RestoreShareObjectL(TDesC& aObjectId);

    /**

     * CreateKernelObjectL create new kernel object.

     */

    void CreateKernelObjectL(TDesC& aDriver, TDesC& aObjectId);

    /**

     * DeleteObjectL deletes object with aObjectId.

     */

    TInt DeleteObjectL(TDesC& aObjectId);

    /**

     * DeleteGlobalObjectL deletes object with aObjectId.

     */

    TInt CTestScripter::DeleteScripterObjectL(TDesC& aObjectId);

    /**

     * GetObject returns object corresponding to aObjectId.

     */

    TTestObjectBase* GetObject(const TDesC& aObjectId);

    /**

     * Read initialization from file.

     */

    void ReadInitializationL(const TDesC& aIniFile, RPointerArray<

            CDefinedValue>& aDefines);

    /**

     * Read sub section from test case file.

     */

    CStifSectionParser* GetSubL(const TDesC& aSubName);

    /**

     * Updates result of test case.

     */

    void UpdateTestCaseResult(const TInt aError, const TDesC& aDescr);

    void Substitute(const TDesC& aSrc, TDes& aDest);

    /**

     * Add Test object 

     */

    void AddTestObjToScripterDictL(TTestObject* aObject);

    /**

     * Delete Test object

     */

    void DelTestObjFromScripterDict(const TDesC& aObjectId);

    /**

     * Get Test object

     */

    TTestObject* GetTestObjFromScripterDict(const TDesC& aObjectId) const;

    /**

    * Append to TS's result description (if possible due to length)

    * limitation provided text in [] brackets.

    */

    void AppendTestResultToResultDes(TDes& aResultDescr, const TDesC& aTestCaseResultDescr);

    /**

     * Trace memory usage of global objects and output to log. method return the used cells.

    */

    TInt TraceGlobalObjectsMemoryUsage();

public:

    // Data

    // Logger 

    CStifLogger* iLog;

protected:

    // Data

private:

    // Data

    // Test case array of running/runned test cases 

    RPointerArray<TTestObjectBase> iTestObjects;

    // Array of test modules

    RPointerArray<TTestModule> iTestModules;

    // Array of test modules

    RPointerArray<TSharedTestModule> iSharedTestModules;

    // Test case array of global test objects 

    RPointerArray<TTestObject> iGlobalObjects;

    // Test case result of the TestScripter

    TTestResult iResult;

    // Sectionparser for the current testcase

    CStifSectionParser* iSectionParser;

    // Currently used section parser (changed when executing a function (sub))

    CStifSectionParser* iCurrentParser;

    // It says if we need to call GetLine or GetNextLine for the parser

    TBool iCurrentParserReadFirstLine;

    // Stack of parsers for called functions (subs)

    RPointerArray<CStifSectionParser> iParserStack;

    // Pointer to used testrunner

    CTestRunner* iTestRunner;

    // Predefined values are listed here

    RPointerArray<CDefinedValue> iDefinedIni;

    RPointerArray<CDefinedValue> iDefinedRuntime;

    RPointerArray<CDefinedValue> iDefinedLocal;

    // Flag for OOM testing. If true test class's build

    // block execution result will ignored.

    TBool iOOMIgnoreFailure;

    // Flag which says if heap balance should be checked (affects only 

    // EKA2 environment). May be set in StifSettings section.

    TBool iCheckHeapBalance;

    // 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;

    // The running test case's config file name

    TFileName iConfig;

    TBuf<KMaxFileName> iCurrentFile;

    TBuf<KMaxFileName> iCurrentFileAlias;

    TBuf<KMaxFileName> iCurrentSection;

    TBuf<KMaxFileName> iCurrentSectionFileAlias;

    TBuf<KMaxFileName> iCurrentKey;

    TBuf<KMaxFileName> iCurrentvalues;

    RArray<TBuf<KMaxFileName> > iKeys;

    RArray<TBuf<KMaxFileName> > iValues;

    RPointerArray<TScriptObject> *iObjects;

    // Indicates if pass limit in loops was met

    TBool iPassLimitNotMet;    

public:

    // Friend classes

protected:

    // Friend classes

private:

    // Friend classes

    friend class CTestRunner;

    friend class CTestContinue;

    };

// CLASS DECLARATION

// DESCRIPTION

// CTestRunner parses the TestScripter configuration file and 

// runs a testcase. CTestRunner is the friend of CTestScripter

// and uses its private member variables directly.

class CTestRunner : public CActive

    {

public:

    // Enumerations

private:

    // Enumerations

    enum TRunnerState

        {

        ERunnerIdle,

        ERunnerRunning,

        ERunnerCancel,

        ERunnerError,

        ERunnerPaused,

        };

    enum TInternalStateForSubTestCases

        {

        EISNotStarted,

        EISRuning,

        EISWaitingForComplete,

        EISEndLoopWaitingForSubTestCases,

        EISFinishedWaitingForSubTestCases,

        EISFinished,

        };

public:

    // Constructors and destructor  

    /**

     * Two-phased constructor.

     */

    static CTestRunner* NewL(CTestScripter* aTestScripter);

    /**

     * Destructor.

     */

    ~CTestRunner();

public:

    // New functions

    /**

     * Calls SetActive() from CActive.

     */

    void SetRunnerActive();

    /**

     * Get test case result handle.

     */

    RArray<TInt>& TestCaseResults()

        {

        return iTestCaseResults;

        }

    ;

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