diff -r 7fdc9a71d314 -r 8ad140f3dd41 stif/TestServer/src/Testexecution.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/stif/TestServer/src/Testexecution.cpp	Wed Oct 13 16:17:58 2010 +0300
@@ -0,0 +1,4821 @@
+/*
+* 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
+                delete item;
+                }
+            }
+        // else: Could not construct TPrintQueueItem, no free memory.
+        // drop printing            
+        }
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: DoNotifyInterference
+
+    Description: Handles Test Interference thread append and remove operations.
+        
+    Parameters: None
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::DoNotifyInterference()
+    {    
+    // Information for this context => information is in this thread's heap and
+    // if CUndertaker::RunL is called then test interface thread can called
+    // with function call and kill() test interference thread
+
+    // Take information from struct given in 
+    // CTestThreadContainer::AddInterferenceThread or
+    // CTestThreadContainer::RemoveInterferenceThread
+    
+    RThread thread;
+    TInt ret = thread.Open ( iTestInterference.iThreadId );
+    if( ret != KErrNone )
+    	{
+    	RDebug::Print( _L("CTestExecution::DoNotifyInterference %d"), ret );
+        User::Panic( _L("CTestExecution::DoNotifyInterference"), ret );
+    	}
+    
+    if ( iTestInterference.iOperation == TTestInterference::EAppend )
+        {
+        iSTIFTestInterferenceArray.Append( thread );
+        }
+    else if (iTestInterference.iOperation == TTestInterference::ERemove )
+        {
+        // Remove thread from Array.Test interference thread is stopped and killed
+        // successfully
+        for( TInt i = 0; i < iSTIFTestInterferenceArray.Count(); i++ )
+            {
+            if( iSTIFTestInterferenceArray[i].Id() == thread.Id() )
+                {
+                iSTIFTestInterferenceArray.Remove( i );
+                break;
+                }
+            }
+        }
+    else
+        {
+        return;
+        }
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: DoNotifyMeasurement
+
+    Description: Handles test measurement operations: NewL, Start and Stop.
+        
+    Parameters: None
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Approved
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::DoNotifyMeasurement()
+    {    
+    // Information for this context => information is in this thread's heap:
+    // From CUndertaker::RunL() or CTestModuleContainer::RunL() method can
+    // handle stop and clean operations if these operations are not done 
+    // before.
+    // Erronous cases(CUndertaker::RunL will be called) or when test case is
+    // executed(CTestModuleContainer::RunL() will be called) there can handle
+    // test measurement stop and clean operation. 
+
+    if( iTestMeasurement.iMeasurementStruct.iMeasurementOperation == 
+                                        CSTIFTestMeasurement::KMeasurementNew)
+        {
+        // Check that same measurement module don't try to create several times
+        // Only one measurement type per test is allowed
+        for( TInt i = 0; i < iMeasurementHandlingArray.Count(); i++ )
+            {
+            if( iMeasurementHandlingArray[i]->iMeasurementModulePtr->MeasurementType() ==
+                        iTestMeasurement.iMeasurementStruct.iMeasurementType )
+                {
+                return KErrAlreadyExists;
+                }
+            }
+
+        TMeasurementHandling* measurementHandling = NULL;
+        measurementHandling = new TMeasurementHandling();
+
+        TBuf<KStifMeasurementTypeLength> modulename;
+        if( iTestMeasurement.iMeasurementStruct.iMeasurementType == 1 )
+            {
+            modulename.Copy( KStifMeasurement01 );
+            }
+        else if( iTestMeasurement.iMeasurementStruct.iMeasurementType == 2 )
+            {
+            modulename.Copy( KStifMeasurement02 );
+            }
+        else if( iTestMeasurement.iMeasurementStruct.iMeasurementType == 3 )
+            {
+            modulename.Copy( KStifMeasurement03 );
+            }
+        else if( iTestMeasurement.iMeasurementStruct.iMeasurementType == 4 )
+            {
+            modulename.Copy( KStifMeasurement04 );
+            }
+        else if( iTestMeasurement.iMeasurementStruct.iMeasurementType == 5 )
+            {
+            modulename.Copy( KStifMeasurement05 );
+            }
+        else if( iTestMeasurement.iMeasurementStruct.iMeasurementType == 6 )
+            {
+            modulename.Copy( KStifMeasurementBappea );
+            }
+        else
+            {
+            __TRACE( KError, (  _L("CTestExecution::DoNotifyMeasurement(): unknown measurement type" ) ) );
+            return KErrArgument;
+            }
+
+        // Loading should work with and without '.dll' extension.
+        TInt r = measurementHandling->iMeasurementModule.Load( modulename );
+        if ( r != KErrNone )
+            {
+            __TRACE( KError, ( CStifLogger::EError, _L("Can't load test measurement module[%S], code = %d"),
+                &modulename, r ) );
+            delete measurementHandling;
+            return KErrNotFound;
+            }
+        else
+            {
+            //Print test measururement module name
+            __TRACE( KInit, (  _L("Loaded test measurement module[%S]"),
+                &modulename ) );
+            }
+
+        // Get pointer to first exported function
+        // Verify that there is function
+        measurementHandling->iMeasurementLibEntry = (CTestMeasurementFactory) measurementHandling->iMeasurementModule.Lookup( 1 );
+        if ( measurementHandling->iMeasurementLibEntry == NULL )
+            {
+            // New instance can't be created
+            __TRACE( KInit, (_L( "Test measurement module instance cannot create." ) ) );
+            measurementHandling->iMeasurementModule.Close();
+            delete measurementHandling;
+            return KErrNotFound;
+            }
+        else
+            {
+            __TRACE ( KInit, ( _L("Pointer to 1st exported received")));
+            }
+
+        CSTIFTestMeasurementImplementation* measurement;
+        measurement = NULL;
+
+        // initialize test measurement module
+        __TRACE ( KVerbose, (_L("Calling 1st exported at 0x%x"), (TUint32) measurementHandling->iMeasurementLibEntry ));
+        TRAPD ( err, measurement = (*measurementHandling->iMeasurementLibEntry)( 
+                            iTestMeasurement.iMeasurementStruct.iConfigurationInfo, iTestMeasurement.iMeasurementStruct.iMeasurementType ) );
+
+         // Handle leave from test module
+        if ( err != KErrNone )
+            {
+            __TRACE (KError, ( CStifLogger::EError, _L( "Leave when calling 1st exported function, code %d"), err ) );
+            delete measurementHandling;
+            return err;
+            }
+        else if ( measurementHandling->iMeasurementLibEntry == NULL )     // Handle NULL from test measurement
+            {
+            __TRACE (KError, ( CStifLogger::EError, _L( "NULL pointer received when constructing test measurement module" ) ) );
+            delete measurementHandling;
+            // Set error codes
+            return KErrNoMemory;
+            }
+        else
+            {
+            measurementHandling->iMeasurementModulePtr = measurement;
+            __TRACE (KInit, (_L("Entrypoint successfully called, Measurement module instance at 0x%x"),
+                (TUint32)measurementHandling->iMeasurementLibEntry ) );
+            }
+        iMeasurementHandlingArray.Append( measurementHandling );
+        } // End of NewL operations
+
+    else if( iTestMeasurement.iMeasurementStruct.iMeasurementOperation == 
+                                        CSTIFTestMeasurement::KMeasurementStart)
+        {
+        for( TInt i = 0; i < iMeasurementHandlingArray.Count(); i++ )
+            {
+            if( iMeasurementHandlingArray[i]->iMeasurementModulePtr->MeasurementType() == iTestMeasurement.iMeasurementStruct.iMeasurementType )
+                {
+                return iMeasurementHandlingArray[i]->iMeasurementModulePtr->Start();
+                }
+            }
+
+        }
+    else if( iTestMeasurement.iMeasurementStruct.iMeasurementOperation == 
+                                        CSTIFTestMeasurement::KMeasurementStop)
+        {
+        for( TInt i = 0; i < iMeasurementHandlingArray.Count(); i++ )
+            {
+            if( iMeasurementHandlingArray[i]->iMeasurementModulePtr->MeasurementType() == iTestMeasurement.iMeasurementStruct.iMeasurementType )
+                {
+                TInt stop_ret = iMeasurementHandlingArray[i]->iMeasurementModulePtr->Stop();
+                delete iMeasurementHandlingArray[i];
+                iMeasurementHandlingArray.Remove(i);
+                return stop_ret;
+                }
+            }
+        }
+    else 
+        {
+        __TRACE (KError, ( CStifLogger::EError, _L("CTestExecution::DoNotifyMeasurement(): Not supported operation") ) );
+        return KErrNotSupported;
+        }
+    
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: WritePrint
+
+    Description: Writes print notification to client memory space.                 
+        
+    Parameters: const TInt aPriority          :in:  Priority
+                const TStifInfoName& aDes         :in:  Description
+                const TName& aBuffer          :in:  Value
+    
+    Return Values: TInt                             Return value from message write
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::WritePrint( TTestProgress& aProgress )
+    {
+
+    TTestProgressPckg progressPckg( aProgress );
+ 
+    // Write message to client space    
+    TRAPD( res, iNotifyPrintMessage.WriteL( 0, progressPckg ) );
+
+    iPrintNotifyAvailable = EFalse;
+
+    // Complete request with possible error code
+    iNotifyPrintMessage.Complete( res );
+
+    return res;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: NotifyEvent
+
+    Description: Handles event request from engine. 
+
+    ESetEvent and EUnsetEvent change event status. EEnable enables 
+    event notify.
+
+    Parameters: const RMessage& aMessage      :in:  Message from client.
+                    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::NotifyEvent( const RMessage2& aMessage )
+    {   
+
+    TEventIf event;
+    TEventIfPckg eventPckg( event );
+    
+    TRAPD( res, aMessage.ReadL( 0, eventPckg ) );
+
+    if( res != KErrNone )
+        {
+        __TRACE( KError, ( _L( "CTestExecution::NotifyEvent: ReadL failed" ) ));
+        return res;
+        }
+    
+    switch( event.Type() )
+        {
+        case TEventIf::ESetEvent: 
+            {
+            TInt ind = 0;
+            TInt count = iEventArray.Count();
+            for( ind=0; ind < count; ind++ )
+                {
+                if( iEventArray[ind]->Name() == event.Name() )
+                    {
+                    __TRACE( KMessage, ( _L( "CTestExecution::NotifyEvent(%d): SetEvent %S ( count %i )" ), 
+                        this, &event.Name(), count ) );
+                    TEventIf::TEventType etype = TEventIf::EIndication;
+                    // To get state events working with testcombiner
+                    if( ( event.EventType() == TEventIf::EState ) ||                            
+                        ( iEventArray[ind]->EventType() == TEventIf::EState ) )
+                        {
+                        etype = TEventIf::EState;
+                        }
+                    iEventArray[ind]->Set( etype );
+                    }
+                }
+            }
+            break;
+        case TEventIf::EUnsetEvent:
+            { 
+            return UnsetEvent( event, aMessage );
+            }
+        case TEventIf::EEnable:
+            {
+            // Store event message
+            iNotifyEventMessage = aMessage;
+            iEventNotifyAvailable = ETrue;
+            TInt errorFromPreviousCmd =  aMessage.Int1();
+
+            __TRACE( KMessage, ( _L( "CTestExecution::NotifyEvent: enable (%d) notify %d" ), 
+                errorFromPreviousCmd, this ) );
+
+            // Complete previous Event command
+            CompleteEvent( errorFromPreviousCmd );    
+            iEventHandler->StartL();
+            
+            // iNotifyEventMessage is completed from DoNotifyEvent
+            return KErrNone; 
+            }
+        
+        default:
+            __TRACE( KError, ( _L( "CTestExecution::NotifyEvent: Unknown command %i" ), 
+                event.Type() ));
+            return KErrArgument;
+        }
+
+    __TRACE( KMessage, ( _L( "CTestExecution::NotifyEvent(%d): Done" ), this ) );
+
+    aMessage.Complete( KErrNone );
+    //User::After(1000); //Stif-95 This pause is needed to let Info::TestFrameworkEngine thread
+                       //get some processor time and run exactly at this moment (by calling
+                       //CTestEventController::EventCallBack). When Stif is focused on the screen,
+                       //there is no problem if this line is absent, however when another
+                       //application (like screen saver) is focused this is required.
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: DoNotifyEvent
+
+    Description: Forward event request.
+        
+    Parameters: None
+   
+    Return Values: None
+
+    Errors/Exceptions: Panics if event array can't be created
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::DoNotifyEvent()
+    {
+    
+    TInt ret = KErrNone;
+        
+    switch( iEventDef.iEvent.Type() )
+        {
+        case TEventIf::EReqEvent:
+            {
+            __TRACE( KMessage, 
+                ( _L( "CTestExecution::DoNotifyEvent(%d): ReqEvent %S" ), 
+                    this, &iEventDef.iEvent.Name() ) );
+            ret = RequestEvent( iEventDef.iEvent );
+            // If error, return error, 
+            // otherwise proceed with sending information to engine
+            if( ret != KErrNone )
+                {
+                iEventHandler->StartL();
+                return ret;
+                }
+            }
+            break;
+        case TEventIf::EWaitEvent:
+        case TEventIf::ESetWaitPending:
+            {
+            __TRACE( KMessage, 
+                ( _L( "CTestExecution::DoNotifyEvent(%d): WaitEvent %S" ), 
+                    this, &iEventDef.iEvent.Name() ) );
+            // We return from here, i.e. nothing is sent to engine
+            ret = WaitEvent( iEventDef.iEvent, iEventDef.iStatus );
+            iEventHandler->StartL();
+            return ret;
+            }
+        // Add state events to internal array  
+        case TEventIf::ESetEvent: 
+        case TEventIf::EUnsetEvent:
+            {
+            __TRACE( KMessage, 
+                ( _L( "CTestExecution::DoNotifyEvent(%d): Set/UnsetEvent %S" ), 
+                    this, &iEventDef.iEvent.Name() ) );
+            EventStateChange( iEventDef.iEvent );
+            }
+            break;
+        case TEventIf::ERelEvent:
+            // This is handled later
+            __TRACE( KMessage, 
+                ( _L( "CTestExecution::DoNotifyEvent(%d): RelEvent %S" ), 
+                    this, &iEventDef.iEvent.Name() ) );
+            break;
+        default:
+            iEventHandler->StartL();
+            return KErrArgument;
+        }
+    
+    // Construct message
+    TEventIfPckg eventPckg( iEventDef.iEvent );
+
+    // Write message to client space
+    TRAPD( res, iNotifyEventMessage.WriteL( 0, eventPckg ) );
+
+    if( res != KErrNone )
+        {
+        __TRACE( KError, ( _L( "CTestExecution::DoNotifyEvent: WriteL failed" ) ) );
+        ret = res;
+        }
+    // Complete request
+    // Complete with WriteL result
+    // MUST be done before ERelEvent
+    iEventNotifyAvailable = EFalse;
+    iNotifyEventMessage.Complete( res );
+    User::After(1000); //Stif-95 This pause is needed to let Info::TestFrameworkEngine thread
+                       //get some processor time and run exactly at this moment (by calling
+                       //CTestEventNotifier::RunL). When Stif is focused on the screen,
+                       //there is no problem if this line is absent, however when another
+                       //application (like screen saver) is focused this is required.
+
+    if( iEventDef.iEvent.Type() == TEventIf::ERelEvent )
+        {
+        ret = ReleaseEvent( iEventDef.iEvent );
+        if( ret != KErrNone )
+            {
+            // If error, return immediately
+            return ret;
+            }
+        }
+
+    __TRACE( KMessage, ( _L( "CTestExecution::DoNotifyEvent(%d): Done" ), this ) );
+
+    return ret;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: RequestEvent
+
+    Description: Handles TestModule event requests. 
+        
+    Parameters: const TEventIf& aEvent: in: Event requested  
+    
+    Return Values: TInt: Success/Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/    
+TInt CTestExecution::RequestEvent( TEventIf& aEvent )
+    {
+
+    // Requested events are added to iEventArray
+    // There can be multiple simultaneous requests for the same event                    
+    TEvent* event = new TEvent( iTestThreadId );    
+    if( !event )
+        {
+        return KErrNoMemory;
+        }
+    event->Copy( aEvent );
+    if( iEventArray.Append( event ) != KErrNone )
+        {
+        delete event;
+        return KErrNoMemory;
+        }
+        
+    __TRACE( KMessage,( _L( "CTestExecution::DoNotifyEvent: Req added %S ( count %i )" ), 
+         &aEvent.Name(), iEventArray.Count() ));
+    
+    return KErrNone;
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: WaitEvent
+
+    Description: Handles TestModule event waits. Waiting is implemented here 
+                and completed in NotifyEvent    
+
+        
+    Parameters: const TEventIf& aEvent: in: Event wait  
+    
+    Return Values: TInt: Success/Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/    
+TInt CTestExecution::WaitEvent( TEventIf& aEvent, TRequestStatus* aStatus )
+    {
+      
+    // Get first "free" event entry from requested events
+    TInt ind = 0;
+    TInt count = iEventArray.Count();
+    TEvent* event = NULL;
+    for( ind=0; ind < count; ind++ )
+        {
+        if( ( iEventArray[ind]->Name() == aEvent.Name() ) &&
+            ( iEventArray[ind]->WaitEventPending() == EFalse ) )
+            {
+            // Found event with correct name and one that is still free
+            // i.e. nobody is waiting for it.
+            event = iEventArray[ind];
+            if( aEvent.Type() == TEventIf::EWaitEvent )
+                {
+                // For EWaitEvent we complete immediately if event is pending
+                if( event->EventPending() )
+                    {
+                    // Event was already pending, so we may return immediately
+                    if( aStatus )
+                        {
+                        TestThreadRequestComplete( aStatus, KErrNone );
+                        }
+                    return KErrNone;           
+                    }
+                }
+            }
+        }
+    if( event == NULL )
+        {
+        // Event is not in the iEventArray, 
+        // so event is not currently requested
+        return KErrNotFound;
+        }
+        
+    __TRACE( KMessage,( _L( "CTestExecution::DoNotifyEvent: Waiting %S ( count %i )" ), 
+        &aEvent.Name(), count ));
+    
+    // Event is not pending so we have to wait for it
+    // Set wait pending            
+    TInt ret = event->SetWaitPending( aStatus );
+    // event cannot be freed by the test module, 
+    // because it is waiting the event, 
+
+    if( ( aStatus == NULL ) &&
+        ( ret == KErrNone ) &&
+        ( aEvent.Type() == TEventIf::EWaitEvent ) ) 
+        {
+        // This is synchronous wait
+        // Go waiting, completed from set event            
+        event->Wait();
+        }
+
+    return ret;
+    
+    } 
+    
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: ReleaseEvent
+
+    Description: Handles TestModule event releases. 
+        
+    Parameters: const TEventIf& aEvent: in: Event released  
+    
+    Return Values: TInt: Success/Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/   
+TInt CTestExecution::ReleaseEvent( TEventIf& aEvent )
+    {
+    
+    // Get last event entry from requested events
+    TInt ind = 0;
+    TInt freeFound = 0;
+    TInt eventIndex = 0;
+    TInt count = iEventArray.Count();
+    for( ind=0; ind < count; ind++ )
+        {
+        if( iEventArray[ind]->Name() == aEvent.Name() )
+            {
+            if( iEventArray[ind]->WaitEventPending() == EFalse )
+                {
+                freeFound++;
+                eventIndex = ind;
+                }
+            }
+        }
+
+    if( freeFound == 0 )
+        {
+        return KErrNotFound;
+        }
+    __TRACE( KMessage,( 
+        _L( "CTestExecution::DoNotifyEvent: Release event %S ( count %i )" ), 
+            &aEvent.Name(), iEventArray.Count() ));
+
+    TEvent* event = iEventArray[eventIndex];
+    iEventArray.Remove( eventIndex );
+    // Release and free event entry
+    event->Release(); 
+
+    // Delete used event entry
+    delete event;
+    
+    return KErrNone;
+}
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: UnsetEvent
+
+    Description: Handles TestModule event unsets. 
+        
+    Parameters: const TEventIf& aEvent: in: Event unset  
+    
+    Return Values: TInt: Success/Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::UnsetEvent( TEventIf& aEvent, const RMessage2& aMessage )
+    {
+    
+    TInt ret = KErrNone;
+    TInt ind = 0;
+    TInt count = iEventArray.Count();
+    TBool activeEventReq = EFalse;
+    for( ind=0; ind < count; ind++ )
+        {
+        if( iEventArray[ind]->Name() == aEvent.Name() )
+            {
+             __TRACE( KMessage, ( 
+                _L( "CTestExecution::NotifyEvent(%d): UnsetEvent %S ( count %i )" ), 
+                this, &aEvent.Name(), count ) );
+                
+            ret = iEventArray[ind]->Unset( aMessage, this );
+            if( ret == KErrNone )
+                {
+                activeEventReq = ETrue;
+                }
+            break;
+            }
+        }
+    if( activeEventReq )
+        {
+        // Unset is completed by release   
+        return KErrNone;
+        }
+        
+    // No pending requests or error from unset
+    aMessage.Complete( ret );
+    
+    return KErrNone;
+    
+    }
+    
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: EventStateChange
+
+    Description: Handles event setting and unsetting. Saves status of
+                state events to enable unsetting of set state events when 
+                killing the testcase abnormally.
+        
+    Parameters: const TEventIf& aEvent: in: Event set/unset  
+    
+    Return Values: TInt: Success/Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/   
+TInt CTestExecution::EventStateChange( TEventIf& aEvent )
+    {
+    
+    TInt ret = KErrNotFound;
+    if( aEvent.EventType() == TEventIf::EState )
+        {
+        
+        TInt count = iStateEvents.Count();
+        TInt index = 0;
+        for(; index < count; index++ )   
+            {
+            TPtrC name = *(iStateEvents[index]);
+            if( name == aEvent.Name() )
+                {
+                break;
+                }
+            } 
+            
+                
+        if( aEvent.Type() == TEventIf::ESetEvent )
+            {
+            if( index < count )
+                {
+                ret = KErrAlreadyExists;
+                }
+            else
+                {
+                // add event to iStateEvents
+                HBufC* name = aEvent.Name().Alloc();
+                if( name == NULL )
+                    {
+                    ret = KErrNoMemory;
+                    }
+                else if( iStateEvents.Append( name ) != KErrNone )
+                    {
+                    delete name;
+                    ret = KErrNoMemory;
+                    }
+                else
+                    {
+                    ret = KErrNone;
+                    }
+                }                
+            }
+        else if( aEvent.Type() == TEventIf::EUnsetEvent )
+            {
+            if( index == count )
+                {
+                ret = KErrNotFound;
+                }
+            else
+                {
+                ret = KErrNone;
+                delete iStateEvents[index];
+                iStateEvents.Remove( index );
+                }
+            }
+        }
+    
+    return ret;
+    
+    }
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelEvent
+
+    Description: Cancels pending event request.
+        
+    Parameters: None
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+    
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::CancelEvent()
+    {
+    
+    TInt ret = KErrNotFound;
+
+    __TRACE( KMessage, ( _L( "CTestThreadContainer::CancelEvent(%d): %S [%p]" ), 
+            iEventDef.iEvent.Type(), &iEventDef.iEvent.Name(), iEventDef.iStatus ) );
+
+    switch( iEventDef.iEvent.Type() )
+        {
+        case TEventIf::EReqEvent:
+        case TEventIf::ERelEvent:
+        case TEventIf::ESetEvent:
+        case TEventIf::EUnsetEvent:   
+            CompleteEvent( KErrCancel );  
+            break;
+        case TEventIf::EWaitEvent:
+        case TEventIf::ESetWaitPending:
+            {
+            // Get waited event entry from requested events
+            TInt ind = 0;
+            TInt count = iEventArray.Count();
+            for( ind=0; ind < count; ind++ )
+                {
+                if( ( iEventArray[ind]->Name() == iEventDef.iEvent.Name() ) &&
+                    ( iEventArray[ind]->WaitEventPending() != EFalse ) &&
+                    ( iEventArray[ind]->RequestStatus() == iEventDef.iStatus ) )
+                    {
+                    TEvent* event = iEventArray[ind];
+                    // Found event with correct name and one that is waited.
+                    event->CompletePendingWait( KErrCancel ); 
+                    ret = KErrNone;
+                    break;
+                    }
+                }
+            if( ret != KErrNone )
+                {
+                // Request has been already completed, not handled 
+                // by ActiveScheduler yet.
+                // DoCancel will do the job, don't worry.
+                __TRACE( KError, ( _L( "CTestThreadContainer::CancelEvent(%d): %S, not found 2" ), 
+                    iEventDef.iEvent.Type(), &iEventDef.iEvent.Name() ) ); 
+                }
+            }
+            break;
+        default:
+            CTestServer::PanicServer( EUnknownEventCmd );
+            break;
+        }
+        
+    // Synchonize
+    iEventHandler->StartL();
+        
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: NotifyRemoteCmd
+
+    Description: Handles the first phase of the RemoteCmd request from engine.
+
+    Parameters: const RMessage& aMessage: in: Message from client.
+                    
+    Return Values: Symbian OS error code.
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::NotifyRemoteCmd( const RMessage2& aMessage )
+    {   
+
+    // Store RemoteCmd message
+    // and the length buffer address
+    iNotifyRemoteCmdMessage = aMessage;
+    iRemoteSendAvailable = ETrue;
+    iSndHandler->StartL();
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: DoRemoteReceive
+
+    Description: Enable remote receive.
+    
+    Parameters: None 
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::DoRemoteReceive()
+    {    
+
+    switch( iRcvCmdDef.iCommand )
+        {
+        case EStifCmdReceive:          // "Receive"
+            {
+            // @js If there's pointer in array, we'll send it down
+            if(iMessageQueue.Count() > 0)
+                {
+                HBufC8 * buf =  iMessageQueue[0];
+                iRcvCmdDef.iParam.aRemoteMsgRef->Copy( iMessageQueue[0]->Des() );
+                iMessageQueue.Remove(0);
+                delete buf; 
+                __TRACE( KMessage, 
+                        (_L("CTestExecution::ReadRemoteCmdInfo: complete receive 0x%x"), 
+                            iRcvCmdDef.iStatus ));
+                       
+                 // calls the TestCombiner's CRemoteReceiver::RunL()
+                 TestThreadRequestComplete( iRcvCmdDef.iStatus, KErrNone );
+                }
+            else
+                {
+                iRemoteReceiveAvailable = ETrue;            
+                }
+
+            break;
+            }
+        case EStifCmdReceiveCancel:
+            if( iRemoteReceiveAvailable )
+                {
+                iRemoteReceiveAvailable = EFalse;
+                TestThreadRequestComplete( iRcvCmdDef.iStatus, KErrCancel );
+                }                
+            break;
+        default:
+            CTestServer::PanicServer( EUnknownRemoteCmd );
+            break;
+        }
+    // Signal test thread
+    iRcvHandler->StartL();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: DoRemoteSend
+
+    Description: Send remote messages.
+    
+    Parameters: None 
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Approved
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::DoRemoteSend()
+    {  
+    switch( iCmdDef.iCommand )
+        {  
+        case EStifCmdSend:             // "Send"
+        case EStifCmdReboot:           // "Send"
+        case EStifCmdStoreState:       // "Send"
+        case EStifCmdGetStoredState:   // "Receive, this must be done with two phase"
+        case EStifCmdMeasurement:      // "Receive, this must be done with two phase"
+            {
+            if( iRemoteSendAvailable )
+                {
+                TInt ret = KErrNone;
+                TPckg<TStifCommand> remoteCommandPckg( iCmdDef.iCommand );
+
+                // Start first phase of the writing message to client space
+                TRAP( ret, 
+                    iNotifyRemoteCmdMessage.WriteL( 0, remoteCommandPckg ) );
+
+                if( ret != KErrNone )
+                    {
+                    __TRACE( KError, ( _L( "CTestExecution::DoRemoteSend: WriteL failed" ) ) );
+                    }
+                TPckg<TInt> lenPckg( iCmdDef.iLen );
+
+                TRAP( ret, 
+                    iNotifyRemoteCmdMessage.WriteL( 1, lenPckg ) );
+
+                if( ret != KErrNone )
+                    {
+                    __TRACE( KError, ( _L( "CTestExecution::DoRemoteSend: WriteL failed" ) ) );
+                    }
+
+                // Complete request
+                // Complete with WriteL result
+                // CTestRemoteCmdNotifier::RunL() will called
+                iRemoteSendAvailable = EFalse;
+                iNotifyRemoteCmdMessage.Complete( ret );
+                break;
+                }
+            }
+            TestThreadRequestComplete( iCmdDef.iStatus, KErrNotSupported );
+            break;
+        default:
+            CTestServer::PanicServer( EUnknownRemoteCmd );
+            break;
+        }
+
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: ReadRemoteCmdInfo
+
+    Description: Handles the second phase of the RemoteCmd request from engine.
+
+    Parameters: const RMessage& aMessage: in: Message from client.
+                    
+    Return Values: Symbian OS error code.
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::ReadRemoteCmdInfo( const RMessage2& aMessage )
+    {   
+    
+    TInt ret( KErrNone );
+    TInt completeSend = EFalse;
+    TInt returnedErrorCode = KErrNone;
+    TInt len = 0;
+    TInt value( aMessage.Int2() );
+    if( value < 0 )
+        {
+        returnedErrorCode = value;
+        }
+    else
+        {
+        len = value;
+        }
+  
+    switch( aMessage.Int1() )
+        {
+        case EStifCmdReceive:              // "Receive"
+            {
+
+                if( len <= 0 )
+                    {
+                    __TRACE( KError, 
+                        (_L("CTestExecution::ReadRemoteCmdInfo: empty message")));
+                    ret = KErrGeneral;
+                    break;
+                    }
+                if( iRcvCmdDef.iParam.aRemoteMsgRef->MaxLength() < len )
+                    {
+                    __TRACE( KError, 
+                        (_L("CTestExecution::ReadRemoteCmdInfo: message overflow")));
+                    ret = KErrGeneral;
+                    break;
+                    }
+
+                HBufC8* buf = HBufC8::New( len );
+                if( buf == NULL )
+                    { 
+                    ret = KErrNoMemory;
+                    break;
+                    }
+                TPtr8 tmp = buf->Des();
+                // Read message from client space
+                TRAP( ret, aMessage.ReadL( 0, tmp ) );
+
+                
+                if( ret != KErrNone )
+                    {
+                    __TRACE( KError, 
+                        (_L("CTestExecution::ReadRemoteCmdInfo: ReadL failed")));
+                    break;
+                    }
+                    
+                if( iRemoteReceiveAvailable )
+                // @js Checking moved here
+                    {                                   
+                    iRcvCmdDef.iParam.aRemoteMsgRef->Copy( buf->Des() );
+                    delete buf;
+                
+                    __TRACE( KMessage, 
+                        (_L("CTestExecution::ReadRemoteCmdInfo: complete receive 0x%x"), 
+                            iRcvCmdDef.iStatus ));
+                    // calls the TestCombiner's CRemoteReceiver::RunL()
+                    TestThreadRequestComplete( iRcvCmdDef.iStatus, ret );
+                    
+                    iRemoteReceiveAvailable = EFalse;
+                    }
+                else
+                // @js Adding buf to RPointerArray, handling it in DoRemoteReceive function
+                    {
+                   iMessageQueue.Append( buf );
+                    } 
+                
+            break;
+            }
+        case EStifCmdSend:                 // "Send"
+            {
+            HBufC8* buf = HBufC8::New( iCmdDef.iParam.aRemoteMsgConstRef->Length() );
+            if( buf == NULL )
+                { 
+                ret = KErrNoMemory;
+                break;
+                }
+            TPtr8 tmp = buf->Des();
+            tmp.Copy( *iCmdDef.iParam.aRemoteMsgConstRef );
+            // Second phase of the writing. Write information to the Engine.
+            TRAP( ret, aMessage.WriteL( 0, tmp ) );
+
+            delete buf;
+            
+            if( ret != KErrNone )
+                {
+                __TRACE( KError, ( _L( "CTestExecution::ReadRemoteCmdInfo: WriteL failed" ) ) );
+                }
+            completeSend = ETrue;
+            break;
+            }
+        case EStifCmdReboot:               // "Send"
+            {
+            TRebootParamsPckg remoteTypePckg( *iCmdDef.iParam.aRebootType );
+
+            // Second phase of the writing. Write information to the Engine.
+            TRAP( ret, aMessage.WriteL( 0, remoteTypePckg ) );
+
+            if( ret != KErrNone )
+                {
+                __TRACE( KError, ( _L( "CTestExecution::ReadRemoteCmdInfo: WriteL failed" ) ) );
+                }
+            // Because Reboot must block...Don't complete, so now we wait for
+            // ever phone booting operation !!!!!
+            break;
+            }
+        case EStifCmdStoreState:          // "Send"
+            {
+            TRebootStateParamsPckg remoteStatePckg( *iCmdDef.iParam.aRebootState );
+
+            // Second phase of the writing. Write information to the Engine.
+            TRAP( ret, aMessage.WriteL( 0, remoteStatePckg ) );
+
+            if( ret != KErrNone )
+                {
+                __TRACE( KError, ( _L( "CTestExecution::ReadRemoteCmdInfo: WriteL failed" ) ) );
+                }
+            // Completed from EStifCmdRebootProceed
+            break;
+            }
+        case EStifCmdMeasurement:   // "Receive"
+            {
+            TGetMeasurementOptions getMeasurementOptions;
+            TGetMeasurementOptionsPckg measurementParamsPckg( getMeasurementOptions );
+
+            // Read message from client space
+            TRAP( ret, aMessage.ReadL( 0, measurementParamsPckg ) );
+
+            if( ret != KErrNone )
+                {
+                __TRACE( KError, ( _L( "CTestExecution::ReadRemoteCmdInfo: ReadL failed" ) ) );
+                }
+            iCmdDef.iParam.aMeasurementOption->iOptions = getMeasurementOptions.iOptions;
+
+            completeSend = ETrue;
+            break;
+            }
+        case EStifCmdGetStoredState:   // "Receive"
+            {
+            TGetRebootStoredParams getRebootStoredParams;
+            TGetRebootStoredParamsPckg rebootStoredParamsPckg( getRebootStoredParams );
+
+            // Read message from client space
+            TRAP( ret, aMessage.ReadL( 0, rebootStoredParamsPckg ) );
+
+            if( ret != KErrNone )
+                {
+                __TRACE( KError, ( _L( "CTestExecution::ReadRemoteCmdInfo: ReadL failed" ) ) );
+                }
+            iCmdDef.iParam.aRebootStoredRef->iCode = getRebootStoredParams.aCode;
+            iCmdDef.iParam.aRebootStoredRef->iName = getRebootStoredParams.aName;
+
+            completeSend = ETrue;
+            break;
+            }
+        case EStifCmdRebootProceed:          
+            {
+            completeSend = ETrue; // Complete EStifCmdStoreState
+            }
+            break;
+        default:
+            {
+            iModuleSession->PanicClient( EUnknownRemoteCmd, aMessage );
+            break;
+            }
+        }
+    // Complete request with ret
+    aMessage.Complete( ret ); 
+
+    if( completeSend )
+        {
+        // Calls the TestCombiner's CRemoteReceiver::RunL() and
+        // returns error code to test module.
+        TestThreadRequestComplete( iCmdDef.iStatus, returnedErrorCode );
+        }
+        
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: Pause
+
+    Description: Pauses a test case
+
+    Only ongoing tests can be paused. If test is not ongoing, then
+    function does nothing.
+
+    Parameters: const RMessage& aMessage      :in:  Message from client.
+    
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::Pause( const RMessage2& aMessage )
+    {
+
+    __TRACE ( KThreadOperation, ( _L( "CTestExecution::Pause" ) ) );
+
+    TInt completionCode = KErrNone;
+
+    // Note that it is allowed to suspend already suspended thread, so
+    // there is no need for states to verify that thread is really in
+    // resumed state.
+    switch ( iThreadState )
+        {
+        case EOnGoing:
+            completionCode = iModuleContainer->PauseThread();
+            break;
+
+        case ENotStarted:
+            completionCode = KErrNotReady;
+            break;
+
+        case EFinished:
+        case ECancelled:
+            completionCode = KErrCompletion;
+            break;
+
+        default:
+            CTestServer::PanicServer( EInvalidThreadState );
+            break;
+        }
+
+
+    // Complete the request
+    aMessage.Complete( completionCode );
+
+    return KErrNone;
+
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: Resume
+
+    Description: Resumes a test case. If test is not ongoing,
+    then do not resume.
+
+    Parameters: const RMessage& aMessage      :in:  Message from client.
+    
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::Resume( const RMessage2& aMessage )
+    {
+
+    __TRACE ( KThreadOperation, ( _L( "CTestExecution::Resume" ) ) );
+
+    TInt completionCode = KErrNone;
+
+    // Note that it is allowed to resume already resumed thread, so
+    // there is no need for states to verify that thread is really in
+    // suspended state.
+    switch ( iThreadState )
+        {
+        case EOnGoing:
+            completionCode = iModuleContainer->ResumeThread();
+            break;
+
+        case ENotStarted:
+            completionCode = KErrNotReady;
+            break;
+
+        case EFinished:
+        case ECancelled:
+            completionCode = KErrCompletion;
+            break;
+
+        default:
+            CTestServer::PanicServer( EInvalidThreadState );
+            break;
+        }
+
+
+    // Complete the request
+    aMessage.Complete( completionCode );
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CloseTestExecution
+
+    Description: Closes Test Execution subsession
+
+    Parameters: const RMessage& aMessage      :in:  Message from client.
+    
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CloseTestExecution( const RMessage2& aMessage )
+    {
+
+    // Cancel test request
+    CancelTestRequest();
+
+    // Cancel print request
+    CancelPrintRequest();
+    
+    // Cancel event request
+    CancelEventRequest();
+
+    // Delete this subsession
+    const TUint subsession = aMessage.Int3();
+    iModuleSession->DeleteTestExecution( subsession, aMessage );
+
+    // Complete the request
+    aMessage.Complete( KErrNone );
+
+    return KErrNone;
+
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelPrintRequest
+
+    Description: Cancel print request. Completes ongoing print request
+    with KErrCancel.
+
+    Parameters: None
+    
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CancelPrintRequest()
+    {
+
+    if ( iPrintNotifyAvailable )
+        {
+        iPrintHandler->Cancel();
+        
+        iPrintNotifyAvailable = EFalse;
+        iNotifyPrintMessage.Complete ( KErrCancel );
+        //@spe iPrintNotifyAvailable = EFalse;
+        }
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelEventRequest
+
+    Description: Cancel event request. Completes ongoing event request
+    with KErrCancel.
+
+    Parameters: None
+    
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CancelEventRequest()
+    {
+    iEventHandler->Cancel();
+
+    if( iEventNotifyAvailable )
+        {
+        // Cancel request
+        iEventNotifyAvailable = EFalse;
+        iNotifyEventMessage.Complete ( KErrCancel );
+        }
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelInterferenceRequest
+
+    Description: Cancel print request. Completes ongoing print request
+    with KErrCancel.
+
+    Parameters: None
+
+    Return Values: TInt: Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CancelInterferenceRequest()
+    {
+
+    if ( iInterferenceNotifyAvailable )
+        {
+        iInterferenceHandler->Cancel();
+        
+        iInterferenceNotifyAvailable = EFalse;
+        iNotifyInterferenceMessage.Complete ( KErrCancel );
+        }
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelRemoteCmdRequest
+
+    Description: Cancel RemoteCmd request. Completes ongoing RemoteCmd request
+        with KErrCancel.
+
+    Parameters: None
+    
+    Return Values: TInt: Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CancelRemoteCmdRequest()
+    {
+    iSndHandler->Cancel();
+
+    // Cancel request
+    if( iRemoteSendAvailable )
+        {
+        iRemoteSendAvailable = EFalse;
+        iNotifyRemoteCmdMessage.Complete ( KErrCancel );
+        }
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: NotifyCommand
+
+    Description: Handles the first phase of the Command request from engine.
+
+    Parameters: const RMessage& aMessage: in: Message from client.
+
+    Return Values: Symbian OS error code.
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::NotifyCommand( const RMessage2& aMessage )
+    {
+    iNotifyCommandMessage = aMessage;
+    iCommandNotifyAvailable = ETrue;
+    iCommandHandler->StartL();
+
+    return KErrNone;
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelCommandRequest
+
+    Description: Cancel Command request. Completes ongoing Command request
+        with KErrCancel.
+
+    Parameters: None
+
+    Return Values: TInt: Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CancelCommandRequest()
+    {
+    iCommandHandler->Cancel();
+
+    // Cancel request
+    if(iCommandNotifyAvailable)
+        {
+        iCommandNotifyAvailable = EFalse;
+        iNotifyCommandMessage.Complete(KErrCancel);
+        }
+
+    return KErrNone;
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: GetTestCaseArguments
+
+    Description: Get test case arguments
+
+    Parameters: None
+
+    Return Values: Test case arguments
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+const TDesC& CTestExecution::GetTestCaseArguments() const
+    {
+    if ( iTestCaseArgs != NULL )
+        {
+        return *iTestCaseArgs;
+        }
+    return KNullDesC;
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelTestRequest
+
+    Description: Cancel test execution request.
+    If thread is not in OnGoing state, function does not do anything.
+
+    Otherwise following operations are done:
+    1 ) Obtain access to both  PrintMutex and EventMutex to make sure that
+       thread can't be accessing print queue or events.
+    2 ) Kill the thread
+    3 ) Complete original "RunTestCase" request with KErrCancel
+    4 ) If print queue is empty, complete print request
+    5 ) Give up mutexes
+    6 ) Delete module container
+
+    Parameters: None
+    
+    Return Values: TInt: Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Approved
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CancelTestRequest()
+    {
+    // This mutex block and make sure that cancel operation is done succesfully
+    // and test case e.g. cannot complete at the same time. Get mutex.
+    iTestThreadMutex.Wait();
+
+    // iModuleContainer is an active object, check is active.
+    if ( iModuleContainer == NULL || ( iModuleContainer != NULL && !iModuleContainer->IsActive() ) )
+        {
+        // Test case is already ready, return.
+        iTestThreadMutex.Signal();
+        return KErrNone;
+        }
+
+    if ( iThreadState == EOnGoing )
+        {
+        // Print mutex access is required to make sure that the dying thread
+        // does not have access to print queue. Same is true for event queue.
+
+        // NOTE: iEventArrayMutex is now taken, so the ongoing thread
+        // can't set any events so queue will be empty.
+        iPrintHandler->Cancel();
+        iEventHandler->Cancel();
+        iInterferenceHandler->Cancel();
+        iCommandHandler->Cancel();
+
+        // Kill the thread
+        iModuleContainer->KillThread( KErrCancel );
+
+        // Complete the test execution request
+        CompleteTestExecution( KErrCancel, TFullTestResult::ECaseCancelled, 
+                               KErrCancel, KErrCancel, _L( "Cancelled" ) );
+        iThreadState = ECancelled;
+
+       
+        /**        
+        * Removed, because may block in certain situations. Implemented now in
+        * TestCombiner instead.
+        // Unset all pending state events, 
+        // because we have killed the testcase abnormally
+        // UnsetStateEvents();
+        */
+        
+        // Complete print request if queue is empty
+        CompletePrintRequestIfQueueEmpty();
+        
+        // Delete the module containter
+        delete iModuleContainer;
+        iModuleContainer = NULL;
+        }
+        
+    // Relinquish mutex.
+    iTestThreadMutex.Signal();
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelRequestL
+
+    Description: Cancel asynchronous request
+
+    Parameters: const RMessage& aMessage      :in:  Message from client.
+    
+    Return Values: TInt                             Error code from CancelXXX-
+                                                    function
+
+    Errors/Exceptions: Function panics the client, if invalid message
+                       received.
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CancelRequestL( const RMessage2& aMessage )
+    {
+    TInt r = KErrNone;
+
+    switch ( aMessage.Int0() )
+        {
+        case ETestExecutionRunTestCase:
+            {
+            r = CancelTestRequest();
+            break;
+            }
+        case ETestExecutionNotifyProgress:
+            {
+            r = CancelPrintRequest();
+            break;
+            }
+        case ETestExecutionNotifyEvent:
+            {
+            r = CancelEventRequest();
+            break;
+            }
+        case ETestExecutionNotifyRemoteCmd:
+            {
+            r = CancelRemoteCmdRequest();
+            break;
+            }
+        case ETestExecutionNotifyCommand:
+            {
+            r = CancelCommandRequest();
+            break;
+            }
+        default:
+            iModuleSession->PanicClient( EInvalidRequestCancel, aMessage );
+            break;
+        }
+
+    aMessage.Complete( r );
+
+    return r;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: SetThreadState
+
+    Description: A multithread safe thread state modification function
+
+    Parameters: const TTestState aState       :in:  New state
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::SetThreadState( const TTestState aState )
+    {
+
+    iThreadState = aState;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: Complete event
+
+    Description: Completes pending event request. Must be 
+        called with iEventSem taken.
+        
+    Parameters: None
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+    
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::CompleteEvent( TInt aError )
+    {
+    if( iEventDef.iStatus )
+        {
+        __TRACE( KMessage,(_L("Comp Stat %d, %x (error %d)"), 
+            this, iEventDef.iStatus, aError));
+        TestThreadRequestComplete( iEventDef.iStatus, aError );
+        
+        iEventDef.iStatus = NULL;
+        
+        }
+        
+    }
+    
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CompletePrintRequestIfQueueEmpty
+
+    Description: Completes print request if queue is empty.
+
+    Parameters: None
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::CompletePrintRequestIfQueueEmpty()
+    {
+
+    if ( iPrintNotifyAvailable &&  iPrintQueue->Count() == 0 )
+        {
+        iNotifyPrintMessage.Complete ( KErrEof );
+        iPrintNotifyAvailable = EFalse;
+        }
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CleanupEvents
+
+    Description: Cleanups Events.
+
+    Parameters: None
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::CleanupEvents()
+    {
+    
+    iEventArray.ResetAndDestroy();
+    
+    }
+    
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: GetRq
+
+    Description: Get request pointers.
+
+    Parameters: None
+
+    Return Values: TRequestStatus*
+
+    Errors/Exceptions: None
+
+    Status: Approved
+    
+-------------------------------------------------------------------------------
+*/
+TRequestStatus* CTestExecution::GetRq( TRequestType aType )
+    {
+
+    TRequestStatus* status = NULL;
+
+    switch( aType )
+        {
+        case ERqPrint:
+            status = &iPrintHandler->iStatus;
+            break;
+        case ERqEvent:
+            status = &iEventHandler->iStatus;
+            break;
+        case ERqSnd:
+            status = &iSndHandler->iStatus;
+            break;
+        case ERqRcv:
+            status = &iRcvHandler->iStatus;
+            break;
+        case ERqInterference:
+            status = &iInterferenceHandler->iStatus;
+            break;
+        case ERqMeasurement:
+            status = &iMeasurementHandler->iStatus;
+            break;
+        case ERqCommand:
+            status = &iCommandHandler->iStatus;
+            break;
+        default:
+            break;
+        }
+
+    return status;
+
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CompleteTestExecution
+
+    Description: Completes test execution
+
+    Parameters: const TInt aCompletionCode    :in:  Request completion code
+                const TInt aCaseExecutionCode  in:  Case execution code
+                const TFullTestResult::TCaseExecutionResult aCaseExecutionType,
+                const TInt aCaseResult        :in:  Case result
+                const TDesC& aText            :in:  Completion text
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::CompleteTestExecution( const TInt aCompletionCode,
+    const TFullTestResult::TCaseExecutionResult aCaseExecutionType,
+    const TInt aCaseExecutionCode,
+    const TInt aCaseResult,
+    const TDesC& aText )
+    {
+    
+    TInt completionCode = aCompletionCode;
+    
+    if( iModuleContainer != NULL )
+        {
+        // Fill the description
+        iFullResult.iEndTime.HomeTime();
+        iFullResult.iCaseExecutionResultType = aCaseExecutionType;
+        iFullResult.iCaseExecutionResultCode = aCaseExecutionCode;
+        iFullResult.iTestResult.iResult = aCaseResult;
+        iFullResult.iTestResult.iResultDes = aText;
+        CompleteTestExecution( aCompletionCode );
+        return;
+        }
+    else
+        {   
+        completionCode = KErrGeneral;
+        __TRACE ( KError, ( CStifLogger::ERed, 
+            _L("CTestExecution::CompleteTestExecution: ModuleContainer NULL") ) );
+        }
+
+    iTestExeMessage.Complete ( completionCode );
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CompleteTestExecution
+
+    Description: Completes test execution
+
+    Parameters: const TInt aCompletionCode: in: completion code
+                TFullTestResult&: in: test case result
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::CompleteTestExecution( const TInt aCompletionCode )
+    {
+    
+    TInt completionCode = aCompletionCode;
+    
+    TFullTestResultPckg fullResultPckg( iFullResult );
+    TRAPD( res, iTestExeMessage.WriteL( 0, fullResultPckg ) );
+    if ( res != KErrNone )
+        {
+        completionCode = res;
+        }
+
+    iTestExeMessage.Complete ( completionCode );
+    
+    // @js Now it returns completionCode, used to return res
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: UnsetStateEvents
+
+    Description: Unsets all state events. Must be done if testcase is exited 
+                abnormally (i.e. aborted by the user).
+
+    Parameters: None
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::UnsetStateEvents()
+    {
+
+
+    // Unset all state events that are set currently
+    TInt count = iStateEvents.Count();
+    TEventIf event;
+    for( TInt i = 0; i < count; i++ )   
+        {
+        TPtrC name = *(iStateEvents[i]);
+        event.Set( TEventIf::EUnsetEvent, name, TEventIf::EState );
+        
+        // Construct message
+        TEventIfPckg eventPckg( event );
+
+        // Write message to client space
+        TRAPD( res, iNotifyEventMessage.WriteL( 0, eventPckg ) );
+
+        // Complete with WriteL result
+        iEventNotifyAvailable = EFalse;
+        iNotifyEventMessage.Complete( res );
+        if( res != KErrNone )
+            {
+            __TRACE( KError,( _L( "CTestExecution::UnsetStateEvents: WriteL failed" ) ));
+            break;
+            } 
+        }
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: TestThreadRequestComplete
+
+    Description: Complete test thread request.
+
+    Parameters: None
+    
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CTestExecution::TestThreadRequestComplete( TRequestStatus* aStatus, 
+                                                TInt aCode)
+    {                                        
+    
+    if( iThreadState != EOnGoing )
+        {
+        __TRACE( KError,
+            ( _L( "CTestExecution::TestThreadRequestComplete: test thread killed" ) ));
+        return;
+        }
+
+    if( iTestThreadOpen == EFalse )
+        {        
+        if( iTestThread.Open( iTestThreadId ) != KErrNone )
+            {
+            __TRACE( KError,
+                ( _L( "CTestExecution::TestThreadRequestComplete: test thread cannot be opened" ) ));
+            return;
+            }
+        iTestThreadOpen = ETrue;
+        }
+    if( iTestThread.ExitType() != EExitPending ) 
+        {
+        // test thread has died
+        __TRACE( KError,
+            ( _L( "CTestExecution::TestThreadRequestComplete: test thread has died" ) ));
+        return;
+        }    
+     
+    iTestThread.RequestComplete( aStatus, aCode );
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: CancelTestExecution
+
+    Description: Cancels test(s) execution in special cases e.g. timeout,
+                 exit etc.
+
+    Parameters: None
+    
+    Return Values: TInt: Symbian error code.
+
+    Errors/Exceptions: None
+
+    Status: Approved
+    
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::CancelTestExecution()
+    {
+    TInt ret( KErrNone );
+    ret = CancelTestRequest();
+
+    return ret;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: KillTestinterferenceThread
+
+    Description: Make sure that any of the test interference thread's won't
+                 stay to run if test case is crashed of test interference
+                 object is not deleted.
+
+    Parameters: None
+
+    Return Values: TInt: Symbian OS error code.
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::KillTestinterferenceThread()
+    {
+    for( TInt i = 0; i < iSTIFTestInterferenceArray.Count(); i++ )
+        {
+        RDebug::Print( 
+            _L( "Test interference's thread[%x] killed by STIF" ), (TInt)iSTIFTestInterferenceArray[i].Id() );
+        __TRACE( KInit,
+            ( _L( "Test interference's thread[%x] killed by STIF" ), (TInt)iSTIFTestInterferenceArray[i].Id() ) );
+        iSTIFTestInterferenceArray[i].Kill( KErrCancel );
+        //iSTIFTestInterferenceArray.Remove( i );
+        }
+
+    iSTIFTestInterferenceArray.Reset();
+    iSTIFTestInterferenceArray.Close();
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: DoNotifyCommand
+
+    Description: Completes command message.
+
+    Parameters: None.
+
+    Return Values: Symbian OS error code.
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::DoNotifyCommand()
+    {
+    if(!iCommandNotifyAvailable)
+    	{
+    	__TRACE(KPrint, (_L("CTestExecution::DoNotifyCommand(): unable to complete notification")))
+    	return KErrNone;
+    	}
+
+    TInt ret = KErrNone;
+
+    switch(iCommandDef->iCommand)
+        {
+        case EStopExecution:
+            {
+            //Unpack received parameters
+            TStopExecutionCommandParams par;
+            TStopExecutionCommandParamsPckg parPack(par);
+            parPack.Copy(iCommandDef->iParamsPckg);
+
+            //Set test case handle
+            par.iTestCaseHandle = iNotifyCommandMessage.Int3();
+
+            __TRACE(KPrint, (_L("CTestExecution::DoNotifyCommand(): command [%d] type [%d] code [%d] test handle [%d]"), TInt(iCommandDef->iCommand), TInt(par.iType), TInt(par.iCode), par.iTestCaseHandle));
+            iCommandDef->iParamsPckg.Copy(parPack);
+            break;
+            }
+        case ESendTestModuleVersion:
+        	{
+        	TSendTestModuleVesionCommandParams par;
+        	TSendTestModuleVesionCommandParamsPckg parPack(par);
+        	parPack.Copy(iCommandDef->iParamsPckg);
+        	
+        	__TRACE(KPrint, (_L("CTestExecution::DoNotifyCommand(): command ESendTestModuleVersion")));
+        	break;
+        	}
+        default:
+            __TRACE(KError, (_L("CTestExecution::DoNotifyCommand(): Unknown command [%d]"), TInt(iCommandDef->iCommand)));
+            return KErrNotFound;
+        }
+    // Construct message
+    TPckg<TCommand> commandPckg(iCommandDef->iCommand);
+
+    // Start first phase of the writing message to client space
+    TRAP(ret, iNotifyCommandMessage.WriteL(0, commandPckg));
+    if(ret != KErrNone)
+       {
+       __TRACE(KError, (_L( "CTestExecution::DoNotifyCommand(): WriteL failed (0)")));
+       }
+
+    TRAP(ret, iNotifyCommandMessage.WriteL(1, iCommandDef->iParamsPckg));
+    if(ret != KErrNone)
+       {
+       __TRACE(KError, (_L( "CTestExecution::DoNotifyCommand(): WriteL failed (1)")));
+       }
+
+    // Complete request with WriteL result
+    iCommandNotifyAvailable = EFalse;
+    iNotifyCommandMessage.Complete(ret);
+
+    return KErrNone;
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CTestExecution
+
+    Method: KillTestMeasurement
+
+    Description: Make sure that any of the test measurement operations won't
+                 stay to run if test case is crashed or test measurement object
+                 is not stopped by user.
+
+    Parameters: None
+
+    Return Values: TInt: Symbian OS error code.
+
+    Errors/Exceptions: None
+
+    Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestExecution::KillTestMeasurement()
+    {
+    for( TInt i = 0; i < iMeasurementHandlingArray.Count(); i++ )
+        {
+        iMeasurementHandlingArray[i]->iMeasurementModulePtr->Stop();
+        }
+
+    iMeasurementHandlingArray.ResetAndDestroy();
+    iMeasurementHandlingArray.Close();
+
+    return KErrNone;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    DESCRIPTION
+
+    This module contains implementation of CPrintHandler class member functions.
+    CPrintHandler listens print notifications from test thread.
+
+-------------------------------------------------------------------------------
+*/
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CPrintHandler
+
+    Method: NewL
+
+    Description: Constructs a new CPrintHandler object.
+
+    Parameters: CTestExecution& aExecution: in: "Parent"
+
+    Return Values: CPrintHandler*: New undertaker
+
+    Errors/Exceptions: Leaves if memory allocation or ConstructL leaves.
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CPrintHandler* CPrintHandler::NewL( CTestExecution& aExecution )
+    {
+
+    CPrintHandler* self = new( ELeave ) CPrintHandler( aExecution );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CPrintHandler
+
+    Method: ConstructL
+
+    Description: Second level constructor.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CPrintHandler::ConstructL()
+    {
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CPrintHandler
+
+    Method: CPrintHandler
+
+    Description: Constructor
+
+    Parameters: CTestModuleContainer& aExecution :in:   "Parent"
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CPrintHandler::CPrintHandler( CTestExecution& aExecution ) :
+    CActive( CActive::EPriorityStandard ),
+    iExecution( aExecution )
+    {
+    
+    CActiveScheduler::Add ( this );
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CPrintHandler
+
+    Method: ~CPrintHandler
+
+    Description: Destructor. 
+    Cancels active request.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CPrintHandler::~CPrintHandler()
+    {
+
+    Cancel();
+
+    }
+
+
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CPrintHandler
+
+    Method: StartL
+
+    Description: Starts to monitor thread.
+
+    Parameters: None
+
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CPrintHandler::StartL()
+    {
+    
+    __TRACE( KPrint, ( _L( "CPrintHandler::StartL" ) ) );
+    
+    if( IsActive() ) 
+        {
+        CTestServer::PanicServer( EAlreadyActive );
+        }
+
+    iStatus = KRequestPending;
+    SetActive();
+    
+    // Signal test thread
+    iExecution.iPrintSem.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CPrintHandler
+
+    Method: RunL
+
+    Description: Handles thread death.
+    Function does:
+    1 ) Stops monitoring thread
+    1 ) Marks thread death
+    2 ) Completes ongoing requests
+    3 ) Cleans the memory
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CPrintHandler::RunL()
+    {
+
+    __TRACE( KPrint, ( _L( "CPrintHandler::RunL [%d]" ), iStatus.Int() ) );
+    
+    iExecution.DoNotifyPrint();
+    
+    // enable print request
+    //@speiExecution.iPrintHandler->StartL();
+    StartL();
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CPrintHandler
+
+    Method: DoCancel
+
+    Description: Stops print notification listening.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+
+void CPrintHandler::DoCancel()
+    {
+
+    __TRACE( KPrint, ( _L( "CPrintHandler::DoCancel" ) ) );
+
+    iExecution.iPrintMutex.Wait();  // Take mutex and check test case print
+                                    // operation. If pending take print semaphore
+                                    // and complete
+    if( iStatus == KRequestPending )
+        {
+        // Signal test thread
+        // @remove iExecution.iPrintSem.Wait();
+    
+        TRequestStatus* status = &iStatus;    
+        User::RequestComplete( status, KErrCancel );        
+        }
+
+    iExecution.iPrintMutex.Signal();
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CPrintHandler
+
+    Method: RunError
+
+    Description: Handle errors. RunL function does not leave, so one should
+    never come here. 
+
+    Print trace and let framework handle error( i.e to do Panic )
+
+    Parameters: TInt aError:                  :in:  Error code
+
+    Return Values:  TInt                            Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CPrintHandler::RunError( TInt aError )
+    {
+    
+    __TRACE( KError,( _L( "CPrintHandler::RunError" ) ) );
+
+    return aError;
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    DESCRIPTION
+
+    This module contains implementation of CEventHandler class member functions.
+    CEventHandler listens print notifications from test thread.
+
+-------------------------------------------------------------------------------
+*/
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CEventHandler
+
+    Method: NewL
+
+    Description: Constructs a new CEventHandler object.
+
+    Parameters: CTestExecution& aExecution: in: "Parent"
+
+    Return Values: CEventHandler*: New undertaker
+
+    Errors/Exceptions: Leaves if memory allocation or ConstructL leaves.
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CEventHandler* CEventHandler::NewL( CTestExecution& aExecution )
+    {
+
+    CEventHandler* self = new( ELeave ) CEventHandler( aExecution );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CEventHandler
+
+    Method: ConstructL
+
+    Description: Second level constructor.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CEventHandler::ConstructL()
+    {
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CEventHandler
+
+    Method: CEventHandler
+
+    Description: Constructor
+
+    Parameters: CTestModuleContainer& aExecution :in:   "Parent"
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CEventHandler::CEventHandler( CTestExecution& aExecution ) :
+    CActive( CActive::EPriorityStandard ),
+    iExecution( aExecution )
+    {
+    
+    CActiveScheduler::Add ( this );
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CEventHandler
+
+    Method: ~CEventHandler
+
+    Description: Destructor. 
+    Cancels active request.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CEventHandler::~CEventHandler()
+    {
+
+    Cancel();
+
+    }
+
+
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CEventHandler
+
+    Method: StartL
+
+    Description: Starts to monitor thread.
+
+    Parameters: None
+
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CEventHandler::StartL()
+    {
+    
+    __TRACE( KPrint, ( _L( "CEventHandler::StartL" ) ) );
+
+    if( IsActive() ) 
+        {
+        CTestServer::PanicServer( EAlreadyActive );
+        }
+    
+    iStatus = KRequestPending;
+    SetActive();
+    
+    // Signal test thread
+    iExecution.iEventSem.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CEventHandler
+
+    Method: RunL
+
+    Description: Handles thread death.
+    Function does:
+    1 ) Stops monitoring thread
+    1 ) Marks thread death
+    2 ) Completes ongoing requests
+    3 ) Cleans the memory
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CEventHandler::RunL()
+    {
+
+    __TRACE( KPrint, ( _L( "CEventHandler::RunL [%d]" ), iStatus.Int() ) );
+
+    switch( iExecution.EventDef().iType )
+        {
+        case TEventDef::EEventCmd:
+            iExecution.DoNotifyEvent();
+            break;
+        case TEventDef::EEventCmdCancel:
+            iExecution.CancelEvent();
+            break;
+        default:
+            CTestServer::PanicServer( EUnknownEventCmd );
+            break;  
+        }
+         
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CEventHandler
+
+    Method: DoCancel
+
+    Description: Stops print notification listening.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+
+void CEventHandler::DoCancel()
+    {
+
+    __TRACE( KPrint, ( _L( "CEventHandler::DoCancel" ) ) );
+    
+    iExecution.iEventMutex.Wait();  // Take mutex and check test case event
+                                    // operation. If pending take event
+                                    // semaphore and complete
+    if( iStatus == KRequestPending )
+        {
+        // Signal test thread
+        // @remove iExecution.iEventSem.Wait();
+
+        TRequestStatus* status = &iStatus;    
+        User::RequestComplete( status, KErrCancel );
+
+        }
+
+    iExecution.iEventMutex.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CEventHandler
+
+    Method: RunError
+
+    Description: Handle errors. RunL function does not leave, so one should
+    never come here. 
+
+    Print trace and let framework handle error( i.e to do Panic )
+
+    Parameters: TInt aError:                  :in:  Error code
+
+    Return Values:  TInt                            Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CEventHandler::RunError( TInt aError )
+    {
+    
+    __TRACE( KError,( _L( "CEventHandler::RunError" ) ) );
+
+    return aError;
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    DESCRIPTION
+
+    This module contains implementation of CSndHandler class member functions.
+    CSndHandler listens print notifications from test thread.
+
+-------------------------------------------------------------------------------
+*/
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CSndHandler
+
+    Method: NewL
+
+    Description: Constructs a new CSndHandler object.
+
+    Parameters: CTestExecution& aExecution: in: "Parent"
+
+    Return Values: CSndHandler*: New undertaker
+
+    Errors/Exceptions: Leaves if memory allocation or ConstructL leaves.
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CSndHandler* CSndHandler::NewL( CTestExecution& aExecution )
+    {
+
+    CSndHandler* self = new( ELeave ) CSndHandler( aExecution );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CSndHandler
+
+    Method: ConstructL
+
+    Description: Second level constructor.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CSndHandler::ConstructL()
+    {
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CSndHandler
+
+    Method: CSndHandler
+
+    Description: Constructor
+
+    Parameters: CTestModuleContainer& aExecution :in:   "Parent"
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CSndHandler::CSndHandler( CTestExecution& aExecution ) :
+    CActive( CActive::EPriorityStandard ),
+    iExecution( aExecution )
+    {
+    
+    CActiveScheduler::Add ( this );
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CSndHandler
+
+    Method: ~CSndHandler
+
+    Description: Destructor. 
+    Cancels active request.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CSndHandler::~CSndHandler()
+    {
+
+    Cancel();
+
+    }
+
+
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CSndHandler
+
+    Method: StartL
+
+    Description: Starts to monitor thread.
+
+    Parameters: None
+
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CSndHandler::StartL()
+    {
+    
+    __TRACE( KPrint, ( _L( "CSndHandler::StartL" ) ) );
+
+    if( IsActive() ) 
+        {
+        CTestServer::PanicServer( EAlreadyActive );
+        }
+    
+    iStatus = KRequestPending;
+    SetActive();
+    
+    // Signal test thread
+    iExecution.iSndSem.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CSndHandler
+
+    Method: RunL
+
+    Description: Handles thread death.
+    Function does:
+    1 ) Stops monitoring thread
+    1 ) Marks thread death
+    2 ) Completes ongoing requests
+    3 ) Cleans the memory
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CSndHandler::RunL()
+    {
+
+    __TRACE( KPrint, ( _L( "CSndHandler::RunL [%d]" ), iStatus.Int() ) );
+    
+    iExecution.DoRemoteSend();
+       
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CSndHandler
+
+    Method: DoCancel
+
+    Description: Stops print notification listening.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+
+void CSndHandler::DoCancel()
+    {
+
+    __TRACE( KPrint, ( _L( "CSndHandler::DoCancel" ) ) );
+
+    iExecution.iSndMutex.Wait();  // Take mutex and check test case send
+                                  // operation. If pending take send
+                                  // semaphore and complete
+    if( iStatus == KRequestPending )
+        {
+        // Signal test thread
+        // @remove iExecution.iSndSem.Wait();
+
+        TRequestStatus* status = &iStatus;    
+        User::RequestComplete( status, KErrCancel );
+
+        }
+
+    iExecution.iSndMutex.Signal();
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CSndHandler
+
+    Method: RunError
+
+    Description: Handle errors. RunL function does not leave, so one should
+    never come here. 
+
+    Print trace and let framework handle error( i.e to do Panic )
+
+    Parameters: TInt aError:                  :in:  Error code
+
+    Return Values:  TInt                            Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CSndHandler::RunError( TInt aError )
+    {
+    
+    __TRACE( KError,( _L( "CSndHandler::RunError" ) ) );
+
+    return aError;
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    DESCRIPTION
+
+    This module contains implementation of CSndHandler class member functions.
+    CRcvHandler listens print notifications from test thread.
+
+-------------------------------------------------------------------------------
+*/
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CRcvHandler
+
+    Method: NewL
+
+    Description: Constructs a new CRcvHandler object.
+
+    Parameters: CTestExecution& aExecution: in: "Parent"
+
+    Return Values: CRcvHandler*: New undertaker
+
+    Errors/Exceptions: Leaves if memory allocation or ConstructL leaves.
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CRcvHandler* CRcvHandler::NewL( CTestExecution& aExecution )
+    {
+
+    CRcvHandler* self = new( ELeave ) CRcvHandler( aExecution );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CRcvHandler
+
+    Method: ConstructL
+
+    Description: Second level constructor.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CRcvHandler::ConstructL()
+    {
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CRcvHandler
+
+    Method: CRcvHandler
+
+    Description: Constructor
+
+    Parameters: CTestModuleContainer& aExecution :in:   "Parent"
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CRcvHandler::CRcvHandler( CTestExecution& aExecution ) :
+    CActive( CActive::EPriorityStandard ),
+    iExecution( aExecution )
+    {
+    
+    CActiveScheduler::Add ( this );
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CRcvHandler
+
+    Method: ~CRcvHandler
+
+    Description: Destructor. 
+    Cancels active request.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CRcvHandler::~CRcvHandler()
+    {
+
+    Cancel();
+
+    }
+
+
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CRcvHandler
+
+    Method: StartL
+
+    Description: Starts to monitor thread.
+
+    Parameters: None
+
+    Return Values: TInt                             Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CRcvHandler::StartL()
+    {
+    
+    __TRACE( KPrint, ( _L( "CRcvHandler::StartL" ) ) );
+    
+    if( IsActive() ) 
+        {
+        CTestServer::PanicServer( EAlreadyActive );
+        }
+    iStatus = KRequestPending;
+    SetActive();
+    
+    // Signal test thread
+    iExecution.iRcvSem.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CRcvHandler
+
+    Method: RunL
+
+    Description: Handles thread death.
+    Function does:
+    1 ) Stops monitoring thread
+    1 ) Marks thread death
+    2 ) Completes ongoing requests
+    3 ) Cleans the memory
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CRcvHandler::RunL()
+    {
+
+    __TRACE( KPrint, ( _L( "CRcvHandler::RunL [%d]" ), iStatus.Int() ) );
+    
+    iExecution.DoRemoteReceive();
+       
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CRcvHandler
+
+    Method: DoCancel
+
+    Description: Stops print notification listening.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+
+void CRcvHandler::DoCancel()
+    {
+
+    __TRACE( KPrint, ( _L( "CRcvHandler::DoCancel" ) ) );
+
+    iExecution.iRcvMutex.Wait();  // Take mutex and check test case receive
+                                  // operation. If pending take reveive
+                                  // semaphore and complete
+    if( iStatus == KRequestPending )
+        {
+        // Signal test thread
+        // @remove iExecution.iRcvSem.Wait();
+
+        TRequestStatus* status = &iStatus;    
+        User::RequestComplete( status, KErrCancel );
+        }
+        
+    iExecution.iRcvMutex.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CRcvHandler
+
+    Method: RunError
+
+    Description: Handle errors. RunL function does not leave, so one should
+    never come here. 
+
+    Print trace and let framework handle error( i.e to do Panic )
+
+    Parameters: TInt aError:                  :in:  Error code
+
+    Return Values:  TInt                            Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CRcvHandler::RunError( TInt aError )
+    {
+    
+    __TRACE( KError,( _L( "CRcvHandler::RunError" ) ) );
+
+    return aError;
+    
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    DESCRIPTION
+
+    This module contains implementation of CTestInterferenceHandler class 
+    member functions. CTestInterferenceHandler listens print notifications from
+    test thread.
+
+-------------------------------------------------------------------------------
+*/
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CInterferenceHandler
+
+    Method: NewL
+
+    Description: Constructs a new CInterferenceHandler object.
+
+    Parameters: CTestExecution& aExecution: in: "Parent"
+
+    Return Values: CInterferenceHandler*: New undertaker
+
+    Errors/Exceptions: Leaves if memory allocation or ConstructL leaves.
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CInterferenceHandler* CInterferenceHandler::NewL( 
+                                                CTestExecution& aExecution )
+    {
+    CInterferenceHandler* self = 
+                        new( ELeave ) CInterferenceHandler( aExecution );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CInterferenceHandler
+
+    Method: ConstructL
+
+    Description: Second level constructor.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CInterferenceHandler::ConstructL()
+    {
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CInterferenceHandler
+
+    Method: CInterferenceHandler
+
+    Description: Constructor
+
+    Parameters: CTestModuleContainer& aExecution :in: "Parent"
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CInterferenceHandler::CInterferenceHandler( CTestExecution& aExecution ) :
+    CActive( CActive::EPriorityStandard ),
+    iExecution( aExecution )
+    {
+    CActiveScheduler::Add ( this );
+    
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CInterferenceHandler
+
+    Method: ~CInterferenceHandler
+
+    Description: Destructor. 
+    Cancels active request.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+CInterferenceHandler::~CInterferenceHandler()
+    {
+    Cancel();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CInterferenceHandler
+
+    Method: StartL
+
+    Description: Starts to monitor thread.
+
+    Parameters: None
+
+    Return Values: TInt: Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CInterferenceHandler::StartL()
+    {
+    __TRACE( KPrint, ( _L( "CInterferenceHandler::StartL" ) ) );
+    
+    if( IsActive() ) 
+        {
+        CTestServer::PanicServer( EAlreadyActive );
+        }
+
+    iStatus = KRequestPending;
+    SetActive();
+    
+    // Signal test thread, Notify test thread that operation is done.
+    iExecution.iInterferenceSem.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CInterferenceHandler
+
+    Method: RunL
+
+    Description: Handles thread death.
+    Function does:
+    1 ) Stops monitoring thread
+    1 ) Marks thread death
+    2 ) Completes ongoing requests
+    3 ) Cleans the memory
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CInterferenceHandler::RunL()
+    {
+    __TRACE( KPrint, ( _L( "CInterferenceHandler::RunL [%d]" ), iStatus.Int() ) );
+    
+    iExecution.DoNotifyInterference();
+    
+    StartL();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CInterferenceHandler
+
+    Method: DoCancel
+
+    Description: Stops interference notification listening.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+    
+-------------------------------------------------------------------------------
+*/
+void CInterferenceHandler::DoCancel()
+    {
+    __TRACE( KPrint, ( _L( "CInterferenceHandler::DoCancel" ) ) );
+
+    iExecution.iInterferenceMutex.Wait();   // Take mutex and check test
+                                            // interference operation. If
+                                            // pending take interference
+                                            // semaphore and complete
+    if( iStatus == KRequestPending )
+        {
+    
+        TRequestStatus* status = &iStatus;    
+        User::RequestComplete( status, KErrCancel );
+        }
+
+    iExecution.iInterferenceMutex.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CInterferenceHandler
+
+    Method: RunError
+
+    Description: Handle errors. RunL function does not leave, so one should
+    never come here. 
+
+    Print trace and let framework handle error( i.e to do Panic )
+
+    Parameters: TInt aError: in: Error code
+
+    Return Values:  TInt: Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CInterferenceHandler::RunError( TInt aError )
+    {
+    __TRACE( KError,( _L( "CTestInterferenceHandler::RunError" ) ) );
+
+    return aError;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    DESCRIPTION
+
+    This module contains implementation of CMeasurementHandler class 
+    member functions. CMeasurementHandler handles test measurement operations
+    that comes from test execution side to TestServer side.
+
+-------------------------------------------------------------------------------
+*/
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CMeasurementHandler
+
+    Method: NewL
+
+    Description: Constructs a new CMeasurementHandler object.
+
+    Parameters: CTestExecution& aExecution: in: Pointer to test execution side.
+
+    Return Values: CMeasurementHandler*: New undertaker
+
+    Errors/Exceptions: Leaves if memory allocation or ConstructL leaves.
+
+    Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+CMeasurementHandler* CMeasurementHandler::NewL( CTestExecution& aExecution )
+    {
+    CMeasurementHandler* self = 
+                        new( ELeave ) CMeasurementHandler( aExecution );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CMeasurementHandler
+
+    Method: ConstructL
+
+    Description: Second level constructor.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+void CMeasurementHandler::ConstructL()
+    {
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CMeasurementHandler
+
+    Method: CMeasurementHandler
+
+    Description: Constructor
+
+    Parameters: CTestModuleContainer& aExecution :in: Pointer to test
+                execution side.
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+CMeasurementHandler::CMeasurementHandler( CTestExecution& aExecution ) :
+    CActive( CActive::EPriorityStandard ),
+    iExecution( aExecution )
+    {
+    CActiveScheduler::Add ( this );
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CMeasurementHandler
+
+    Method: ~CMeasurementHandler
+
+    Description: Destructor. 
+    Cancels active request.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+CMeasurementHandler::~CMeasurementHandler()
+    {
+    Cancel();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CMeasurementHandler
+
+    Method: StartL
+
+    Description: Starts to monitor thread.
+
+    Parameters: None
+
+    Return Values: TInt: Always KErrNone
+
+    Errors/Exceptions: None
+
+    Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+void CMeasurementHandler::StartL()
+    {
+    __TRACE( KPrint, ( _L( "CMeasurementHandler::StartL" ) ) );
+
+    if( IsActive() ) 
+        {
+        CTestServer::PanicServer( EAlreadyActive );
+        }
+
+    iStatus = KRequestPending;
+    SetActive();
+
+    // Do not Signal here because synchronous operations will be executed and we
+    // don't want to signal at first time: iExecution.iMeasurementSem.Signal();
+    // Signal() operation will be handled in RunL in this case.
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CMeasurementHandler
+
+    Method: RunL
+
+    Description: Derived from CActive, handles test measurement execution.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+void CMeasurementHandler::RunL()
+    {
+    __TRACE( KPrint, ( _L( "CMeasurementHandler::RunL [%d]" ), iStatus.Int() ) );
+    
+    TInt ret( 0 );
+    ret = iExecution.DoNotifyMeasurement();
+
+    // ret value is copied to struct so it can be handled later.
+    iExecution.iTestMeasurement.iMeasurementStruct.iOperationResult = ret;
+    
+    // SetActive again
+    StartL();
+
+    // TestServer side operations are done, Signal that operation is done.
+    iExecution.iMeasurementSem.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CMeasurementHandler
+
+    Method: DoCancel
+
+    Description: Stops measurement notification listening.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Approved
+    
+-------------------------------------------------------------------------------
+*/
+void CMeasurementHandler::DoCancel()
+    {
+    __TRACE( KPrint, ( _L( "CMeasurementHandler::DoCancel" ) ) );
+
+    iExecution.iMeasurementMutex.Wait();    // Take mutex and check test
+                                            // measurement operation. If
+                                            // pending take measurement
+                                            // semaphore and complete
+    if( iStatus == KRequestPending )
+        {
+    
+        TRequestStatus* status = &iStatus;    
+        User::RequestComplete( status, KErrCancel );
+        }
+
+    iExecution.iMeasurementMutex.Signal();
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CMeasurementHandler
+
+    Method: RunError
+
+    Description: Handle errors. RunL function does not leave, so one should
+    never come here. 
+
+    Print trace and let framework handle error( i.e to do Panic )
+
+    Parameters: TInt aError: in: Error code
+
+    Return Values:  TInt: Error code
+
+    Errors/Exceptions: None
+
+    Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+TInt CMeasurementHandler::RunError( TInt aError )
+    {
+    __TRACE( KError,( 
+        _L( "CMeasurementHandler::RunError with error: %d" ), aError ) );
+
+    return aError;
+
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    DESCRIPTION
+
+    This module contains implementation of CCommandHandler class member functions.
+    CCommandHandler listens command notifications from test thread.
+
+-------------------------------------------------------------------------------
+*/
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandHandler
+
+    Method: NewL
+
+    Description: Constructs a new CCommandHandler object.
+
+    Parameters: CTestExecution& aExecution: in: "Parent"
+
+    Return Values: CCommandHandler*: New object
+
+    Errors/Exceptions: Leaves if memory allocation or ConstructL leaves.
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CCommandHandler* CCommandHandler::NewL(CTestExecution& aExecution)
+    {
+    CCommandHandler* self = new (ELeave) CCommandHandler(aExecution);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandHandler
+
+    Method: ConstructL
+
+    Description: Second level constructor.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CCommandHandler::ConstructL()
+    {
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandHandler
+
+    Method: CCommandHandler
+
+    Description: Constructor
+
+    Parameters: CTestExecution& aExecution :in:   "Parent"
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CCommandHandler::CCommandHandler(CTestExecution& aExecution):
+    CActive(CActive::EPriorityStandard),
+    iExecution(aExecution)
+    {
+    CActiveScheduler::Add (this);
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandHandler
+
+    Method: ~CCommandHandler
+
+    Description: Destructor.
+    Cancels active request.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CCommandHandler::~CCommandHandler()
+    {
+    Cancel();
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandHandler
+
+    Method: StartL
+
+    Description: Starts to monitor thread.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CCommandHandler::StartL()
+    {
+    __TRACE(KPrint, (_L( "CCommandHandler::StartL" )));
+
+    if(IsActive())
+        {
+        CTestServer::PanicServer(EAlreadyActive);
+        }
+    iStatus = KRequestPending;
+    SetActive();
+
+    // Signal test thread
+    iExecution.iCommandSem.Signal();
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandHandler
+
+    Method: RunL
+
+    Description:
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CCommandHandler::RunL()
+    {
+    __TRACE(KPrint, (_L( "CCommandHandler::RunL [%d]"), iStatus.Int()));
+
+    iExecution.DoNotifyCommand();
+//    StartL();
+    }
+
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandHandler
+
+    Method: DoCancel
+
+    Description: Stops command notification listening.
+
+    Parameters: None
+
+    Return Values: None
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+
+void CCommandHandler::DoCancel()
+    {
+    __TRACE(KPrint, (_L("CCommandHandler::DoCancel")));
+
+    iExecution.iCommandMutex.Wait();  // Take mutex and check test case receive
+                                      // operation. If pending take reveive
+                                      // semaphore and complete
+    if(iStatus == KRequestPending)
+        {
+        TRequestStatus* status = &iStatus;
+        User::RequestComplete(status, KErrCancel);
+        }
+
+    iExecution.iCommandMutex.Signal();
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandHandler
+
+    Method: RunError
+
+    Description: Handle errors. RunL function does not leave, so one should
+    never come here.
+
+    Print trace and let framework handle error( i.e to do Panic )
+
+    Parameters: TInt aError:                  :in:  Error code
+
+    Return Values:  TInt                            Error code
+
+    Errors/Exceptions: None
+
+    Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CCommandHandler::RunError(TInt aError)
+    {
+    __TRACE(KError, (_L("CCommandHandler::RunError")));
+
+    return aError;
+    }
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandDef
+
+    Method: CCommandDef
+
+    Description: private constructor
+
+    Return Values:  void
+
+-------------------------------------------------------------------------------
+*/
+
+CCommandDef::CCommandDef()
+	{
+	}
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandDef
+
+    Method: ConstructL
+
+    Description: Second phase constructor
+
+    Return Values:  void
+
+-------------------------------------------------------------------------------
+*/
+
+void CCommandDef::ConstructL()
+	{
+
+	}
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandDef
+
+    Method: NewL
+
+    Description: First phase constructor
+
+    Return Values:  void
+
+-------------------------------------------------------------------------------
+*/
+
+CCommandDef* CCommandDef::NewL()
+	{
+	CCommandDef* self = new(ELeave) CCommandDef;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+/*
+-------------------------------------------------------------------------------
+
+    Class: CCommandDef
+
+    Method: ~CCommandDef
+
+    Description: destructor
+
+-------------------------------------------------------------------------------
+*/
+
+CCommandDef::~CCommandDef()
+	{
+
+	}
+
+// End of File