/*

* 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 implementation of 

* CTestModuleController class member functions.

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <stifinternal/TestServerClient.h>

#include <StifLogger.h>

#include "TestEngine.h"

#include "TestModuleController.h"

#include "Logging.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

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

// None

#define LOGGER iEngine->Logger()

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

/*

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

    Class: CTestModuleController

    Method: CTestModuleController

    Description: Default constructor

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

    might leave.

    Parameters: CTestEngine* aEngine: in: Pointer to CTestEngine

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

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

*/

CTestModuleController::CTestModuleController( CTestEngine* aEngine ) :

    CActive( CActive::EPriorityStandard ),

    iEngine( aEngine ),

    iState( ETestModuleIdle )

    {

    CActiveScheduler::Add( this );

    iTestScripterController = NULL;

    }

/*

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

    Class: CTestModuleController

    Method: ConstructL

    Description: Symbian OS second phase constructor

    Symbian OS default constructor can leave.

    Parameters: const TName& aName: in: Test module name

    Return Values: None

    Errors/Exceptions: Leaves if memory allocation for iConfigFiles fails

                       Leaves if memory allocation for iTestCaseArray fails

    Status: Approved

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

*/

void CTestModuleController::ConstructL( 

                            const TName& aName,

                            TBool aAfterReboot,

                            CTestScripterController* aTestScripterController )

    {

    iTestScripterController = aTestScripterController;

    iTestScripterIndicator = 0;

    iAfterReboot = aAfterReboot;

    __TRACE ( KInit, ( _L( "Creating CTestModuleController [%S]" ), &aName ) );

    iTestCaseArray = RPointerArray<TTestCaseArray>();

    // Check aName length

    if( aName.Length() <= 0 )

        {

        iEngine->LeaveWithNotifyL( KErrArgument );

        }

    // Remove optional '.DLL' from file name

    TName name = aName;

    name.LowerCase();

    TParse parse;

    parse.Set( name, NULL, NULL );

    if ( parse.Ext() == _L(".dll") )

        {

        const TInt len = parse.Ext().Length();

        name.Delete ( name.Length()-len, len );

        }

    iName = name.AllocL();

    // HBufC to TPtrC

    TPtrC atsName;

    TFileName newNameBuffer;

    TInt check = GenerateModuleName( iName->Des(), newNameBuffer );

    if( check == KErrNone )

        {

        // Load the module(TestScripter)

        atsName.Set( newNameBuffer );

        }

    else

        {

        // Load the module(Others)

        atsName.Set( iName->Des() );

        }

    // Moved the implementation to a new function, ConstructASTLoggerL, due to

    // CW 3.0 compiler error with multiple TRAPDs

    TRAPD(err, ConstructASTLoggerL( atsName, aAfterReboot));

    if( err != KErrNone )

        {

         __TRACE ( KError, ( _L( "CTestModuleController[%S]::ConstructL: Creation of ATS logger failed" ), iName ) );

        iEngine->LeaveWithNotifyL( err, _L("Creation of ATS logger failed") );

        }

    }

/*

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

    Class: CTestModuleController

    Method: ConstructASTLoggerL

    Description: Construct ATS logger

    Parameters: TDesC& atsName, TBool& aAfterReboot

    Return Values: TInt

    Errors/Exceptions: Leaves if error got from ATS logger NewL

    Status: Proposal

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

*/

TInt CTestModuleController::ConstructASTLoggerL( TDesC& atsName, TBool& aAfterReboot )

    {

    TRAPD( err, iAtsLogger = CAtsLogger::NewL( atsName, aAfterReboot ); );

    if( err == KErrNotFound && aAfterReboot )

        {

        // If file does not exist, create new 

        aAfterReboot = EFalse;

        iAtsLogger = CAtsLogger::NewL( atsName, aAfterReboot );

        }

    User::LeaveIfError( err );

    iAtsLogger->SetFullReporting( ETrue );

    if( aAfterReboot )

        {

        iAtsLogger->ContinueAfterRebootL();

        }

    else

        {

        // Begin reporting

        iAtsLogger->BeginTestReportL();

        // Begin test set

        iAtsLogger->BeginTestSetL();

        }

    return KErrNone;

    }

/*

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

    Class: CTestModuleController

    Method: InitL

    Description: Initialize test module.

    Parameters: TFileName& aIniFile: in: Initialization file of Test Module

                const TDesC& aConfigFile: in: Test case(config) file name(Used 

                in TestScripter case).

    Return Values: None

    Errors/Exceptions: Leaves if error got from Test Server

    Status: Proposal

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

*/

void CTestModuleController::InitL( TFileName& aIniFile, 

                                    const TDesC& aConfigFile )

    {

    __TRACE( KInit, (_L( "Initialising test module [%S] with initialization file [%S]" ),

        iName, &aIniFile ) );

    // HBufC to TPtrC

    TPtrC name( iName->Des() );

    // Connect to server

    TInt r = iServer.Connect( name, aConfigFile );

    if ( r != KErrNone )

        {

        __TRACE( KError, ( CStifLogger::ERed, _L( "Can't connect to test module [%S], IniFile [%S]" ), &name, &aIniFile ) );

        LeaveWithNotifyL( r,  _L( "Can't connect to test module" ) );

        }

    // Open session 

    r = iModule.Open( iServer, aIniFile );

    if ( r != KErrNone )

        {

        __TRACE( KError, ( CStifLogger::ERed, _L( "Can't open session to test module [%S], IniFile=[%S]" ), &name, &aIniFile ) );

        LeaveWithNotifyL( r, _L( "Can't open session to test module" ) );

        }

    iErrorPrinter = CErrorPrinter::NewL( iEngine );

    iErrorPrinter->StartL( iModule );

    iServerStateHandler = CServerStateHandler::NewL( iEngine, this );

    iServerStateHandler->StartL( iServer );

    __TRACE( KInit, (_L( "Initialising test module [%S] with initialization file [%S] done" ),

        iName, &aIniFile ) );

    }

/*

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

    Class: CTestModuleController

    Method: NewL

    Description: Two-phased constructor.

    Parameters: CTestEngine* aEngine: in: CTestEngine object.

                const TName& aName: in: module name.

                TBool aAfterReboot: in: reboot indicator.

                TBool aCreateTestScripterCont: in: Indications to

                TestModule or TestScripter creation

                CTestScripterController* aTestScripterController: in:

                CTestEngine object.

    Return Values: CTestModuleController* : pointer to created object

    Errors/Exceptions: Leaves if called ConstructL method leaves

    Status: Proposal

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

*/

CTestModuleController* CTestModuleController::NewL( 

                            CTestEngine* aEngine,

                            const TName& aName,

                            TBool aAfterReboot,

                            TBool aCreateTestScripterCont,

                            CTestScripterController* aTestScripterController )

    {

    // Create CTestScripterController

    if( aCreateTestScripterCont )

        {

        CTestScripterController* testScripterController = NULL;

        testScripterController = CTestScripterController::NewL(

            aEngine, aName, aAfterReboot );

        return testScripterController;  

        }

    CTestModuleController* self =

        new ( ELeave ) CTestModuleController( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL( aName, aAfterReboot, aTestScripterController );

    CleanupStack::Pop( self );

    return self;

    }

/*

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

    Class: CTestModuleController

    Method: ~CTestModuleController

    Description: Destructor

    Deallocate all allocated resources

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CTestModuleController::~CTestModuleController()

    {

    // If CTestScripterController is created there is deleted base class(

    // CTestModuleController) also and this has no iName.

    if( iName )

        {

        __TRACE(KVerbose, (_L( "Deleting CTestModuleController [%S]" ), iName ) );

        }

    Cancel();

    // If CTestScripterController is created there is deleted base class(

    // CTestModuleController) also and this has no iAtsLogger.

    if( iAtsLogger )

        {

        // End test set

        TRAPD( err, iAtsLogger->EndTestSetL() );

        // End AtsLogger reporting, has to be trapped in destructor

        TRAPD( err2, iAtsLogger->EndTestReportL() );

        if( ( err != KErrNone ) || ( err2 != KErrNone ) )

            {

            // Print error if error got from trap

            __TRACE( KError, ( 

                _L( "Destructor of CTestModuleController [%S]: XML log closing failed" ),

                iName ) );

            }

        }

    // Delete Atslogger

    delete iAtsLogger;

    // Stop error printer

    delete iErrorPrinter;

    iErrorPrinter = NULL;

    // Delete server state handler

    delete iServerStateHandler;

    iServerStateHandler = NULL;

    // Close RTestModule session

    iModule.Close();

    // Close RTestServer session

    iServer.Close();

    // Release the test case array

    iTestCaseArray.Close();

    // Release the config file array

    iConfigFiles.Close();

    // Release the config file array

    iFailedEnumerateConfig.Reset();

    iFailedEnumerateConfig.Close();

    // Release the children array

    iChildrenControllers.ResetAndDestroy();

    iChildrenControllers.Close();

    delete iName;

    }

/*

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

    Class: CTestModuleController

    Method: AddConfigFileL

    Description: Add config file

    Parameters: TFileName& aConfigFile: in: Config file for Test Module

    Return Values: None

    Errors/Exceptions: Leaves if AppendL leaves

    Status: Approved

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

*/

void CTestModuleController::AddConfigFileL( TFileName& aConfigFile )

    {

    __TRACE( KInit,

        ( _L( "CTestModuleController::AddConfigFileL [%S] aConfigFile=[%S]" ),

        iName, &aConfigFile ) );

    // Check that this config file does not already exists

    for ( TInt i = 0; i < iConfigFiles.Count(); i++ )

        {

        // HBufC to TPtrC

        TPtrC name( iConfigFiles[i]->Des() );

        if ( KErrNone == aConfigFile.CompareF( name ) )

            {

            LeaveWithNotifyL( KErrAlreadyExists,  

                _L( "Adding config file failed: Config file already exists" ) );

            }

        }

    HBufC* configFile = aConfigFile.AllocLC();

    User::LeaveIfError( iConfigFiles.Append( configFile ) );

    CleanupStack::Pop( configFile );

    }

/*

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

    Class: CTestModuleController

    Method: RemoveConfigFileL

    Description: Remove config file

    Parameters: TFileName& aConfigFile: in: Config file name

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

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

*/

void CTestModuleController::RemoveConfigFileL( TFileName& aConfigFile )

    {

    __TRACE( KInit, ( 

        _L( "CTestModuleController::RemoveConfigFileL [%S] aConfigFile=[%S]" ),

        iName, &aConfigFile ) );

    // Find config file

    for ( TInt i = 0; i < iConfigFiles.Count(); i++ )

        {

        // HBufC to TPtrC

        TPtrC name( iConfigFiles[i]->Des() );

        if ( KErrNone == aConfigFile.CompareF( name ) )

            {

            HBufC* configFile = iConfigFiles[i];

            iConfigFiles.Remove(i);

            delete configFile;

            // Cancel enumerate and free test cases

            Cancel();

            FreeTestCases();

            return;

            }

        }

    LeaveWithNotifyL( KErrNotFound, 

        _L( "Removing config file failed: Config file not found" ) );

    }

/*

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

    Class: CTestModuleController

    Method: StartEnumerateL

    Description: Start test case enumeration

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

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

*/

void CTestModuleController::StartEnumerateL()

    {

    __TRACE( KVerbose, ( 

        _L( "CTestModuleController::StartEnumerateL [%S]" ), iName ) ); 

    iTestCaseCount = 0;

    iEnumerateCount = 0;

    iFailedEnumerateCount = 0;

    iFailedEnumerateConfig.Reset();

    iEnumerateComplete = EFalse;

    iState = ETestModuleEnumerateCases;