/*

* 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 

* CTestThreadContainer class implementation. These functions are 

* called from the context of the test execution thread.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32svr.h>

#include <e32uid.h>

#include <StifTestModule.h>

#include "ThreadLogging.h"

#include "TestEngineClient.h"

#include <stifinternal/TestServerClient.h>

#include "TestServer.h"

#include "TestThreadContainer.h"

#include "TestServerCommon.h"

#include "TestServerModuleIf.h"

#include "TestServerEvent.h"

#include "TestThreadContainerRunner.h"

#include <stifinternal/TestThreadContainerRunnerFactory.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

#ifdef THREADLOGGER

#undef THREADLOGGER

#endif

#define THREADLOGGER iThreadLogger 

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// None

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

/*

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

    Class: CTestThreadContainer

    Method: NewL

    Description: Returns new CTestThreadContainer instance.

    Parameters: None

    Return Values: CTestThreadContainer*            New instance

    Errors/Exceptions: Function leaves if memory allocation fails or

                       CTestThreadContainer ConstructL leaves.

    Status: Proposal

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

*/

CTestThreadContainer* CTestThreadContainer::NewL( 

    CTestModuleContainer* aModuleContainer,

    TThreadId aServerThreadId )

    {

    CTestThreadContainer* self = 

        new ( ELeave ) CTestThreadContainer( aModuleContainer );

    CleanupStack::PushL( self );

    self->ConstructL( aServerThreadId );

    CleanupStack::Pop( self );

    return self;

    }

/*

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

    Class: CTestThreadContainer

    Method: ConstructL

    Description: Second level constructor.

    Parameters: None

    Return Values: CTestThreadContainer*            New instance

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CTestThreadContainer::ConstructL( TThreadId aServerThreadId )

    {

    User::LeaveIfError( iServerThread.Open( aServerThreadId ) );

    iErrorPrintSem.SetHandle( ModuleContainer().ErrorPrintSemHandle() );

    User::LeaveIfError( iErrorPrintSem.Duplicate( iServerThread ) );

    }

/*

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

    Class: CTestThreadContainer

    Method: CTestThreadContainer

    Description: Constructor.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CTestThreadContainer::CTestThreadContainer( 

    CTestModuleContainer* aModuleContainer ):

    iModuleContainer( aModuleContainer ),

    iCheckResourceFlags( 0 )

    {

    ModuleContainer().SetThreadContainer( this );

    StifMacroErrorInit(); // Initialization

    }

/*

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

    Class: CTestThreadContainer

    Method: ~CTestThreadContainer

    Description: Destructor

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CTestThreadContainer::~CTestThreadContainer()

    {

    // Close mutexes

    if ( iPrintMutex.Handle() != 0 ) iPrintMutex.Close();

    if ( iEventMutex.Handle() != 0 ) iEventMutex.Close();

    if ( iSndMutex.Handle() != 0 ) iSndMutex.Close();

    if ( iRcvMutex.Handle() != 0 ) iRcvMutex.Close();

    if ( iInterferenceMutex.Handle() != 0 ) iInterferenceMutex.Close();

    if ( iMeasurementMutex.Handle() != 0 ) iMeasurementMutex.Close();

    if ( iCommandMutex.Handle() != 0 ) iCommandMutex.Close();

    // Mutex for testcomplete and cancel operations. Close duplicate mutex

    if ( iTestThreadMutex.Handle() != 0 ) iTestThreadMutex.Close();

    // Close semaphores

    if ( iPrintSem.Handle() != 0 ) iPrintSem.Close();

    if ( iErrorPrintSem.Handle() != 0 ) iErrorPrintSem.Close();

    if ( iEventSem.Handle() != 0 ) iEventSem.Close();

    if ( iSndSem.Handle() != 0 ) iSndSem.Close();

    if ( iRcvSem.Handle() != 0 ) iRcvSem.Close();

    if ( iInterferenceSem.Handle() != 0 ) iInterferenceSem.Close();

    if ( iMeasurementSem.Handle() != 0 ) iMeasurementSem.Close();

    //if ( iReceiverSem.Handle() != 0 ) iReceiverSem.Close();

    if ( iCommandSem.Handle() != 0) iCommandSem.Close();

    iServerThread.Close();

    }

/*

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

    Class: CTestThreadContainer

    Method: InitializeModule

    Description: Initialize test module.

    Function obtains pointer to the first exported function of the test module,

    and calls that function to obtain an instance of CTestModuleBase derived

    object. After that the "Init()"-method is called. If some operation fails,

    module will be deleted and error code is returned.

    This function is a static member function, which is intented to be called

    from the context of the test module thread.

    Parameters: RLibrary& aModule                 :in: Module to be loaded

    Return Values: TInt                                Error code from module

                                                       or memory allocation.

    Errors/Exceptions: None.

    Status: Proposal

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

*/

TInt CTestThreadContainer::InitializeModuleInThread ( RLibrary& aModule )

    {        

    __TRACEI ( KInit, ( _L("Starting test module initialization") ) );

    __TRACEI ( KInit, ( CStifLogger::EBold,  _L("Module name \"%S\""), 

        &ModuleContainer().OperationName() ) );

    ModuleContainer().OperationText() = _L("E32DLL");

    TFileName moduleName;

    TFileName tmpBuffer;

    TInt r( KErrNone );

    TFileName newNameBuffer;

    TInt check = CheckModuleName( ModuleContainer().OperationName(), newNameBuffer );

    if( check == KErrNone )

        {

        // Load the module(TestScripter)

        r = aModule.Load( newNameBuffer );

        }

    else

        {

        // Load the module(Others)

        RemoveOptionalIndex(ModuleContainer().OperationName(), newNameBuffer);

        __TRACEI(KInit, (_L( "Valid module name is [%S] (extracted from [%S])"), &newNameBuffer, &ModuleContainer().OperationName()));

        r = aModule.Load(newNameBuffer);

        }

    if ( r != KErrNone )

        {

        __TRACEI (KError, ( CStifLogger::EError, _L("Can't initialize test module code = %d"), r));

        // Set error codes

        ModuleContainer().OperationErrorResult() = r;

        return r;

        }

    else

        {

        // Print module name

        moduleName = aModule.FileName();    

        __TRACEI (KInit, (  _L("Loaded test module[%S]"), &moduleName ) );

        }

    // Get pointer to first exported function

    ModuleContainer().OperationText() = _L("1st EXPORTED function");

    CTestInterfaceFactory libEntry;

    libEntry = (CTestInterfaceFactory) aModule.Lookup(1);

    if ( libEntry == NULL )

        {

        // New instance can't be created

        __TRACEI (KError, ( CStifLogger::EError, _L("Can't initialize test module, NULL libEntry")));

        // Set error codes

        ModuleContainer().OperationErrorResult() = KErrNoMemory;

        return KErrNoMemory;

        }

    else

        {

        __TRACEI ( KInit, ( _L("Pointer to 1st exported received")));

        }

    // initialize test module

    __TRACEI ( KVerbose, (_L("Calling 1st exported at 0x%x"), (TUint32) libEntry ));

    TRAPD ( err, iTestModule =  (*libEntry)() );

     // Handle leave from test module

    if ( err != KErrNone )

        {

        __TRACEI (KError, ( CStifLogger::EError, _L("Leave when calling 1st exported function, code %d"), err));

        tmpBuffer = _L("Leave from test module 1st EXPORTED function");        

        ErrorPrint( 1, tmpBuffer );        

        delete iTestModule;

        iTestModule = NULL;

        // Set error codes

        ModuleContainer().OperationErrorResult() = err;

        return err;

        }

    else if ( iTestModule == NULL )     // Handle NULL from test module init

        {

        __TRACEI (KError, ( CStifLogger::EError, _L("NULL pointer received when constructing test module")));

        tmpBuffer = _L("Test module 1st EXPORTED function returned NULL");        

        ErrorPrint( 1, tmpBuffer );        

        delete iTestModule;

        iTestModule = NULL;

        // Set error codes

        ModuleContainer().OperationErrorResult() = KErrNoMemory;

        return KErrNoMemory;

        }

    else

        {

        __TRACEI (KInit, (_L("Entrypoint successfully called, test module instance at 0x%x"), (TUint32)iTestModule ) );

        }

    // Verify version number.

    ModuleContainer().OperationText() = _L("Version");

    TVersion moduleAPIVersion(0,0,0);

    TVersion myOldAPIVersion( KOldTestModuleAPIMajor, KOldTestModuleAPIMinor, KOldTestModuleAPIBuild );

    TVersion myAPIVersion( KTestModuleAPIMajor, KTestModuleAPIMinor, KTestModuleAPIBuild );

    TRAP ( err,  moduleAPIVersion = iTestModule->Version() );

    if ( err != KErrNone ||  (( myOldAPIVersion.iMajor !=  moduleAPIVersion.iMajor ||

                                myOldAPIVersion.iMinor !=  moduleAPIVersion.iMinor  )

                                &&

                              ( myAPIVersion.iMajor != moduleAPIVersion.iMajor ||

                              	myAPIVersion.iMinor != moduleAPIVersion.iMinor ))

        )

        {

        tmpBuffer = moduleAPIVersion.Name();

        __TRACEI (KError, ( CStifLogger::EError, _L("Incorrect test module version. Module version %S"), &tmpBuffer ) );        

        tmpBuffer = myOldAPIVersion.Name();

        __TRACEI (KError, ( CStifLogger::EError, _L("Required version %S"), &tmpBuffer  ) );

        tmpBuffer.Format(_L("Invalid version in [%S]"), &moduleName );

        ErrorPrint( 1, tmpBuffer );        

         // Set error codes

        ModuleContainer().OperationErrorResult() = KErrNotSupported;

        return KErrNotSupported;

        }

    ModuleContainer().OperationText() = _L("InitL");

    // Initialize test module

    TInt initResult = KErrNone;

    TRAP ( err, 

        CTestModuleIf::NewL( NULL, iTestModule );

        TFileName tmp = ModuleContainer().TestModuleIniFile();

        initResult = iTestModule->InitL( tmp, ModuleContainer().OperationIntBuffer() );

    );

    // Handle leave from test module

    if ( err != KErrNone )

        {

        __TRACEI (KError, ( CStifLogger::EError, _L("Leave when initializing test module code %d"), err));

        tmpBuffer = _L("Leave from test module InitL");        

        ErrorPrint( 1, tmpBuffer );   

        ModuleContainer().OperationText() = _L("DESTRUCTOR");

        delete iTestModule;

        iTestModule = NULL;

        ModuleContainer().OperationText() = _L("");

        // Set error codes

        ModuleContainer().OperationErrorResult() = err;

        return err;

        }      

    else if ( initResult != KErrNone ) 

        {     // Handle failed initialisation of test module

        __TRACEI (KError, ( CStifLogger::EError, _L("Can't initialize test module, code %d"), initResult));

        ModuleContainer().OperationText() = _L("DESTRUCTOR");

        delete iTestModule;

        iTestModule = NULL;

        ModuleContainer().OperationText() = _L("");

        // Set error code

        ModuleContainer().ModuleResult() = initResult;

        return initResult;

        }

    ModuleContainer().OperationText() = _L("");

    __TRACEI (KInit, ( CStifLogger::EBold, _L("Test module initialization done")));     

    return KErrNone;

    }

/*

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

    Class: CTestThreadContainer

    Method: EnumerateInThread

    Description: Enumerate test cases. Function calls GetTestCases method

    from the test module.

    This function is a static member function, which is intented to be called

    from the context of the test module thread.

    Parameters: None

    Return Values: TInt                           Error code.

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CTestThreadContainer::EnumerateInThread()

    {

    TInt err = KErrNone;

    __TRACEI ( KInit, ( CStifLogger::EBold, _L("Calling GetTestCasesL") ) );

    if ( iCases == NULL )

        {

        iCases = new RPointerArray<TTestCaseInfo>;

        if ( iCases == NULL )

            {

            ModuleContainer().OperationErrorResult() = KErrNoMemory;

            __TRACEI ( KError, ( _L("Can't create pointer array for cases") ) );

            return ModuleContainer().OperationErrorResult();

            }

        }

    // Thread ID logging(For error situations) !!!!! ----------

    /*

    RThread t;

    RDebug::Print(_L("XXXXXXXXXXXXXXXXXXXXXX CurrentThread=[%d]"), t.Id() );

    t.Open( t.Id() );   

    RDebug::Print(_L("XXXXXXXXXXXXXXXXXXXXXX Real id=[%d]"), t.Id() );

    t.Close();

    */

    // --------------------------------------------------------

    ModuleContainer().OperationText() = _L("GetTestCasesL");

    TRAPD (r, err = iTestModule->GetTestCasesL( 

                        ModuleContainer().OperationName(),

                        *iCases ) );

    ModuleContainer().OperationText() = _L("");

    // Leave

    if ( r != KErrNone )

        {

        __TRACEI ( KError, ( CStifLogger::ERed, _L("GetTestCasesL leave code %d"), r ) );

        TName tmpBuffer = _L("Leave from test module GetTestCasesL");        

        ErrorPrint( 1, tmpBuffer );        

        FreeEnumerationDataInThread();

        ModuleContainer().OperationErrorResult() = r;

        return r;

        }

    // Error originating from test module

    if ( err != KErrNone )

        {

        __TRACEI ( KError, ( CStifLogger::ERed, _L("GetTestCasesL returned error %d"), err ) );

        FreeEnumerationDataInThread();

        ModuleContainer().ModuleResult() = err;

        return err;

        }

    __TRACEI ( KInit, ( _L("GetTestCasesL successfully called") ) );

    // All ok.

    return KErrNone;

    }

/*

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

    Class: CTestThreadContainer

    Method: FreeEnumerationDataInThread

    Description: Frees the enumeration data. This function is called, when

    the enumeration data is read from execution thread heap to server thread

    heap. If cases have not been enumerated function does nothing.

    Function is intented to be called from the context of the test module thread.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CTestThreadContainer::FreeEnumerationDataInThread()

    {

    __TRACEI ( KInit, ( _L("Freeing test case array") ) );

    if ( iCases )

        {

        iCases->ResetAndDestroy();

        delete iCases;

        iCases = NULL;

        }

    __TRACEI ( KInit, ( _L("Freeing test case array done") ) );

    }

/*

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

    Class: CTestThreadContainer

    Method: ExecuteTestCaseInThread