/*

* 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 

* CTestModuleContainer class member functions. CTestModuleContainer 

* class contains interface * to execute various functions in context 

* of test execution thread.

*

* CTestModuleContainer is the owner of the test execution thread 

* object and the owner of the test module instance.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32svr.h>

#include <e32uid.h>

#include "TestEngineClient.h"

#include <StifTestModule.h>

#include <stifinternal/TestServerClient.h>

#include "TestServer.h"

#include "TestServerModuleIf.h"

#include "TestServerCommon.h"

#include "PrintQueue.h"

#include "TestThreadContainer.h"

//--PYTHON-- begin

#include "StifPython.h"

//--PYTHON-- end

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// The test module execution thread function

TInt ExecutionThread( TAny* aParams );

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

typedef TInt( *CTestInterfaceFactoryTestModule )( CTestModuleParam*&, TUint32& );

// FORWARD DECLARATIONS

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

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

/*

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

    Class: CTestModuleContainer

    Method: NewL

    Description: Returns new CTestModuleContainer instance.

    Parameters: const TDesC& aName: in: Module name

                CTestModule* aSession: in: "Parent"

                const TDesC& aConfig: in: Test case (config) file name.

    Return Values: CTestModuleContainer* New instance

    Errors/Exceptions: Function leaves if memory allocation fails or

                       CTestModuleContainer ConstructL leaves.

                       Panics if aSession is NULL.

    Status: Proposal

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

*/

CTestModuleContainer* CTestModuleContainer::NewL( const TDesC& aName,

                                                  CTestModule* aSession,

                                                  const TDesC& aConfig )

    {

    __ASSERT_ALWAYS ( aSession, 

                      CTestServer::PanicServer( ENullTestModule ) );

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

    CleanupStack::PushL( self );

    self->ConstructL( aName, aSession, aConfig );

    CleanupStack::Pop( self );

    return self;

    }

/*

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

    Class: CTestModuleContainer

    Method: ConstructL

    Description: Second level constructor.

    Function creates the execution thread, creates exception

    handler and the thread undertaker for it and then resumes the thread.

    Parameters: const TDesC& aName: in: Module name

                CTestModule* aSession: in: "Parent"

                const TDesC& aConfig: in: Test case (config) file name.

    Return Values: CTestModuleContainer* New instance

    Errors/Exceptions: Function leaves if thread creation fails,

                       memory allocation fails or undertaker creation leaves.

    Status: Proposal

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

*/

void CTestModuleContainer::ConstructL( const TDesC& aName,

                                       CTestModule* aSession,

                                       const TDesC& aConfig )

    {

    RDebug::Print( aName );

    iNestedActiveScheduler = new (ELeave) CActiveSchedulerWait;

    iCTestModule = aSession;

    // Create error print handler

    iErrorPrintHandler = CErrorPrintHandler::NewL( *this );

    User::LeaveIfError( iErrorPrintSem.CreateLocal( 0 ) );

    // Construct unique thread name

    const TInt KAddressLen = 8;

    const TInt KMaxName = 50;  // Something smaller than max thread name

    TInt len = aName.Length();

    if ( KAddressLen + len > KMaxName )

        {

        len = KMaxName - KAddressLen;

        }

    // Default heap and stack sizes that may configure by user.

    TInt heapMinSize( KTestThreadMinHeap );

    TInt heapMaxSize( KTestThreadMaxHeap );

    TInt stackSize( KStackSize );

    // Check is user give heap or stack sizes and verify sizes.

    GetTestModuleParams( aName, aConfig, stackSize, heapMinSize, heapMaxSize );

    // Create a new thread

    TInt ret = KErrAlreadyExists;

    for( TInt i = 0; ret == KErrAlreadyExists; i++ )

        {

        TName threadName = aName.Left( len );

        threadName.AppendFormat( _L( "%x" ), ( TUint32 ) this );

        threadName.AppendFormat( _L( "%x" ), i );

        //RDebug::Print( threadName );

		RDebug::Print(_L("CTestModuleContainer::ConstructL create thread=[%S] stackSize=(%d)"), &threadName, stackSize);

		if ( iCTestModule->GetTestServer()->IsUiTestingSupported() && iCTestModule->UiTesting() )

            {

            ret = iThread.Create(

                    threadName,                 // name of thread

                    CTestThreadContainer::UIExecutionThread,// thread function

                    stackSize,                  // Stack size

                    heapMinSize,                // Heap sizes

                    heapMaxSize,

                    this                        // Parameter to thread function

                    );

            }

		else

		    {

	        ret = iThread.Create(

	                    threadName,                 // name of thread

	                    CTestThreadContainer::ExecutionThread,// thread function

	                    stackSize,                  // Stack size

	                    heapMinSize,                // Heap sizes

	                    heapMaxSize,

	                    this                        // Parameter to thread function

	                    );

			}

        // If test execution thread exist try to create new one

        if( ret == KErrAlreadyExists )

            {

            RDebug::Print( _L( "Thread[%S] allready exist, creating new one" ), &threadName );

            __TRACE ( KInit, ( CStifLogger::ERed, _L( "Thread[%S] allready exist, creating new one" ), &threadName ) );

            }

        }

    // If thread creation fails, leave here.

    if( ret != KErrNone )

        {

        RDebug::Print( _L( "Execution thread creation fails with: [%d]" ), ret );

        __TRACE ( KError, ( CStifLogger::ERed, _L( "Execution thread creation fails with: [%d]" ), ret ) );

        User::Leave( ret );

        }

    // Doing nothing

    // ChangeOperationNoError ( ESuspend, 0 );

    // Thread suspends always first by default

    // Construct the undertaker to get notifications about the 

    // thread death. 

    // This must be trapped to allow to kill just created thread

    // nicely without a mess in destructor.

    TRAPD ( r, 

        iUnderTaker = CUnderTaker::NewL ( this );

        CActiveScheduler::Add( iUnderTaker );

        iUnderTaker->StartL();

        );    

    // Can't create or start the undertaker. Kill the thread. 

    // Undertaker will be deleted in destructor if needed.

    if ( r != KErrNone )

        {

        iThread.Kill ( r );

        iThread.Close();

        User::Leave( r );

        }

    // Get server thread id ( i.e current thread id )

    RThread tmpThread;

    iServerThreadId = tmpThread.Id();

    // Resume the thread

    iThread.Resume();                // Start the thread

    iUpAndRunning = ETrue;           // Thread is created 

    // Add "this" container to active scheduler

    CActiveScheduler::Add ( this );

    // Start error print handler

    iErrorPrintHandler->StartL();

    }

/*

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

    Class: CTestModuleContainer

    Method: CTestModuleContainer

    Description: Constructor.

    Initialise semaphores.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CTestModuleContainer::CTestModuleContainer() :

    CActive( CActive::EPriorityStandard ),

    iOperationName ( 0, 0 ),

    iIsPaused( EFalse )

    {

    // Create operation start semaphore

    iOperationStartSemaphore.CreateLocal( 0 );

    // Operation can be changed without first waiting.

    iOperationChangeSemaphore.CreateLocal( 1 );

    }

/*

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

    Class: CTestModuleContainer

    Method: ~CTestModuleContainer

    Description: Destructor

    Delete the test execution thread, if it is up and running. Delete

    undertaker and close handles.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CTestModuleContainer::~CTestModuleContainer()

    {

    __TRACE ( KThreadOperation, ( _L( "CTestModuleContainer::~CTestModuleContainer in" ) ) );

    if ( iUpAndRunning )

        {

		if( iUnderTaker != NULL )

			{

			iUnderTaker->Cancel();

			}

        // Set the operation

        ChangeOperationNoError ( EExit, 0 );

        // Do operation

        StartAndWaitOperation();

        }

    delete iErrorPrintHandler;

	iErrorPrintHandler = NULL;

    // Delete heap descriptor

    delete iModuleNameBuffer;

    iModuleNameBuffer = NULL;

    // Delete undertaker

    delete iUnderTaker;

    iUnderTaker = NULL;

    // Close error semaphore

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

    // Close the semaphores

    iOperationStartSemaphore.Close();

    iOperationChangeSemaphore.Close();

    // Close handle to thread

    iThread.Close();

    Cancel();

    delete iNestedActiveScheduler;

    iNestedActiveScheduler = NULL;

    __TRACE ( KThreadOperation, ( _L( "CTestModuleContainer::~CTestModuleContainer out" ) ) );

    }

/*

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

    Class: CTestModuleContainer

    Method: StartAndWaitOperation

    Description: Signals operation and waits until operation is completed.

    Function executes active scheduler locally to handle both request

    completion from execution thread and thread undertaker operations.    

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CTestModuleContainer::StartAndWaitOperation()

    {

    // Change undertaker mode to synchronous    

    iUnderTaker->SetSynchronousMode( ETrue );

    iStatus = KRequestPending;

    // Get ready to handle operation completion

    SetActive();

    // Start operation

    iOperationStartSemaphore.Signal();

    // Start "nested" active scheduler "locally"

    //CActiveScheduler::Start();

    iNestedActiveScheduler->Start();

    // Request completed or operation crashed, everything 

    // is done in ModuleContainer's RunL function or in UnderTaker's RunL.

    // Cancel the original request in case than it was the undertaker

    // that stopped the active scheduler. Does not do anything if original

    // request is already finished.

    Cancel();

    // Undertaker back to "normal" mode

    iUnderTaker->SetSynchronousMode ( EFalse );

    return iModuleResult;

    }

/*

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

    Class: CTestModuleContainer

    Method: Initialise

    Description: Initialise the test module

    Initialisation is done in context of test execution thread.

    Parameters: const TDesC& aName            :in:  Module name

                TBool aFirstTime              :in:  First init?

    Return Values: TInt                             Result from init

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CTestModuleContainer::Initialize( const TFileName& aName,

                                       TBool aFirstTime

                                     )

    {

    __TRACE ( KInit, ( _L( "Initializing test module" ) ) );

    // Set the operation

    iErrorResult = ChangeOperation ( EInitializeModule, aName, aFirstTime );

    iModuleResult = KErrNone;

    if ( iErrorResult == KErrNone )

        {

        // Wait until operation is completed

        StartAndWaitOperation();

        }

    if ( iErrorResult )

        {

        __TRACE ( KError, ( CStifLogger::ERed,  _L( "Initializing test module failed %d" ), iErrorResult ) );

        }

    else if ( iModuleResult )

        {

        __TRACE ( KError, ( CStifLogger::ERed, _L( "Initializing test module failed code from module = %d" ), iModuleResult ) );

        } 

    else

        {

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

        }

    // Return result

    return iModuleResult;

    }

/*

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

    Class: CTestModuleContainer

    Method: EnumerateTestCases

    Description: Enumerate test cases of the test module

    Enumeration is done in context of test execution thread.

    Parameters: const TDesC& aName            :in:  Configuration file

    Return Values: TInt                             Result from enumeration

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CTestModuleContainer::EnumerateTestCases( const TFileName& aName )

    {

    __TRACE ( KInit, ( CStifLogger::EBold, _L( "Enumerating test cases from [%S] (might be empty)" ), &aName ) );

    // Set the operation

    iErrorResult = ChangeOperation( EEnumerateInThread, aName, 0 );

    iModuleResult = KErrNone;

    if ( iErrorResult == KErrNone )

        {

        // Wait until operation is completed

        StartAndWaitOperation();

        }

    if ( iErrorResult )

        {

        __TRACE ( KError, ( CStifLogger::ERed, _L( "Enumerating test cases failed %d" ), iErrorResult ) );

        }

    else if ( iModuleResult )

        {

        __TRACE ( KError, ( CStifLogger::ERed, _L( "Enumerating test cases failed, code from module = %d" ), iModuleResult ) );

        } 

    else

        {

        __TRACE ( KInit, ( _L( "Enumerating test cases done" ) ) );

        }

    // Return result

    return iModuleResult;

    }

/*

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