/*

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

* class member functions. CTestExecution class handles a test 

* execution subsession specific operations.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32svr.h>

#include "TestEngineClient.h"

#include "StifTFwIfProt.h"

#include <stifinternal/TestServerClient.h>

#include "TestServer.h"

#include "TestServerModuleIf.h"

#include "TestServerCommon.h"

#include "PrintQueue.h"

#include "TestServerEvent.h"

#include "TestThreadContainer.h"

#include "STIFMeasurement.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

/*

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

    Class: CTestExecution

    Method: NewL

    Description: Returns new CTestExecution instance.

    Parameters: CTestModule* aModuleSession   :in:  "Parent" module

                TInt aCaseNumber              :in:  Test case number

                const TFileName& aConfig      :in:  Configuration filename

    Return Values: CTestExecution*                  New instance

    Errors/Exceptions: Function leaves if memory allocation fails or

                       CTestExecution construction leaves.

                       Panics is aModuleSession is NULL.

    Status: Proposal

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

*/

CTestExecution* CTestExecution::NewL( CTestModule* aModuleSession,

                                      TInt aCaseNumber, 

                                      const TFileName& aConfig )

    {

    __ASSERT_ALWAYS ( aModuleSession, 

                      CTestServer::PanicServer( ENullModuleSession ) );

    CTestExecution* self=new( ELeave ) CTestExecution;

    CleanupClosePushL( *self );

    self->ConstructL( aModuleSession, aCaseNumber, aConfig );

    CleanupStack::Pop();

    return self;

    }

/*

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

    Class: CTestExecution

    Method: CTestExecution

    Description: Constructor.

    Initialises member variables whose default state is not zero or NULL.

    Parameters:  None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CTestExecution::CTestExecution() : 

    iConfig( 0, 0 ),

    iTestThreadOpen( EFalse ),

    iTestThreadFailure( ETestThreadOk )

    {

    iPrintNotifyAvailable = EFalse;

    iThreadState = ENotStarted;

    iRemoteSendAvailable = EFalse;

    iRemoteReceiveAvailable = EFalse;

    iEventNotifyAvailable = EFalse;

    iCommandNotifyAvailable = EFalse;

    }

/*

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

    Class: CTestExecution

    Method: ~CTestExecution

    Description: Destructor

    Parameters: None

    Return Values: None

    Errors/Exceptions: Panics is threadmutex is taken.

    Status: Approved

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

*/

CTestExecution::~CTestExecution()

    {

    // Thread must be stopped before CTestExecution can be deleted

    if( iThreadState == EOnGoing ) 

		{

			if( iModuleContainer != NULL )

				{

				iModuleContainer->KillThread( KErrCancel );

				}

			delete iModuleContainer;

			iModuleContainer = NULL;

			CTestServer::PanicServer( EClosingWhileTestRunning );

		}

    delete iPrintHandler;

    iPrintHandler = NULL;

    delete iEventHandler;

    iEventHandler = NULL;

    delete iSndHandler;

    iSndHandler = NULL;

    delete iRcvHandler;

    iRcvHandler = NULL;

    delete iInterferenceHandler;

    iInterferenceHandler = NULL;

    delete iMeasurementHandler;

    iMeasurementHandler = NULL;

    delete iCommandHandler;

    iCommandHandler = NULL;

    // Test interference array(Needed cases when test interference thread is

    // needed to Kill())

    iSTIFTestInterferenceArray.Reset();

    iSTIFTestInterferenceArray.Close();

    // Reset test measurement array

    iMeasurementHandlingArray.Reset();

    iMeasurementHandlingArray.Close();

    // iPrintQueue must be emptied here, because it items are allocated from server heap

    delete iPrintQueue;

    iPrintQueue = NULL;

    // Delete name buffer

    delete iConfigNameBuffer;

    iConfigNameBuffer = NULL;

    delete iTestCaseArgs;

    iTestCaseArgs = NULL;

    iStateEvents.ResetAndDestroy();

    iStateEvents.Close();

    iEventArray.ResetAndDestroy();

    iEventArray.Close();

    // 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 mutex

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

    // Close semaphores

    if ( iPrintSem.Handle() != 0 ) iPrintSem.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();

    iMessageQueue.Close();

    iTestThread.Close();

    delete iCommandDef;

    iCommandDef = NULL;

    }

/*

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

    Class: CTestExecution

    Method: ConstructL

    Description: Second level constructor

    Parameters: CTestModule* aModuleSession   :in:  "Parent" module

                TInt aCaseNumber ::           :in:  Test case number

                const TFileName& aConfig      :in:  Configuration filename

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

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

*/

void CTestExecution::ConstructL( CTestModule *aModuleSession,

                                 TInt aCaseNumber,

                                 const TFileName& aConfig )

    {

    // Get the parameters

    iModuleSession = aModuleSession;

    iCaseNumber = aCaseNumber;

    // Construct heap buffer for configuration file

    iConfigNameBuffer = HBufC::NewL( aConfig.Length() );

    iConfig.Set ( iConfigNameBuffer->Des() );

    iConfig.Copy ( aConfig );

    // Create mutexes

    User::LeaveIfError( iPrintMutex.CreateLocal() );

    User::LeaveIfError( iEventMutex.CreateLocal() );

    User::LeaveIfError( iSndMutex.CreateLocal() );

    User::LeaveIfError( iRcvMutex.CreateLocal() );

    User::LeaveIfError( iInterferenceMutex.CreateLocal() );

    User::LeaveIfError( iMeasurementMutex.CreateLocal() );

    User::LeaveIfError( iCommandMutex.CreateLocal() );

    // Mutex for testcomplete and cancel operations. Create mutex

    User::LeaveIfError( iTestThreadMutex.CreateLocal() );

    // Create semaphores

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

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

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

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

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

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

    //User::LeaveIfError( iReceiverSem.CreateLocal( 0 ) );

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

    // Create handlers

    iPrintHandler = CPrintHandler::NewL( *this );

    iEventHandler = CEventHandler::NewL( *this );

    iSndHandler  = CSndHandler::NewL( *this );

    iRcvHandler  = CRcvHandler::NewL( *this );

    iInterferenceHandler = CInterferenceHandler::NewL( *this );

    iMeasurementHandler = CMeasurementHandler::NewL( *this );

    iCommandHandler = CCommandHandler::NewL( *this );

    // Create print queue

    iPrintQueue = CPrintQueue::NewL();

    // Start print handler   

    iPrintHandler->StartL();

    // Start rcv handler

    iRcvHandler->StartL();

    // Start interference handler

    iInterferenceHandler->StartL();

    // Start measurement handler

    iMeasurementHandler->StartL();

    iCommandDef = CCommandDef::NewL();

    }

/*

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

    Class: CTestExecution

    Method: RunTestCase

    Description: Starts to execute test case in separate thread.

    Parameters: const RMessage& aMessage  :in:      Message from client.

    Return Values: TInt                             Error code

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CTestExecution::RunTestCase( const RMessage2& aMessage )

    {

    __TRACE ( KInit, ( _L( "CTestExecution::RunTestCase in" ) ) );

    TInt ret = KErrNone;

    // Store message to be completed when case is finished

    iTestExeMessage = aMessage;

    iFullResult.iStartTime.HomeTime();

    delete iTestCaseArgs;

    iTestCaseArgs = NULL;

    TInt testCaseArgsLength = iTestExeMessage.GetDesLength( 1 );

    if ( ( testCaseArgsLength != KErrArgument ) && ( testCaseArgsLength != KErrBadDescriptor ) )

        {

        iTestCaseArgs = HBufC::New( testCaseArgsLength );

        if ( iTestCaseArgs == NULL )

            {

            _LIT(KRunError,"Can't allocate memory for test case arguments");

            __TRACE ( KError, ( CStifLogger::ERed, KRunError() ) );

            CompleteTestExecution( KErrNone,

                                   TFullTestResult::ECaseException,

                                   KErrNoMemory,

                                   KErrGeneral,

                                   KRunError );

            return KErrNone;        

            }

        TPtr testCaseArgsPtr( iTestCaseArgs->Des() );

        TRAP( ret, iTestExeMessage.Read( 1, testCaseArgsPtr ) );

        if ( ret != KErrNone )

            {

            _LIT(KRunError,"Can't read test case arguments");

            __TRACE ( KError, ( CStifLogger::ERed, KRunError() ) );

            CompleteTestExecution( KErrNone,

                                   TFullTestResult::ECaseException,

                                   ret,

                                   KErrGeneral,

                                   KRunError );

            return KErrNone;

            }

        }

    // Get a test module, which executes the test case.

    // The test module will be freed either when the test case

    // completes, or the test case is aborted.

    ret = iModuleSession->GetTestModule( iModuleContainer, iConfig );

    if ( ret != KErrNone || iModuleContainer == NULL )

        {

        _LIT(KRunError,"Can't get test module");

        __TRACE ( KError, ( CStifLogger::ERed, KRunError() ) );

        CompleteTestExecution( KErrNone,

                               TFullTestResult::ECaseException,

                               ret,

                               KErrGeneral,

                               KRunError );

        return KErrNone;

        }

    // Thread is created, so all thread specific operations are possible, 

    // even if thread is not yet resumed, so mark thread to be "Running"

    SetThreadState ( EOnGoing );

    // Start the test

    iModuleContainer->SetExecutionSubSession( this );

    iModuleContainer->RunTestCase( iConfig, iCaseNumber, aMessage );

    __TRACE ( KRunTestCase, ( _L( "CTestExecution::RunTestCase out. Case ongoing" ) ) );

    return KErrNone;

    }

/*

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

    Class: CTestExecution

    Method: NotifyPrint

    Description: Handles print request from engine. If print queue is empty,

                 message is stored to be used later when there is something to

                 print, otherwise the first queue item is returned and request

                 completes immediately.

    Parameters: const RMessage& aMessage      :in:  Message from client.

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CTestExecution::NotifyPrint( const RMessage2& aMessage )

    {

    __ASSERT_ALWAYS( iPrintNotifyAvailable == EFalse, 

                     CTestServer::PanicServer( EPrintQueueBroken ) );

    // Get first item from queue

    TPrintQueueItem *item = iPrintQueue->Pop();

    if ( item == NULL )

        {

        // If thread can't print anymore, and queue is empty, then 

        // complete with Eof, because there will not be any new prints

        if ( iThreadState == EFinished || iThreadState == ECancelled )

            {

            __TRACE ( KPrint, ( _L( "CTestExecution::NotifyPrint to finished thread" ) ) );

            aMessage.Complete ( KErrEof );

            }

        else

            {

            // Print request available, do not complete request

            iNotifyPrintMessage = aMessage;

            iPrintNotifyAvailable = ETrue;

            }

        }

    else

        {

        // Construct message

        TTestProgress progress;

        progress.iPosition = item->iPriority;

        progress.iDescription = item->iData1;

        progress.iText = item->iData2;

        iNotifyPrintMessage = aMessage;

        // Write message to client space and complete request

        WritePrint( progress );

        delete item; 

        }

    return KErrNone;

    }

/*

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

    Class: CTestExecution

    Method: DoNotifyPrint

    Description: If print notification available, notification is copied to

                    client memory space and request is completed.

                 Else new print queue item is created and appended to print 

                    queue. If queue is full or memory can't be allocated,

                    then message will be discarded.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CTestExecution::DoNotifyPrint()

    {    

    if ( iPrintNotifyAvailable )

        {

        // Write message to client space

        WritePrint( iProgress );

        }

    else

        {

        TPrintQueueItem *item = 

            new TPrintQueueItem( iProgress.iPosition, 

                                 iProgress.iDescription, 

                                 iProgress.iText );

        if ( item != NULL )

            {

            // Item constructed ok, add it to queue

            if ( iPrintQueue->Push( *item ) != KErrNone )

                { 

                // Queue is full, clean-up