/*

* 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 CTestServer 

* class member functions.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32svr.h>

#include "TestEngineClient.h"

#include <StifTestModule.h>

#include <stifinternal/TestServerClient.h>

#include "TestServer.h"

#include "TestServerCommon.h"

#include "TestServerModuleIf.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// Struct to pass parameters to server thread

struct TThreadStartTestServerSession

    {

    RThread    iServerThread; // The server thread

    RSemaphore iStarted;      // Startup syncronisation semaphore   

    TInt       iStartupResult;// Start-up result

    };

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// None

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

/*

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

    Class: CTestModule

    Method: NewL

    Description: Create new Test Module    

    Parameters: RThread& aClient              :in:  Handle to client

                CTestServer* aServer          :in:  Pointer to server

    Return Values: CTestModule*                     Pointer to new test module

    Errors/Exceptions: Leaves if memory allocation fails or ConstructL leaves.

    Status: Approved

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

*/

CTestModule* CTestModule::NewL( CTestServer* aServer )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aServer );

    CleanupStack::Pop();

    return self;

    }

/*

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

    Class: CTestModule

    Method: CTestModule

    Description: Constructor.

    Initialise base class.

    Parameters: RThread& aClient              :in:  Handle to client

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

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

*/

CTestModule::CTestModule() :

    CSession2(),

    iIni(0, 0)

    {

    }

/*

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

    Class: CTestModule

    Method: ~CTestModule

    Description: Destructor.

    Deallocate memory and close handles.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None.

    Status: Proposal

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

*/

CTestModule::~CTestModule()

    {

    __TRACE( KVerbose, ( _L( "Closing test module" ) ) );

    // Free test case related data. No error checking here, because if freeing

    // fails, then nothing can be done in destructor.

    FreeCaseData();

    // Delete all test module instances.

    // Cleanup all RTestExecution has been opened by client but not properly

    // closed for example if timeout occurs and client died. This almost do

    // same than CloseSession() in "if( iTestExecutionHandle )" branch.

    if( iTestExecutionHandle )

        {

        TInt handle = 0;

        CObject* theObj = NULL;

        TInt count = iTestExecutionHandle->Count();

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

            {

            // Get pointer to CTestExecution

            theObj=iTestExecutionHandle->operator[]( i );

            if( theObj )

                {

                handle=iTestExecutionHandle->At( theObj );

                CTestExecution* testcase = (CTestExecution*) theObj;

                // Cancels test(s) execution(timeout, exit, etc)

                // For example TestCombiner is timeouted => TestCombiner's

                // TestServer+TestModule(s) should cancel also.

                testcase->CancelTestExecution();

                // CTestExecution will panic if test case is ongoing!!! This

                // should be stopped, client should handless this.

                iTestExecutionHandle->Remove( handle );

                }

            }

        delete iTestExecutionHandle;

        iTestExecutionHandle = NULL;

        }

    // Delete all FREE Test Module instances.

    if( iTestModuleInstances )

        {

        iTestModuleInstances->ResetAndDestroy();

        delete iTestModuleInstances;

        iTestModuleInstances = NULL;

        }

    // Delete ini file heap buffer

    delete iIniBuffer;

    iIniBuffer = NULL;

    // Delete array of test case titles

    iTestCaseTitles.ResetAndDestroy();

    iTestCaseTitles.Close();

    }

/*

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

    Class: CTestModule

    Method: ConstructL

    Description: Second level constructor.

    Parameters: CTestServer* aServer          :in:  Server

    Return Values: None

    Errors/Exceptions: Leaves if:

                       base class CreateL leaves

                       Object index creation fails

                       Object container creation fails

                       Pointer array construction fails                       

    Status: Approved

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

*/

void CTestModule::ConstructL( CTestServer* aServer )

    {

	__TRACE( KVerbose, ( _L( "CTestModule::ConstructL - constructing server session" ) ) );

    // second-phase construct base class

    //CSession2::CreateL( /* *aServer */ );

    iTestServer = aServer;

    // create new object index

    iTestExecutionHandle = CObjectIx::NewL();

    // Initialize the object container using the object

    // container index in the server.

    iContainer = iTestServer->NewContainerL();

    iTestModuleInstances = new( ELeave ) RPointerArray<CTestModuleContainer>;

	__TRACE( KError, ( _L( "CTestModule::ConstructL - constructing server session done" ) ) );

    }

/*

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

    Class: CTestModule

    Method: CountResources

    Description: Resource counting

    Parameters: None

    Return Values: TInt                             Resource count

    Errors/Exceptions: None

    Status: Approved

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

*/

TInt CTestModule::CountResources()

    {

    return iResourceCount;

    }

/*

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

    Class: CTestModule

    Method: NumResources

    Description: Get resources, writes to Message()

    Parameters: None

    Return Values: None

    Errors/Exceptions: Panic client if result can't be written to descriptor.

    Status: Approved

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

*/

void CTestModule::NumResources( const RMessage2& aMessage )

    {

    TPckgBuf<TInt> countPckg( iResourceCount );

    TRAPD( r, aMessage.WriteL( 0, countPckg ) );

    if( r !=KErrNone )

        {

        PanicClient( EBadDescriptor, aMessage );

        }

    }

/*

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

    Class: CTestModule

    Method: PanicClient

    Description: Panic clients.

    Parameters: TInt aPanic                   :in:  Panic code

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

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

*/

void CTestModule::PanicClient( const TInt aPanic, const RMessage2& aMessage ) const

    {

    __TRACE( KError,( _L( "CTestModule::PanicClient code = %d" ), aPanic ) );

    _LIT( KTxtTestModule,"CTestModule" );

    aMessage.Panic( KTxtTestModule, aPanic );

    }

/*

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

    Class: CTestModule

    Method: CloseSession

    Description: Close session

    Parameters: None

    Return Values: TInt: Symbian error code.

    Errors/Exceptions: None

    Status: Approved

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

*/

TInt CTestModule::CloseSession( const RMessage2& aMessage )

    {

    __TRACE( KMessage,( _L( "CTestModule::CloseSession in" ) ) );

    // Delete all unclosed subsession handle before closing session.

    // Remove iTestExecutionHandle contents. iTestExecutionHandle countains

    // CTestExecution that handles test case have been created.

    if( iTestExecutionHandle )

        {

        TInt handle = 0;

        CObject* theObj = NULL;

        TInt count = iTestExecutionHandle->Count();

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

            {

            theObj=iTestExecutionHandle->operator[]( i );

            if( theObj )

                {

                handle=iTestExecutionHandle->At( theObj );

                // CTestExecution will panic if test case is ongoing!!! This

                // should be stopped, client should handle this.

                iTestExecutionHandle->Remove( handle );

                }

            }

        delete iTestExecutionHandle;

        iTestExecutionHandle = NULL;

        }

    // Deletion must be done here, because the "CloseSession" message is 

    // completed before execution continues from CActiveScheduler::Start 

    // location, and the main thread can continue execution 

    // and therefore shutdown itself and all threads in that process.

    // Delete the object container

    iTestServer->DeleteContainer( iContainer );

    // Free test case related data

    TInt r = FreeCaseData();

    // Delete all FREE Test Module instances

    iTestModuleInstances->ResetAndDestroy();

    delete iTestModuleInstances;

    iTestModuleInstances = NULL;

     // Inform server that session is closed

    iTestServer->SessionClosed();

	// Check for avoiding multiple complete, see CTestModule::ServiceL()

    if( r != KErrNone )

        {

		// In error cases do not complete, just return

        __TRACE( KMessage,( _L( "CTestModule::CloseSession out (1)" ) ) );

        return r;

        }

    aMessage.Complete( KErrNone );

    // After active scheduler shutdown is done, execution continues from

    // CTestServer::ThreadFunction()

    __TRACE( KMessage,( _L( "CTestModule::CloseSession out (2)" ) ) );

    return r;

    }

/*

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

    Class: CTestModule

    Method: ServiceL

    Description: Trap harness for dispatcher

    Parameters: const RMessage& aMessage  :inout:   Message

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CTestModule::ServiceL( const RMessage2& aMessage )

    {

    // NOTE! HW testing slows down dramatically if adds commants here

    //__TRACE( KMessage,( _L( "CTestModule::ServiceL in" ) ) );

    TInt r = KErrNone;

    TRAPD( ret, r = DispatchMessageL( aMessage ) );

    if ( ret != KErrNone )

        {

        // Complete message on leaving cases with leave code.

        __TRACE( KError, ( CStifLogger::ERed, _L( "CTestModule::DispatchMessageL leaved" ) ) );

        aMessage.Complete( ret );

        }

    // Complete message with error code originating from message handling

    // function.

    if ( r != KErrNone )

        {

        __TRACE( KError, ( CStifLogger::ERed, _L( "CTestModule::DispatchMessageL returned error" ) ) );

        aMessage.Complete( r );

        }

     // __TRACE( KMessage,( _L( "CTestModule::ServiceL out" ) ) );

    }

/*

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

    Class: CTestModule

    Method: DispatchMessageL

    Description: Dispatch message, calls corresponding function to do it.

    Parameters: const RMessage& aMessage  :inout:   Message to be handled

    Return Values: TInt                             Error code

    Errors/Exceptions: Leaves if operation handling function leaves

    Status: Proposal

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

*/

TInt CTestModule::DispatchMessageL( const RMessage2& aMessage )

    {

    __TRACE( KMessage,( _L( "CTestModule::DispatchMessageL %d" ),

        aMessage.Function()  ) );

    switch( aMessage.Function() )

    {

    // Session specific

    case ETestServerCloseSession:                // Close whole session

        {

		__TRACE( KError ,( _L( "Closing test module session" ) ) );

        return CloseSession( aMessage );

        }

    case ETestServerGetServerThreadId:           // Get Server ThreadId

        {

		__TRACE( KError ,( _L( "Return server thread id" ) ) );

        return GetServerThreadIdL( aMessage );

        }

    case ETestModuleCreateSubSession :           // Create new test module subsession

        {

		__TRACE( KError,( _L( "Creating test module session" ) ) );

        return CreateModuleSessionL( aMessage );

        }

    case ETestModuleCloseSubSession:             // Close module subsession

        {

        // Nothing to do.

        aMessage.Complete( KErrNone );

        return KErrNone;

        }

    case ETestExecutionCreateSubSession:         // Create new test execution subsession

        {

        return NewTestExecutionL( aMessage );

        }

    case ETestModuleEnumerateTestCases:          // Enumerate test cases

        {

		__TRACE( KError,( _L( "Enumerating test cases" ) ) );

        return EnumerateTestCasesL( aMessage );

        }

    case ETestModuleGetTestCases:                // Get test cases