/*

* 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 module contains the implementation of 

* CTestCombiner class member functions.

*

*/

// INCLUDE FILES

#include <StifTestEventInterface.h>

#include <StifLogger.h>

#include "TestCombiner.h"

#include "TestKeywords.h"

#include "TestCase.h"

#include "TestCombinerEvent.h"

#include "Logging.h"

//--PYTHON-- begin

#include "StifPython.h"

#include "StifPythonFunComb.h"

//--PYTHON-- end

#include "SettingServerClient.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

_LIT( KTestRunner, "CTestRunner" );

_LIT( KRemoteTimer, "CRemoteTimer" );

_LIT( KRemoteReceiver, "CRemoteReceiver" );

// MACROS

#ifdef LOGGER

#undef LOGGER

#endif

#define LOGGER iLog

// LOCAL CONSTANTS AND MACROS

_LIT(KTitle, "title");

_LIT(KTimeout, "timeout");

_LIT(KPriority, "priority");

//printing macros

 _LIT( KExecute, "Execute");

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

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

// None

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

/*

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

     Class: CTestCombiner

     Method: CTestCombiner

     Description: Default constructor

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

     might leave.

     Parameters:    None

     Return Values: None

     Errors/Exceptions: None

     Status: Approved

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

*/

CTestCombiner::CTestCombiner(): 

    iSchedulerActive( EFalse ),

    iRunningTests( 0 ), 

    iResult( KErrNone ),

    iEventPckg( iEvent ),

    iRemoteTimeout( KRemoteProtocolTimeout ),

    iCancelIfError( EFalse ),

    iFailedTestCase( 0 ),

    iLoopIsUsed( EFalse )

    {

    }

/*

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

     Class: CTestCombiner

     Method: ConstructL

     Description: Symbian OS second phase constructor

     Symbian OS default constructor can leave.

     Parameters:    None

     Return Values: None

     Errors/Exceptions: None.

     Status: Approved

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

*/

void CTestCombiner::ConstructL()

    {

    // TRAPed to avoid crashing if logfile creation fails,

    // so we can run test without logging to file

    TRAPD( err, iStdLog = CStifLogger::NewL( KTestCombinerLogDir, 

                                      KTestCombinerLogFile );

        );

    if( err != KErrNone )

        {

        iStdLog = NULL;

        __RDEBUG( (_L("Creating logfile failed") ) );

        }  

    iLog = iStdLog;

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

        }

    // Get engine settings

    TEngineSettings engineSettings;

    ret = settingServer.GetEngineSettings(engineSettings);

    if(ret != KErrNone)

        {

        __TRACE(KError, (_L("Could not retrieve engine settings from SettingServer [%d]"), ret));

        iUITestingSupport = EFalse;

        iSeparateProcesses = EFalse;

        }

        else

        {

        iUITestingSupport = engineSettings.iUITestingSupport;

        iSeparateProcesses = engineSettings.iSeparateProcesses;

        __TRACE(KMessage, (_L("Engine settings retrieved from SettingServer. UITestingSupport [%d] SeparateProcesses [%d]"), iUITestingSupport, iSeparateProcesses));

        }

    // Close Setting server session

    settingServer.Close();

    iAddTestCaseTitleToLogName = loggerSettings.iAddTestCaseTitle;

    iIndexTestModuleControllers = 1;

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

    }

/*

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

     Class: CTestCombiner

     Method: NewL

     Description: Two-phased constructor.

     Parameters:    None

     Return Values: CTestCombiner*: new object

     Errors/Exceptions: Leaves if new or ConstructL leaves.

     Status: Approved

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

*/

CTestCombiner* CTestCombiner::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

/*

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

     Class: CTestCombiner

     Method: ~CTestCombiner

     Description: Destructor

     Parameters:    None

     Return Values: None

     Errors/Exceptions: None

     Status: Approved

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

*/

CTestCombiner::~CTestCombiner()

    {

    iLoopAllocationArray.Reset();

    iLoopAllocationArray.Close();

    iLoopIsUsed = EFalse;

    iTestCases.ResetAndDestroy();

    iTestModules.ResetAndDestroy();

    iEventArray.ResetAndDestroy();

    iSlaveArray.ResetAndDestroy();

    iSendReceive.ResetAndDestroy();

    iTestCases.Close();

    iTestModules.Close();

    iEventArray.Close();

    iSlaveArray.Close();

    iSendReceive.Close();

    // Stop all remaining measurement modules

    const TInt count_meas = iTestMeasurementArray.Count();

    for( TInt b = 0; b < count_meas; b++ )

        {

        iTestMeasurementArray[b]->iMeasurement->Stop();

        }

    iTestMeasurementArray.ResetAndDestroy();

    iTestMeasurementArray.Close();

    delete iSectionParser;

    delete iRemoteReceiver;

    delete iTestRunner;

    iLog = NULL;

    delete iStdLog;

    iStdLog = NULL;

    delete iTCLog;

    iTCLog = NULL;

    }

/*

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

     Class: CTestCombiner

     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 CTestCombiner::InitL( TFileName& aIniFile, 

                           TBool /*aFirstTime*/ )

    {

    __TRACEFUNC();

    if( aIniFile.Length() > 0 )

        {

        // Read initialization from test case file

        ReadInitializationL( aIniFile );

        }

    return KErrNone;

    }

/*

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

     Class: CTestCombiner

     Method: GetTestCases

     Description: GetTestCases is used to inquired test cases

     Parameters:    const TFileName& aConfigFile: in: Config file name

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

                          Array of TestCases 

     Return Values: KErrNone: Success

                    KErrNotFound: Testcases not found

     Errors/Exceptions: Leaves if CStifParser::NewL leaves

                        Leaves if CStifParser::SectionL leaves

                        Leaves if CStifParser::NextSectionL leaves

                        Leaves if memory allocation fails

     Status: Approved

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

*/

TInt CTestCombiner::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;

    TRAPD( err, parser = 

        CStifParser::NewL( _L(""), aConfigFile, CStifParser::ECStyleComments ) );

    if( err != KErrNone )

        {

        __TRACE( KError, (_L("Test case script file not found") ) );

        __RDEBUG( (_L("Test case script file not found") ) );

        return KErrNotFound;

        }

    CleanupStack::PushL( parser );

    CStifSectionParser* section;

    TPtrC tmp;

    TInt index = 0;

    TInt ret = KErrNone;

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

    if( section == NULL )

        {

        ret = KErrNotFound;

        }

    else

        {    

        while( section )

            {

            CleanupStack::PushL( section );

            if( section->GetLine( KTitle,  tmp, ENoTag ) == KErrNone )

                 {

                 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;

                 CStifItemParser* item = section->GetItemLineL( KTimeout );

                 if( item )

                    {

                    TInt timeout; // In milliseconds

                    ret = item->GetInt( KTimeout, timeout ); 

                    if( ret != KErrNone )

                        {

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

                        User::Leave( ret ); 

                        }

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

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

                    }

                 item = section->GetItemLineL( KPriority );

                 if( item )

                    {

                    ret = item->GetInt( KPriority, tc->iPriority ); 

                    if( ret != KErrNone )

                        {

                        TPtrC priority;

                        ret = item->GetString( KPriority, priority );

                        if( ret != KErrNone )

                            {

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

                            User::Leave( ret ); 

                            }

                        switch( TTCKeywords::Parse( priority, 

                                                    TTCKeywords::Priority ) )

                            {

                            case TTCKeywords::EPriHigh:

                                tc->iPriority = TTestCaseInfo::EPriorityHigh;

                                break;

                            case TTCKeywords::EPriNormal:

                                tc->iPriority = TTestCaseInfo::EPriorityNormal;

                                break;

                            case TTCKeywords::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: CTestCombiner

     Method: RunTestCaseL

     Description: Run a specified testcase.

     RunTestCaseL is used to run an individual test case specified 

     by aTestCase. 

     Parameters:    const TInt aCaseNumber: in: Testcase number 

                    const TFileName& aConfig: in: Configuration file name

                    TTestResult& aResult: out; test case result

     Return Values: KErrNone: Test case started succesfully.

                    KErrNotFound: Testcase not found

                    KErrUnknown: Unknown TestCombiner error

                    Any other SymbianOS error

     Errors/Exceptions: Leaves if GetTestCaseL leaves

                        Leaves if RunTestL leaves

                        Leaves if memory allocation fails

     Status: Approved

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

*/

TInt CTestCombiner::RunTestCaseL( const TInt aCaseNumber, 

                                  const TFileName& aConfig, 

                                  TTestResult& aResult )

    {

    __TRACEFUNC();

    __TRACE( KMessage, (_L("***Testcase started***")));

    //Open new log file with test case title in file name

    if(iAddTestCaseTitleToLogName)

        {

        //Close test case log if exists

        if(iTCLog)

            {

            delete iTCLog;

            iTCLog = NULL;

            }

        TFileName logFileName;

        TName title;

        TestModuleIf().GetTestCaseTitleL(title);

        logFileName.Format(KTestCombinerLogFileWithTitle, &title);

        iTCLog = CStifLogger::NewL(KTestCombinerLogDir, logFileName);

        iLog = iTCLog;

        }

    /* 

    * Allow memory leaks, because Defines are leaved untouched 

    * after test case execution. Real memory leaks are detected with 

    * UHEAP macros.

    */

    TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksMem );

    // Read initialization from test case file

    ReadInitializationL( aConfig );

    __UHEAP_MARK;

    iSectionParser = GetTestCaseL( aCaseNumber, aConfig );

    // Check parsing result

    if( iSectionParser == NULL )

        {

        __TRACE( KError, (_L("***Parsing testcase failed***")));

        __UHEAP_MARKEND;

        return KErrNotFound;

        }

    CActiveScheduler* activeScheduler = 

        new ( ELeave ) CActiveScheduler();

    CleanupStack::PushL( activeScheduler );

    CActiveScheduler::Install( activeScheduler );