/*

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

*

*/

// INCLUDE FILES

#include <StifTestEventInterface.h>

#include <StifLogger.h>

#include "TestScripter.h"

#include "TestKeywords.h"

#include "Logging.h"

#include "TestEngineClient.h"

#include "SettingServerClient.h"

#include <stifinternal/UiEnvProxy.h>

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

// None

// MACROS

#ifdef LOGGER

#undef LOGGER

#endif

#define LOGGER iLog

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

// ==================== LOCAL FUNCTIONS =======================================

/*

-------------------------------------------------------------------------------

     Class: -

     Method: CallBack

     Description: (Function pointer) Called from CScriptBase class. Generic

                  method for call back operations from Test Script Class to

                  TestScripter.

     Parameters: CTestScripter* aTestScripter: in: Pointer to TestScripter

                 TStifTSCallBackType aCallType: in: Call back type

                 const TDesC& aLine: in Script line

     Return Values: TInt: Symbian error code

     Errors/Exceptions: None

     Status: Draft

-------------------------------------------------------------------------------

*/

TInt CallBack( CTestScripter* aTestScripter,

                TStifTSCallBackType aCallType,

                const TDesC& aLine )

    {

    TInt ret( 0 );

    switch( aCallType )

        {

        case EStifTSCallClass:

            {

            ret = aTestScripter->CallTestClass( aLine );

            break;

            }

        case EStifTSGetObject:

            {

            ret = aTestScripter->GetTestScriptObject( aLine );

            break;

            }

        default:

            {

            ret = KErrArgument;

            break;

            }

        }

    return ret;

    }

/*

-------------------------------------------------------------------------------

    DESCRIPTION

    This module contains the implementation of CTestScripter class 

    member functions.

-------------------------------------------------------------------------------

*/

// ================= MEMBER FUNCTIONS =========================================

/*

-------------------------------------------------------------------------------

     Class: CTestScripter

     Method: CTestScripter

     Description: Default constructor

     C++ default constructor can NOT contain any code, that

     might leave.

     Parameters:    None

     Return Values: None

     Errors/Exceptions: None

     Status: Draft

-------------------------------------------------------------------------------

*/

CTestScripter::CTestScripter()

    {

    }

/*

-------------------------------------------------------------------------------

     Class: CTestScripter

     Method: ConstructL

     Description: Symbian OS second phase constructor

     Symbian OS default constructor can leave.

     Parameters:    None

     Return Values: None

     Errors/Exceptions: None.

     Status: Draft

-------------------------------------------------------------------------------

*/

void CTestScripter::ConstructL()

    {

    __TRACE( KPrint, ( _L("New TestScripter") ) );

    iStdLog = CStifLogger::NewL( KTestScripterLogDir,

                                KTestScripterLogFile );

    iLog = iStdLog;

    iOOMIgnoreFailure = EFalse; // OFF for default

    iCheckHeapBalance = EFalse; // No checking heap balance by default

    //Read logger settings to check whether test case name is to be

    //appended to log file name.

    RSettingServer settingServer;

    TInt ret = settingServer.Connect();

    if(ret != KErrNone)

        {

        User::Leave(ret);

        }

    // Struct to StifLogger settigs.

    TLoggerSettings loggerSettings; 

    // Parse StifLogger defaults from STIF initialization file.

    ret = settingServer.GetLoggerSettings(loggerSettings);

    if(ret != KErrNone)

        {

        User::Leave(ret);

        } 

    // Close Setting server session

    settingServer.Close();

    iAddTestCaseTitleToLogName = loggerSettings.iAddTestCaseTitle;

    // Initialize parser variables

    iCurrentParser = NULL;

    iCurrentParserReadFirstLine = EFalse;

    }

/*

-------------------------------------------------------------------------------

     Class: CTestScripter

     Method: NewL

     Description: Two-phased constructor.

     Parameters:    None

     Return Values: CTestScripter*: new object

     Errors/Exceptions: Leaves if new or ConstructL leaves.

     Status: Draft

-------------------------------------------------------------------------------

*/

CTestScripter* CTestScripter::NewL()

    {

    CTestScripter* self = new (ELeave) CTestScripter();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

/*

-------------------------------------------------------------------------------

     Class: CTestScripter

     Method: ~CTestScripter

     Description: Destructor

     Parameters:    None

     Return Values: None

     Errors/Exceptions: None

     Status: Draft

-------------------------------------------------------------------------------

*/

CTestScripter::~CTestScripter()

    {

    iTestObjects.ResetAndDestroy();

    iTestModules.ResetAndDestroy();

    iDefinedIni.ResetAndDestroy();

    iDefinedRuntime.ResetAndDestroy();

    iDefinedLocal.ResetAndDestroy();

    iParserStack.ResetAndDestroy();

    iTestObjects.Close();

    iTestModules.Close();

    iDefinedIni.Close();

    iDefinedRuntime.Close();

    iDefinedLocal.Close();

    iParserStack.Close();

    iCurrentParser = NULL;

    delete iSectionParser;

    delete iTestRunner;

    iLog = NULL;

    delete iStdLog;

    iStdLog = NULL;

    delete iTCLog;

    iTCLog = NULL;

    }

/*

-------------------------------------------------------------------------------

     Class: CTestScripter

     Method: InitL

     Description: InitL is used to initialize the Test Module.

     Parameters: const TFileName& aIniFile: in: Initialization file

                 TBool aFirstTime: in: First time flag 

     Return Values: Symbian OS error code

     Errors/Exceptions: Leaves if ReadInitializationL leaves

     Status: Draft

-------------------------------------------------------------------------------

*/        

TInt CTestScripter::InitL( TFileName& aIniFile, 

                           TBool /*aFirstTime*/ )

    {

    __TRACEFUNC();

    if( aIniFile.Length() > 0 )

        {

        // Read initialization from test case file

        ReadInitializationL( aIniFile, iDefinedIni );

        }

    return KErrNone;

    }

/*

-------------------------------------------------------------------------------

     Class: CTestScripter

     Method: GetTestCases

     Description: GetTestCases is used to inquired test cases

     Parameters:    const TFileName& aConfigFile: in: Test case file

                    RPointerArray<RTestEngine::TTestCaseInfo>& aTestCases: out: 

                          Array of TestCases 

     Return Values: KErrNone: Success

                    Symbian OS error code

     Errors/Exceptions: Leaves if CStifParser::SectionL leaves

                        Leaves if CStifParser::NextSectionL leaves

                        Leaves if memory allocation fails

     Status: Draft

-------------------------------------------------------------------------------

*/        

TInt CTestScripter::GetTestCasesL( const TFileName& aConfigFile, 

                                   RPointerArray<TTestCaseInfo>& aTestCases )

    {

    __TRACEFUNC();

    if( aConfigFile.Length() == 0 )

        {

        __TRACE( KError, (_L("No test case script file given") ) );

        __RDEBUG( (_L("No test case script file given") ) );

        return KErrNotFound;

        }

    CStifParser* parser = NULL; 

    // Open test case file

    TRAPD( err, 

        parser = CStifParser::NewL( _L(""), 

                                    aConfigFile, 

                                    CStifParser::ECStyleComments ) );

    if( err != KErrNone )

        {

        __TRACE( KError, (_L("Given test case script file [%S] not found"),

            &aConfigFile ) );

        __RDEBUG( (_L("Given test case script file [%S] not found"),

            &aConfigFile ) );

        return err;

        }

    CleanupStack::PushL( parser );

    CStifSectionParser* section;

    TPtrC tmp;

    TInt index = 0;

    TInt ret = KErrNone;

    // Find first section

    section = parser->SectionL( KTestStartTag, KTestEndTag );

    if( section == NULL )

        {

        ret = KErrNotFound;

        }

    else

        {    

        // Parse all sections

        while( section )

            {

            CleanupStack::PushL( section );

            // Get title line

            if( section->GetLine( TTestKeywords::Keyword( TTestKeywords::ETitle ),

                tmp, ENoTag ) != KErrNone )

                {

                __TRACE( KError, (_L("Title not given for test case")));

                User::Leave( KErrNotFound );

                }

            else

                {

                if( tmp.Length() > KMaxName )

                    {

                    tmp.Set( tmp.Left( KMaxName ) );

                    }   

                TTestCaseInfo* tc = new ( ELeave ) TTestCaseInfo();

                CleanupStack::PushL( tc );

                __TRACE( KVerbose, (_L("TestCase: %S"), &tmp));

                tc->iTitle.Copy( tmp );

                tc->iCaseNumber = ++index;

                 // Get timeout if defined

                CStifItemParser* item = section->GetItemLineL(  

                   TTestKeywords::Keyword( TTestKeywords::ETimeout ) );

                if( item )

                    {

                    TInt timeout; // In milliseconds

                    ret = item->GetInt( 

                        TTestKeywords::Keyword( TTestKeywords::ETimeout ), 

                        timeout ); 

                    if( ret != KErrNone )

                        {

                        __TRACE( KError, (_L("Illegal timeout")));

                        User::Leave( ret ); 

                        }

                    // Type cast timeout to TInt64    

                    tc->iTimeout = TInt64( timeout ) * 1000;

                    __TRACE( KMessage, (_L("Timeout: %i"), tc->iTimeout.Int64() ));

                    }

                 // Get priority if defined

                item = section->GetItemLineL(  

                   TTestKeywords::Keyword( TTestKeywords::EPriority ) );

                if( item )

                    {

                    // First try to interpret as integer

                    ret = item->GetInt( 

                        TTestKeywords::Keyword( TTestKeywords::EPriority ), 

                        tc->iPriority ); 

                    if( ret != KErrNone )

                        {

                        TPtrC priority;

                        // If priority was not given as integer, it must be 

                        // one of the predefined values

                        ret = item->GetString( 

                            TTestKeywords::Keyword( TTestKeywords::EPriority ),

                            priority );

                        if( ret != KErrNone )

                            {

                            __TRACE( KError, (_L("Illegal priority")));

                            User::Leave( ret ); 

                            }

                        switch( TTestKeywords::Parse( priority, 

                                                       TTestKeywords::Priority ) )

                            {

                            case TTestKeywords::EPriHigh:

                                tc->iPriority = TTestCaseInfo::EPriorityHigh;

                                break;

                            case TTestKeywords::EPriNormal:

                                tc->iPriority = TTestCaseInfo::EPriorityNormal;

                                break;

                            case TTestKeywords::EPriLow:

                                tc->iPriority = TTestCaseInfo::EPriorityLow;

                                break;

                            default:

                                __TRACE( KError, (_L("Illegal priority")));

                                User::Leave( KErrArgument ); 

                            }

                        }

                    __TRACE( KMessage, (_L("Priority: %i"), tc->iPriority ));

                    }

                aTestCases.Append(tc);

                CleanupStack::Pop( tc );

                }

            CleanupStack::PopAndDestroy( section );

            section = parser->NextSectionL( KTestStartTag, KTestEndTag );

            }

        }

    CleanupStack::PopAndDestroy( parser );

    __TRACE( KPrint, (  _L( "Configfile '%S', testcases %d" ),

        &aConfigFile, index ));     

    return ret;

    }

/*

-------------------------------------------------------------------------------

     Class: CTestScripter

     Method: GetConstantValue

     Description: Internal fuction to get const value defined in 

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

     GetConstantValue gets const value defined in [Define]...[Enddefine] 

     section of script file

     Parameters:    const TDesC& aName: in: constant name 

                    TDes& avalue: out: constant value

     Return Values: KErrNone: Value is returned succesfully.

                    KErrNotFound: Constant was not found

                    Any other SymbianOS error

-------------------------------------------------------------------------------

*/

EXPORT_C TInt CTestScripter::GetConstantValue( const TDesC& aName, TDes& aValue )

	{

	__TRACEFUNC();

    TInt count = iDefinedLocal.Count();

    for(TInt i = 0; i < count; i++)

        {

        if(iDefinedLocal[i]->Name() == aName)

            {

            aValue.Copy(iDefinedLocal[i]->Value());

            return KErrNone;

            }

        }	

	  count = iDefinedIni.Count();

    for( TInt i = 0; i < count; i++ )

        {

        if( iDefinedIni[i]->Name() == aName )