/*
* 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 file contains TestScripter implementation.
*
*/
// INCLUDE FILES
#include "TestScripterUtils.h"
#include <f32file.h>
#include "TestScripter.h"
#include "Logging.h"
// EXTERNAL DATA STRUCTURES
// None
// EXTERNAL FUNCTION PROTOTYPES
// None
// CONSTANTS
// None
// MACROS
// None
// LOCAL CONSTANTS AND MACROS
// None
// MODULE DATA STRUCTURES
// None
// LOCAL FUNCTION PROTOTYPES
// None
// FORWARD DECLARATIONS
// None
// ==================== LOCAL FUNCTIONS =======================================
// ================= MEMBER FUNCTIONS =========================================
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: CStartInfo
Description: Default constructor
C++ default constructor can NOT contain any code, that
might leave.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CStartInfo::CStartInfo():
iCategory( TFullTestResult::ECaseExecuted )
{
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: ConstructL
Description: Symbian OS second phase constructor
Symbian OS default constructor can leave.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CStartInfo::ConstructL()
{
iModule = HBufC::NewL( 0 );
iIniFile = HBufC::NewL( 0 );
iConfig = HBufC::NewL( 0 );
iTestId = HBufC::NewL( 0 );
iTitle = HBufC::NewL( 0 );
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: NewL
Description: Two-phased constructor.
Parameters: None
Return Values: CStartInfo*: new object
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CStartInfo* CStartInfo::NewL()
{
CStartInfo* self = new (ELeave) CStartInfo();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: ~CStartInfo
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CStartInfo::~CStartInfo()
{
delete iModule;
delete iIniFile;
delete iConfig;
delete iTestId;
delete iTitle;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetModuleNameL
Description: Set module name.
Parameters: TDesC& aModule: in: Module name
TInt aExtLength: in: Extra length reserved for buffer
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetModuleNameL( const TDesC& aModule, TInt aExtLength )
{
HBufC* module = HBufC::NewL( aModule.Length() + aExtLength );
CleanupStack::PushL( module );
TPtr modulePtr( module->Des() );
modulePtr.Append( aModule );
// Remove optional '.DLL' from file name
modulePtr.LowerCase();
TParse parse;
parse.Set( *module, NULL, NULL );
if ( parse.Ext() == _L(".dll") )
{
const TInt len = parse.Ext().Length();
modulePtr.Delete ( modulePtr.Length() - len, len );
}
CleanupStack::Pop( module );
delete iModule;
iModule = module;
};
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetIniFileL
Description: Set initialization file name name.
Parameters: TDesC& aIni: in: Initialization file name
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetIniFileL( const TDesC& aIni )
{
HBufC* inifile = aIni.AllocL();
delete iIniFile;
iIniFile = inifile;
};
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetConfigL
Description: Set configuration file name name.
Parameters: TDesC& aConfig: in: Configuration file name
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetConfigL( const TDesC& aConfig )
{
HBufC* config = aConfig.AllocL();
delete iConfig;
iConfig = config;
};
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetTestIdL
Description: Set test identifier.
Parameters: TDesC& aTestId: in: test identifier
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetTestIdL( const TDesC& aTestId )
{
HBufC* testId = aTestId.AllocL();
delete iTestId;
iTestId = testId;
};
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetTitleL
Description: Set title.
Parameters: TDesC& aTitle: in: Test case title
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetTitleL( const TDesC& aTitle)
{
HBufC* title = aTitle.AllocL();
delete iTitle;
iTitle = title;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetTestCaseNumber
Description: Sets test case index.
Parameters: TInt aTestCaseNumber: in: Test case index
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetTestCaseNumber( TInt aTestCaseNumber )
{
iCaseNum = aTestCaseNumber;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetExpectedResult
Description: Sets test case expected result
Parameters: TInt aExpectedResult: in: Test case expected result
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetExpectedResult( TInt aExpectedResult )
{
iExpectedResult = aExpectedResult;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetExpectedResultCategory
Description: Sets test case expected result category
Parameters: TFullTestResult::TCaseExecutionResult aCategory: in: Test case expected result category
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetExpectedResultCategory( TFullTestResult::TCaseExecutionResult aCategory )
{
iCategory = aCategory;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: SetTimeout
Description: Sets test case timeout value
Parameters: TInt aTimeout: in: Test case timeout value
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::SetTimeout( TInt aTimeout )
{
iTimeout = aTimeout;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetModuleName
Description: Gets test module name.
Parameters: None
Return Values: Test module name
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
const TDesC& CStartInfo::GetModuleName() const
{
return *iModule;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetIniFile
Description: Gets ini file path
Parameters: None
Return Values: Ini file path
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
const TDesC& CStartInfo::GetIniFile() const
{
return *iIniFile;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetConfig
Description: Gets config file path
Parameters: None
Return Values: Config file path
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
const TDesC& CStartInfo::GetConfig() const
{
return *iConfig;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetTestId
Description: Gets test case id
Parameters: None
Return Values: Test case id
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
const TDesC& CStartInfo::GetTestId() const
{
return *iTestId;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetTitle
Description: Gets test case title
Parameters: None
Return Values: Test case title
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
const TDesC& CStartInfo::GetTitle() const
{
return *iTitle;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetTestCaseNumber
Description: Gets test case index
Parameters: None
Return Values: Test case index
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TInt CStartInfo::GetTestCaseNumber() const
{
return iCaseNum;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetExpectedResult
Description: Gets test case expected result
Parameters: None
Return Values: Test case expected result
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TInt CStartInfo::GetExpectedResult() const
{
return iExpectedResult;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetExpectedResultCategory
Description: Gets test case expected result category
Parameters: None
Return Values: Test case expected result category
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TFullTestResult::TCaseExecutionResult CStartInfo::GetExpectedResultCategory() const
{
return iCategory;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: GetTimeout
Description: Gets test case timeout value
Parameters: None
Return Values: Test case timeout value
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TInt CStartInfo::GetTimeout() const
{
return iTimeout;
}
/*
-------------------------------------------------------------------------------
Class: CStartInfo
Method: CopyL
Description: Copy values from other CStartInfo instance.
Parameters: const CStartInfo& aStartInfo: in: CStartInfo instance
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CStartInfo::CopyL( const CStartInfo& aStartInfo )
{
SetConfigL( aStartInfo.GetConfig() );
SetExpectedResult( aStartInfo.GetExpectedResult() );
SetExpectedResultCategory( aStartInfo.GetExpectedResultCategory() );
SetIniFileL( aStartInfo.GetIniFile() );
SetModuleNameL( aStartInfo.GetModuleName() );
SetTestCaseNumber( aStartInfo.GetTestCaseNumber() );
SetTestIdL( aStartInfo.GetTestId() );
SetTimeout( aStartInfo.GetTimeout() );
SetTitleL( aStartInfo.GetTitle() );
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: NewL
Description: Two-phased constructor.
Parameters: CTestRunner* aTestRunner: in: Pointer to CTestRunner
Return Values: CLoopHelper*: new object
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CLoopHelper* CLoopHelper::NewL( CTestRunner* aTestRunner )
{
CLoopHelper* self = new(ELeave)CLoopHelper( aTestRunner );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: ~CLoopHelper
Description: Destructor.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CLoopHelper::~CLoopHelper()
{
Cancel();
iInLoopSubTestCases.Reset();
iInLoopSubTestCases.Close();
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: CLoopHelper
Description: Constructor.
Parameters: CTestRunner* aTestRunner: in: Pointer to CTestRunner
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CLoopHelper::CLoopHelper( CTestRunner* aTestRunner )
:CActive( EPriorityStandard ), iTestRunner( aTestRunner )
{
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: ConstructL
Description: Two-phased constructor.
Parameters: None
Return Values: None
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::ConstructL()
{
CActiveScheduler::Add( this );
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: LoopStartL
Description: Should be to indicate loop start.
Parameters: None
Return Values: None
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::LoopStartL()
{
IterationBeginL( ETrue );
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: IterationEndStartNextIterationL
Description: Should be called to indicate end of iteration and begining of next iteration
Parameters: None
Return Values: None
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::IterationEndStartNextIterationL()
{
IterationEndL( EFalse );
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: LoopEndL
Description: Should be called to indicate loop end
Parameters: None
Return Values: None
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::LoopEndL()
{
IterationEndL( ETrue );
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: IterationBeginL
Description: Indicate begining of the loop iteration
Parameters: TBool aFirstIteration: in: Indicates if it is first iteration
Return Values: None
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::IterationBeginL( TBool aFirstIteration )
{
// Check if it is first iteration. If yes then reset CLoopHelper state
if ( aFirstIteration )
{
if ( iInProgress )
{
User::Leave( KErrInUse );
}
iPassedIterationsCounter = 0;
iInProgress = ETrue;
iLoopEnd = EFalse;
}
// Check for invalid calls order
if ( iIterationOngoing )
{
User::Leave( KErrInUse );
}
iIterationOngoing = ETrue;
iPassCurrentIteration = ETrue;
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: IterationEndL
Description: Indicate end of the loop iteration
Parameters: TBool aLastIteration: in: Indicates if it is last iteration
Return Values: None
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::IterationEndL( TBool aLastIteration )
{
// Perform tests to check if methods were called in proper order
if ( IsActive() )
{
User::Leave( KErrInUse );
}
if ( !( iInProgress && iIterationOngoing ) )
{
User::Leave( KErrNotReady );
}
if ( aLastIteration )
{
iLoopEnd = ETrue;
}
// It is end of loop iteration. Wait for all sub test cases executed inside loop
// to finish its execution.
iStatus = KRequestPending;
SetActive();
if ( iInLoopSubTestCases.Count() == 0 )
{
// All sub test cases executed inside loop are already finished.
// Schedule activation of CTestRunner to continue script execution after endloop keyword
// ( it is done in CLoopHelper::RunL )
TRequestStatus* status = &iStatus;
User::RequestComplete( status, KErrNone );
}
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: RegisterInLoopSubTestCaseL
Description: Should be called to register sub test case executed inside loop
Parameters: CSubTestCaseRunner* aSubTestCaseRunner: in: Sub test case runner
to be registered
Return Values: None
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::RegisterInLoopSubTestCaseL( CSubTestCaseRunner* aSubTestCaseRunner )
{
// Check if loop iteration is ongoing
if ( !( iInProgress && iIterationOngoing ) )
{
User::Leave( KErrNotReady );
}
iInLoopSubTestCases.AppendL( aSubTestCaseRunner );
}
void CLoopHelper::UnregisterInLoopSubTestCaseL( CSubTestCaseRunner* aSubTestCaseRunner )
{
// Check if loop iteration is ongoing
if ( !( iInProgress && iIterationOngoing ) )
{
User::Leave( KErrNotReady );
}
TInt idx = iInLoopSubTestCases.Find( aSubTestCaseRunner );
if ( idx >= 0 )
{
iInLoopSubTestCases.Remove( idx );
}
}
void CLoopHelper::RegisterInLoopSlaveL( CSlave* aSlave )
{
// Check if loop iteration is ongoing
if ( !( iInProgress && iIterationOngoing ) )
{
User::Leave( KErrNotReady );
}
iInLoopSlaves.AppendL( aSlave );
}
void CLoopHelper::UnregisterInLoopSlaveL( CSlave* aSlave )
{
// Check if loop iteration is ongoing
if ( !( iInProgress && iIterationOngoing ) )
{
User::Leave( KErrNotReady );
}
TInt idx = iInLoopSlaves.Find( aSlave );
if ( idx >= 0 )
{
iInLoopSlaves.Remove( idx );
}
}
RPointerArray<CSlave>& CLoopHelper::GetRegisteredInLoopSlaves()
{
return iInLoopSlaves;
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: NotifySubTestCaseEndL
Description: Should be called to indicate end of sub test case executed inside loop
Parameters: CSubTestCaseRunner* aSubTestCaseRunner: in: Sub test case which ended
TBool aPassed: in: Indicates if test case passed or not
Return Values: None
Errors/Exceptions: Leaves if new or ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::NotifySubTestCaseEndL( CSubTestCaseRunner* aSubTestCaseRunner, TBool aPassed )
{
// Check if execution of the loop is ongoing
if ( !iInProgress )
{
User::Leave( KErrNotReady );
}
// Check if selected sub test case was executed inside loop
TInt idx = iInLoopSubTestCases.Find( aSubTestCaseRunner );
if ( idx >= 0 )
{
iInLoopSubTestCases.Remove( idx );
if ( !aPassed )
{
iPassCurrentIteration = EFalse;
}
// Check if there are other ont finished sub test cases executed inside loop
if ( iInLoopSubTestCases.Count() == 0 )
{
// Check if CLoopHelper is active.
if ( IsActive() )
{
// CLoopHelper is active. It means that IterationEndL method was called
// and CTestRunner currently waiting for sub test end before executing next
// iteration of the loop. Since all sub test cases executed inside lopp are
// already finished we can activate CTestRunner ( it is done in CLoopHelper::RunL )
TRequestStatus* status = &iStatus;
User::RequestComplete( status, KErrNone );
}
}
}
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: LoopInProgress
Description: Indicates if loop execution is in progress
Parameters: None
Return Values: True if loop is in progress.
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TBool CLoopHelper::LoopInProgress() const
{
return iInProgress;
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: DoCancel
Description: See CActive::DoCancel
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::DoCancel()
{
TRequestStatus* status = &iStatus;
User::RequestComplete( status, KErrCancel );
}
/*
-------------------------------------------------------------------------------
Class: CLoopHelper
Method: RunL
Description: See CActive::RunL
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CLoopHelper::RunL()
{
// Iteration has ended and all sub test cases executed inside loop has ended.
User::LeaveIfError( iStatus.Int() );
iIterationOngoing = EFalse;
if ( iPassCurrentIteration )
{
iPassedIterationsCounter++;
}
// Activate CTestRunner to continue test case execution
iTestRunner->SetRunnerActive();
if ( iLoopEnd )
{
iTestRunner->ReleaseRemoteResourcesAllocatedInLoopL();
// It was last iteration. Report loop result to CTestRunner
iTestRunner->ReportLoopEndResultL( iPassedIterationsCounter );
// Reset CLoopHelper state
iLoopEnd = EFalse;
iInProgress = EFalse;
}
else
{
// Begin next loop iteration
IterationBeginL( EFalse );
}
}
/*
-------------------------------------------------------------------------------
Class: CSlaveInfo
Method: GetEvent
Description: Returns event with given name.
Parameters: TDesC& aEventName: in; Event name
Return Values: TEventTc: Event structure
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
//TEventTc* CSlaveInfo::GetEvent( TDesC& aEventName )
// {
//
// TInt count = iEvents.Count();
// for( TInt i = 0; i < count; i++ )
// {
// if( iEvents[i]->Name() == aEventName )
// {
// return iEvents[i];
// }
// }
// return NULL;
//
// }
#ifdef LOGGER
#undef LOGGER
#endif
#define LOGGER iLogger
/*
-------------------------------------------------------------------------------
Class: TEventTS
Method: TEventTS
Description: Default constructor
C++ default constructor can NOT contain any code, that
might leave.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TEventTS::TEventTS()
:iClientReqStatus( NULL )
{
}
/*
-------------------------------------------------------------------------------
Class: TEventTS
Method: TEventTS
Description: Parametric constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TEventTS::TEventTS( TName& aEventName )
:iClientReqStatus( NULL )
{
SetName( aEventName );
SetType( EReqEvent );
}
/*
-------------------------------------------------------------------------------
Class: TEventTS
Method: ~TEventTS
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TEventTS::~TEventTS()
{
Complete( KErrNone );
}
/*
-------------------------------------------------------------------------------
Class: TEventTS
Method: SetRequestStatus
Description: Set request status member.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void TEventTS::SetRequestStatus( TRequestStatus* aStatus )
{
iClientReqStatus = aStatus;
*iClientReqStatus = KRequestPending;
}
/*
-------------------------------------------------------------------------------
Class: TEventTS
Method: Complete
Description: Complete request status member.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void TEventTS::Complete( TInt aError )
{
if( iClientReqStatus )
{
User::RequestComplete( iClientReqStatus, aError );
}
}
/*
-------------------------------------------------------------------------------
Class: TEventTS
Method: SetEvent
Description: Set event pending.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void TEventTS::SetEvent( TEventType aEventType )
{
SetEventType( aEventType );
if( iClientReqStatus )
{
Complete( KErrNone );
if( EventType() == EState )
{
SetType( ESetEvent ) ;
}
}
else
{
SetType( ESetEvent ) ;
}
}
/*
-------------------------------------------------------------------------------
Class: TEventTS
Method: WaitEvent
Description: Wait event.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void TEventTS::WaitEvent( TRequestStatus& aStatus )
{
SetRequestStatus( &aStatus );
if( Type() == ESetEvent )
{
Complete( KErrNone );
if( EventType() == EIndication )
{
SetType( EReqEvent );
}
}
}
CRemoteCallsProxy* CRemoteCallsProxy::NewL( CTestModuleIf& aTestModuleIf, CStifLogger* aLogger )
{
CRemoteCallsProxy* self = new(ELeave)CRemoteCallsProxy( aTestModuleIf, aLogger );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
CRemoteCallsProxy::~CRemoteCallsProxy()
{
Cancel();
iLogger = NULL;
iSlaveAllocateFreeMonitor = NULL;
iRemoteTestCasesMonitor = NULL;
iRemoteEventsMonitor = NULL;
iRemoteSendReceiveMonitor = NULL;
iReceiveErrorHandler = NULL;
}
CRemoteCallsProxy::CRemoteCallsProxy( CTestModuleIf& aTestModuleIf, CStifLogger* aLogger )
: CActive( EPriorityNormal ), iLogger( aLogger ), iTestModuleIf( aTestModuleIf )
{
CActiveScheduler::Add( this );
}
void CRemoteCallsProxy::ConstructL()
{
StartReceivingL();
}
void CRemoteCallsProxy::DoCancel()
{
iTestModuleIf.RemoteReceiveCancel();
}
void CRemoteCallsProxy::RunL()
{
RDebug::Print( _L("[STIF Master received response] %S"), &iReceivedRemoteMsg );
DispatchReceivedRemoteMsgL();
StartReceivingL();
}
TInt CRemoteCallsProxy::RunError( TInt aError )
{
if ( iReceiveErrorHandler != NULL )
{
iReceiveErrorHandler->HandleRemoteReceiveError( aError, iReceiveErrorDescription );
return KErrNone;
}
return aError;
}
void CRemoteCallsProxy::AllocateL( TUint32 aMasterId, const TDesC& aType )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Reserve message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgReserve ) );
// Srcid. i.e. master id
User::LeaveIfError(
remoteRequest->AppendId( aMasterId ) );
// DstId, broacast id
User::LeaveIfError(
remoteRequest->AppendId( 0 ) );
// Slave type
User::LeaveIfError(
remoteRequest->Append( aType ) );
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::FreeL( TUint32 aMasterId, TUint16 aSlaveId )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Release message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRelease ) );
// Srcid. i.e. master id
User::LeaveIfError(
remoteRequest->AppendId( aMasterId ) );
// DstId is device broadcast
User::LeaveIfError(
remoteRequest->AppendId( SETID( aSlaveId, 0 ) ) );
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::SendReceiveL( TUint32 aMasterId, TUint16 aSlaveId, const TDesC& aMessage )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ) );
// Srcid. i.e. master id
User::LeaveIfError( remoteRequest->AppendId( aMasterId ) );
// DstId, i.e.slave device id
User::LeaveIfError( remoteRequest->AppendId( SETID( aSlaveId, 0 ) ) );
// Run command
User::LeaveIfError( remoteRequest->Append(
CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdSendReceive ) );
// asynchronous sendreceive's parameters
if ( aMessage != KNullDesC )
{
// Append parameters
User::LeaveIfError( remoteRequest->Append( aMessage ) );
}
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::SendUnknownL( TUint32 aMasterId, TUint16 aSlaveId,
const TDesC& aCommand, const TDesC& aMessage )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ) );
// Srcid. i.e. master id
User::LeaveIfError( remoteRequest->AppendId( aMasterId ) );
// DstId, i.e.slave device id
User::LeaveIfError( remoteRequest->AppendId( SETID( aSlaveId, 0 ) ) );
// Append command name
User::LeaveIfError( remoteRequest->Append( aCommand ) );
if ( aMessage != KNullDesC )
{
// Append parameters
User::LeaveIfError( remoteRequest->Append( aMessage ) );
}
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::RunTestCaseL( TUint32 aMasterId, TUint16 aSlaveId, CStartInfo* aStartInfo )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ) );
// Srcid. i.e. master id
User::LeaveIfError( remoteRequest->AppendId( aMasterId ) );
// DstId is device broadcast
User::LeaveIfError(
remoteRequest->AppendId( SETID( aSlaveId, 0 ) ) );
// Run command
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdRun ) );
// Run parameters
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::RunParams,
CStifTFwIfProt::ERunModule,
aStartInfo->GetModuleName() ) );
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::RunParams,
CStifTFwIfProt::ERunTestcasenum,
aStartInfo->GetTestCaseNumber() ));
if( aStartInfo->GetIniFile().Length() > 0 )
{
// Initialization file
__TRACE( KMessage, (_L("ini: %S"), &aStartInfo->GetIniFile() ));
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::RunParams,
CStifTFwIfProt::ERunInifile,
aStartInfo->GetIniFile() ) );
}
if( aStartInfo->GetConfig().Length() > 0 )
{
// Initialization file
__TRACE( KMessage, (_L("config: %S"), &aStartInfo->GetConfig() ));
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::RunParams,
CStifTFwIfProt::ERunTestcasefile,
aStartInfo->GetConfig() ));
}
//Title (must be given between quotation marks in case of any spaces inside
if( aStartInfo->GetTitle().Length() > 0 )
{
__TRACE(KMessage, (_L("title: %S"), &aStartInfo->GetTitle() ) );
TName title;
title.Format(_L("\"title=%S\""), &aStartInfo->GetTitle() );
User::LeaveIfError( remoteRequest->Append( title ) );
}
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::PauseTestCaseL( TUint32 aMasterId, TUint16 aSlaveId, TUint16 aTestId )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ) );
// Srcid. i.e. master id
User::LeaveIfError(
remoteRequest->AppendId( aMasterId ) );
// DstId, i.e.slave id
User::LeaveIfError(
remoteRequest->AppendId( SETID( aSlaveId, aTestId ) ) );
// Pause command
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdPause ) );
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::ResumeTestCaseL( TUint32 aMasterId, TUint16 aSlaveId, TUint16 aTestId )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ) );
// Srcid. i.e. master id
User::LeaveIfError(
remoteRequest->AppendId( aMasterId ));
// DstId, i.e.slave id
User::LeaveIfError(
remoteRequest->AppendId( SETID( aSlaveId, aTestId ) ) );
// Resume command
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdResume ));
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::CancelTestCaseL( TUint32 aMasterId, TUint16 aSlaveId, TUint16 aTestId )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ) );
// Srcid. i.e. master id
User::LeaveIfError(
remoteRequest->AppendId( aMasterId ));
// DstId, i.e.slave id
User::LeaveIfError(
remoteRequest->AppendId( SETID( aSlaveId, aTestId ) ) );
// Cancel command
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdCancel ));
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::RequestEventL( TUint32 aMasterId, TUint16 aSlaveId, const TDesC& aEventName )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ));
// Srcid. i.e. master id
User::LeaveIfError( remoteRequest->AppendId( aMasterId ) );
// DstId, i.e.slave device id
User::LeaveIfError( remoteRequest->AppendId( SETID( aSlaveId, 0 ) ) );
// Request event
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdRequest ));
// Event name
User::LeaveIfError( remoteRequest->Append( aEventName ) );
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::SetEventL( TUint32 aMasterId, TUint16 aSlaveId, const TDesC& aEventName,
TEventIf::TEventType aEventType )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ));
// Srcid. i.e. master id
User::LeaveIfError( remoteRequest->AppendId( aMasterId ) );
// DstId, i.e.slave device id
User::LeaveIfError( remoteRequest->AppendId( SETID( aSlaveId, 0 ) ) );
// Set event
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdSetEvent ) );
// Event name
User::LeaveIfError( remoteRequest->Append( aEventName ) );
if ( aEventType == TEventIf::EState )
{
// State event
User::LeaveIfError( remoteRequest->Append( remoteRequest->EventType( aEventType ) ) );
}
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::UnsetEventL( TUint32 aMasterId, TUint16 aSlaveId, const TDesC& aEventName )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ));
// Srcid. i.e. master id
User::LeaveIfError( remoteRequest->AppendId( aMasterId ) );
// DstId, i.e.slave device id
User::LeaveIfError( remoteRequest->AppendId( SETID( aSlaveId, 0 ) ) );
// Set event
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdUnsetEvent ) );
// Event name
User::LeaveIfError( remoteRequest->Append( aEventName ) );
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::ReleaseEventL( TUint32 aMasterId, TUint16 aSlaveId, const TDesC& aEventName )
{
CStifTFwIfProt* remoteRequest = CStifTFwIfProt::NewL();
CleanupStack::PushL( remoteRequest );
remoteRequest->CreateL();
// Remote message
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote ));
// Srcid. i.e. master id
User::LeaveIfError( remoteRequest->AppendId( aMasterId ) );
// DstId, i.e.slave device id
User::LeaveIfError( remoteRequest->AppendId( SETID( aSlaveId, 0 ) ) );
// Release event
User::LeaveIfError(
remoteRequest->Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdRelease ));
// Event name
User::LeaveIfError( remoteRequest->Append( aEventName ) );
RDebug::Print( _L("[STIF Master sending request] %S"), &remoteRequest->Message() );
User::LeaveIfError(
iTestModuleIf.RemoteSend( remoteRequest->Message() ) );
CleanupStack::PopAndDestroy( remoteRequest );
}
void CRemoteCallsProxy::SetSlaveAllocateFreeMonitor( MSlaveAllocateFreeMonitor* aSlaveAllocateFreeMonitor )
{
iSlaveAllocateFreeMonitor = aSlaveAllocateFreeMonitor;
}
void CRemoteCallsProxy::SetRemoteTestCasesMonitor( MRemoteTestCasesMonitor* aRemoteTestCasesMonitor )
{
iRemoteTestCasesMonitor = aRemoteTestCasesMonitor;
}
void CRemoteCallsProxy::SetRemoteEventsMonitor( MRemoteEventsMonitor* aRemoteEventsMonitor )
{
iRemoteEventsMonitor = aRemoteEventsMonitor;
}
void CRemoteCallsProxy::SetRemoteSendReceiveMonitor( MRemoteSendReceiveMonitor* aRemoteSendReceiveMonitor )
{
iRemoteSendReceiveMonitor = aRemoteSendReceiveMonitor;
}
void CRemoteCallsProxy::SetReceiveErrorHandler( MReceiveErrorHandler* aReceiveErrorHandler )
{
iReceiveErrorHandler = aReceiveErrorHandler;
}
void CRemoteCallsProxy::StartReceivingL()
{
iTestModuleIf.RemoteReceive( iReceivedRemoteMsg, iStatus );
SetActive();
}
void CRemoteCallsProxy::DispatchReceivedRemoteMsgL()
{
_LIT( KErrMsg, "Error during slave respons handling");
iReceiveErrorDescription = KErrMsg;
CStifTFwIfProt* msg = CStifTFwIfProt::NewL();
CleanupStack::PushL( msg );
TRAPD( err, msg->SetL( iReceivedRemoteMsg ); );
if( err != KErrNone )
{
__TRACE( KError, (_L("Response parsing failed")));
User::Leave( err );
}
// Check protocol identifiers
if( ( msg->SrcDevId() == 0 ) ||
( msg->DstDevId() == 0 ) ||
( msg->DstTestId() == 0 ) )
{
__TRACE( KError, (_L("Illegal deviceid received")));
User::Leave( KErrGeneral );
}
// This is master, cannot receive anything else but responses
if( msg->iMsgType != CStifTFwIfProt::EMsgResponse )
{
__TRACE( KError, (_L("Illegal message received %d"),
msg->iMsgType ));
User::Leave( KErrGeneral );
}
switch( msg->iRespType )
{
case CStifTFwIfProt::EMsgReserve:
{
ReceiveResponseReserveL( msg );
}
break;
case CStifTFwIfProt::EMsgRelease:
{
ReceiveResponseReleaseL( msg );
}
break;
case CStifTFwIfProt::EMsgRemote:
{
__TRACE( KMessage, (_L("ReceiveResponse Remote")));
switch( msg->iCmdType )
{
case CStifTFwIfProt::ECmdRun:
ReceiveResponseRunL( msg );
break;
case CStifTFwIfProt::ECmdPause:
case CStifTFwIfProt::ECmdResume:
case CStifTFwIfProt::ECmdCancel:
ReceiveResponseTestCtlL( msg );
break;
case CStifTFwIfProt::ECmdRequest:
case CStifTFwIfProt::ECmdRelease:
case CStifTFwIfProt::ECmdSetEvent:
case CStifTFwIfProt::ECmdUnsetEvent:
ReceiveResponseEventCtlL( msg );
break;
case CStifTFwIfProt::ECmdSendReceive:
ReceiveResponseSendReceiveL( msg );
break;
default:
ReceiveResponseSendUnknownL( msg );
break;
}
}
break;
default:
User::Leave( KErrGeneral );
}
CleanupStack::PopAndDestroy( msg );
iReceiveErrorDescription = KNullDesC;
}
void CRemoteCallsProxy::ReceiveResponseReserveL( CStifTFwIfProt* aMsg )
{
_LIT( KErrMsg, "Error during slave allocate respons handling");
__TRACE( KMessage, (_L("ReceiveResponse Reserve")));
// Check protocol Src test id
if( aMsg->SrcTestId() != 0 )
{
__TRACE( KError, (_L("Illegal deviceid received")));
User::Leave( KErrGeneral );
}
if( aMsg->iResult != KErrNone )
{
__TRACE( KError, (_L("Response with error %d"), aMsg->iResult ));
User::Leave( aMsg->iResult );
}
iReceiveErrorDescription = KErrMsg;
iSlaveAllocateFreeMonitor->NotifySlaveAllocatedL( aMsg->SrcDevId() );
iReceiveErrorDescription = KNullDesC;
__TRACE( KMessage, (_L("Slave allocated succesfully, continue execution")));
}
void CRemoteCallsProxy::ReceiveResponseReleaseL( CStifTFwIfProt* aMsg )
{
_LIT( KErrMsg, "Error during slave release respons handling");
__TRACE( KMessage, (_L("ReceiveResponse Release")));
// Check protocol Src test id
if( aMsg->SrcTestId() != 0 )
{
__TRACE( KError, (_L("Illegal deviceid received")));
User::Leave( KErrGeneral );
}
if( aMsg->iResult != KErrNone )
{
__TRACE( KError, (_L("Response with error %d"), aMsg->iResult ));
User::Leave( aMsg->iResult );
}
iReceiveErrorDescription = KErrMsg;
iSlaveAllocateFreeMonitor->NotifySlaveFreedL( aMsg->SrcDevId() );
iReceiveErrorDescription = KNullDesC;
__TRACE( KMessage, (_L("Slave freed succesfully, continue execution")));
}
void CRemoteCallsProxy::ReceiveResponseRunL( CStifTFwIfProt* aMsg )
{
_LIT( KErrMsgRun, "Error during remote sub test casse run respons handling");
TPtrC tmp = CStifTFwIfProt::RunStatus( aMsg->iRunStatus );
__TRACE( KMessage, (_L("ReceiveResponse Remote Run %S"), &tmp ));
if ( iRemoteTestCasesMonitor == NULL )
{
return;
}
switch( aMsg->iRunStatus )
{
case CStifTFwIfProt::ERunStarted:
{
iReceiveErrorDescription = KErrMsgRun;
iRemoteTestCasesMonitor->NotifyTestCaseStartedL( aMsg->SrcDevId(), aMsg->SrcTestId() );
iReceiveErrorDescription = KNullDesC;
}
break;
case CStifTFwIfProt::ERunError:
case CStifTFwIfProt::ERunReady:
{
TFullTestResult testCaseResult;
switch( aMsg->iResultCategory )
{
case CStifTFwIfProt::EResultNormal:
testCaseResult.iCaseExecutionResultType =
TFullTestResult::ECaseExecuted;
testCaseResult.iTestResult.iResult = aMsg->iResult;
testCaseResult.iCaseExecutionResultCode = 0;
break;
case CStifTFwIfProt::EResultPanic:
testCaseResult.iCaseExecutionResultType =
TFullTestResult::ECasePanic;
testCaseResult.iTestResult.iResult = KErrGeneral;
testCaseResult.iCaseExecutionResultCode = aMsg->iResult;
break;
case CStifTFwIfProt::EResultException:
testCaseResult.iCaseExecutionResultType =
TFullTestResult::ECaseException;
testCaseResult.iTestResult.iResult = KErrGeneral;
testCaseResult.iCaseExecutionResultCode = aMsg->iResult;
break;
case CStifTFwIfProt::EResultTimeout:
testCaseResult.iCaseExecutionResultType =
TFullTestResult::ECaseTimeout;
testCaseResult.iTestResult.iResult = KErrGeneral;
testCaseResult.iCaseExecutionResultCode = aMsg->iResult;
break;
case CStifTFwIfProt::EResultLeave:
testCaseResult.iCaseExecutionResultType =
TFullTestResult::ECaseLeave;
testCaseResult.iTestResult.iResult = KErrGeneral;
testCaseResult.iCaseExecutionResultCode = aMsg->iResult;
break;
default:
User::Leave( KErrGeneral );
}
iReceiveErrorDescription = KErrMsgRun;
if ( aMsg->iRunStatus == CStifTFwIfProt::ERunError )
{
iRemoteTestCasesMonitor->NotifyTestCaseRunErrorL( aMsg->SrcDevId(), testCaseResult );
}
else
{
iRemoteTestCasesMonitor->NotifyTestCaseFinishedL( aMsg->SrcDevId(), aMsg->SrcTestId(), testCaseResult );
}
iReceiveErrorDescription = KNullDesC;
}
break;
default:
// Should never come here
User::Leave( KErrGeneral );
}
}
void CRemoteCallsProxy::ReceiveResponseTestCtlL( CStifTFwIfProt* aMsg )
{
_LIT( KErrMsgPause, "Error during remote sub test casse pause respons handling");
_LIT( KErrMsgResume, "Error during remote sub test casse resume respons handling");
_LIT( KErrMsgCancel, "Error during remote sub test casse cancel respons handling");
if( aMsg->iResult != KErrNone )
{
__TRACE( KError, (_L("Response with error %d"), aMsg->iResult ));
User::Leave( aMsg->iResult );
}
switch( aMsg->iCmdType )
{
case CStifTFwIfProt::ECmdPause:
{
__TRACE( KMessage, (_L("ReceiveResponse Remote Pause")));
iReceiveErrorDescription = KErrMsgPause;
iRemoteTestCasesMonitor->NotifyTestCasePausedL( aMsg->SrcDevId(), aMsg->SrcTestId() );
iReceiveErrorDescription = KNullDesC;
}
break;
case CStifTFwIfProt::ECmdResume:
{
__TRACE( KMessage, (_L("ReceiveResponse Remote Resume")));
iReceiveErrorDescription = KErrMsgResume;
iRemoteTestCasesMonitor->NotifyTestCaseResumedL( aMsg->SrcDevId(), aMsg->SrcTestId() );
iReceiveErrorDescription = KNullDesC;
}
break;
case CStifTFwIfProt::ECmdCancel:
__TRACE( KMessage, (_L("ReceiveResponse Remote Cancel")));
iReceiveErrorDescription = KErrMsgCancel;
iRemoteTestCasesMonitor->NotifyTestCaseCancelledL( aMsg->SrcDevId(), aMsg->SrcTestId() );
iReceiveErrorDescription = KNullDesC;
break;
default:
// Should never come here
User::Leave( KErrGeneral );
}
}
void CRemoteCallsProxy::ReceiveResponseEventCtlL( CStifTFwIfProt* aMsg )
{
_LIT( KErrMsgRequest, "Error during remote event request respons handling");
_LIT( KErrMsgStateChanged, "Error during remote event state change respons handling");
_LIT( KErrMsgSet, "Error during remote event set respons handling");
_LIT( KErrMsgUnset, "Error during remote event unset respons handling");
_LIT( KErrMsgRelease, "Error during remote event release respons handling");
if ( iRemoteEventsMonitor == NULL )
{
return;
}
switch( aMsg->iCmdType )
{
case CStifTFwIfProt::ECmdRequest:
{
if ( ( aMsg->iEventStatus == CStifTFwIfProt::EEventSet ) ||
( aMsg->iEventStatus == CStifTFwIfProt::EEventUnset ) )
{
iReceiveErrorDescription = KErrMsgStateChanged;
iRemoteEventsMonitor->NotifyEventStateChangedL(
aMsg->SrcDevId(),
aMsg->iEventName,
aMsg->iEventStatus,
aMsg->iEventType,
aMsg->iResult
);
iReceiveErrorDescription = KNullDesC;
}
else
{
iReceiveErrorDescription = KErrMsgRequest;
iRemoteEventsMonitor->NotifyEventRequestedL(
aMsg->SrcDevId(),
aMsg->iEventName,
aMsg->iEventStatus,
aMsg->iEventType,
aMsg->iResult
);
iReceiveErrorDescription = KNullDesC;
}
}
break;
case CStifTFwIfProt::ECmdRelease:
{
iReceiveErrorDescription = KErrMsgRelease;
iRemoteEventsMonitor->NotifyEventReleasedL(
aMsg->SrcDevId(),
aMsg->iEventName,
aMsg->iResult
);
iReceiveErrorDescription = KNullDesC;
}
break;
case CStifTFwIfProt::ECmdSetEvent:
{
iReceiveErrorDescription = KErrMsgSet;
iRemoteEventsMonitor->NotifyEventSetCompletedL(
aMsg->SrcDevId(),
aMsg->iEventName,
aMsg->iResult
);
iReceiveErrorDescription = KNullDesC;
}
break;
case CStifTFwIfProt::ECmdUnsetEvent:
{
iReceiveErrorDescription = KErrMsgUnset;
iRemoteEventsMonitor->NotifyEventUnsetCompletedL(
aMsg->SrcDevId(),
aMsg->iEventName,
aMsg->iResult
);
iReceiveErrorDescription = KNullDesC;
}
break;
default:
// Should never come here
User::Leave( KErrGeneral );
}
}
void CRemoteCallsProxy::ReceiveResponseSendReceiveL( CStifTFwIfProt* aMsg )
{
_LIT( KErrMsgStarted, "Error during remote sendreceive started respons handling");
_LIT( KErrMsgResult, "Error during remote sendreceive result respons handling");
if ( iRemoteSendReceiveMonitor == NULL )
{
return;
}
switch( aMsg->iRunStatus )
{
case CStifTFwIfProt::ERunStarted:
{
iReceiveErrorDescription = KErrMsgStarted;
iRemoteSendReceiveMonitor->NotifySendReceiveStartedL( aMsg->SrcDevId() );
iReceiveErrorDescription = KNullDesC;
break;
}
case CStifTFwIfProt::ERunError:
case CStifTFwIfProt::ERunReady:
{
iReceiveErrorDescription = KErrMsgResult;
iRemoteSendReceiveMonitor->NotifySendReceiveResultL(
aMsg->SrcDevId(),
aMsg->iRunStatus,
aMsg->iResult );
iReceiveErrorDescription = KNullDesC;
break;
}
default:
{
// Should never come here
User::Leave( KErrGeneral );
}
}
}
void CRemoteCallsProxy::ReceiveResponseSendUnknownL( CStifTFwIfProt* aMsg )
{
_LIT( KErrMsg, "Error during remote send unknown respons handling");
if ( iRemoteSendReceiveMonitor == NULL )
{
return;
}
iReceiveErrorDescription = KErrMsg;
iRemoteSendReceiveMonitor->NotifySendUnknownL( aMsg->SrcDevId(), aMsg->iResult );
iReceiveErrorDescription = KNullDesC;
}
CSlave* CSlave::NewL()
{
CSlave* self = new(ELeave)CSlave;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
CSlave::~CSlave()
{
iSubTestCases.Reset(); // CSlave does not own sub test cases objects
iSubTestCases.Close();
iEvents.ResetAndDestroy();
iEvents.Close();
delete iNestedASLoop;
iNestedASLoop = NULL;
delete iName;
iName = NULL;
}
CSlave::CSlave()
{
}
void CSlave::ConstructL()
{
iName = HBufC::NewL( 0 );
iNestedASLoop = new(ELeave)CActiveSchedulerWait;
}
const TDesC& CSlave::GetName() const
{
return *iName;
}
void CSlave::SetNameL( const TDesC& aName )
{
HBufC* tmp = aName.AllocL();
delete iName;
iName = tmp;
}
TUint32 CSlave::GetMasterId() const
{
return iMasterId;
}
void CSlave::SetMasterId( TUint32 aMasterId )
{
iMasterId = aMasterId;
}
TUint16 CSlave::GetSlaveId() const
{
return iSlaveId;
}
TBool CSlave::HasRunningTestCases() const
{
if ( iSubTestCases.Count() > 0 )
{
return ETrue;
}
return EFalse;
}
void CSlave::RegisterSubTestCaseL( CRemoteSubTestCaseRunner* aSubTestCase )
{
iSubTestCases.AppendL( aSubTestCase );
}
void CSlave::UnregisterSubTestCaseL( CRemoteSubTestCaseRunner* aSubTestCase )
{
TInt idx = iSubTestCases.Find( aSubTestCase );
if ( idx >= 0 )
{
iSubTestCases.Remove( idx );
}
else
{
User::Leave( KErrNotFound );
}
if ( ( !HasRunningTestCases() ) && iNestedASLoop->IsStarted() )
{
iNestedASLoop->AsyncStop();
}
}
RPointerArray<CRemoteSubTestCaseRunner>& CSlave::GetSubTestCases()
{
return iSubTestCases;
}
void CSlave::WaitForSubTestCasesL()
{
if ( iNestedASLoop->IsStarted() )
{
User::Leave( KErrInUse );
}
if ( !HasRunningTestCases() )
{
return;
}
iNestedASLoop->Start();
}
void CSlave::CancelWaitForSubTestCases()
{
iNestedASLoop->AsyncStop();
}
void CSlave::AddEventL( TEventTS* aEvent )
{
iEvents.AppendL( aEvent );
}
void CSlave::RemoveEventL( TEventTS* aEvent )
{
TInt idx = iEvents.Find( aEvent );
if ( idx >= 0 )
{
iEvents.Remove( idx );
}
else
{
User::Leave( KErrNotFound );
}
}
TEventTS* CSlave::GetEvent( const TDesC& aName )
{
for ( TInt i = 0; i < iEvents.Count(); i++ )
{
if ( iEvents[ i ]->Name() == aName )
{
return iEvents[ i ];
}
}
return NULL;
}
RPointerArray<TEventTS>& CSlave::GetEvents()
{
return iEvents;
}
#ifdef LOGGER
#undef LOGGER
#endif
#define LOGGER iTestRunner->GetLogger()
void CSlave::SetSlaveId( TUint16 aSlaveId )
{
iSlaveId = aSlaveId;
}
CSlavesManager* CSlavesManager::NewL( CTestRunner* aTestRunner, CTestModuleIf& aTestModuleIf )
{
CSlavesManager* self = new(ELeave)CSlavesManager( aTestRunner, aTestModuleIf );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
CSlavesManager::~CSlavesManager()
{
Cancel();
iOperationTimeoutTimer.Close();
iRemoteCallsProxy->Cancel();
delete iSlaveForAllocate;
iSlaveForAllocate = NULL;
iSlaves.ResetAndDestroy();
iSlaves.Close();
delete iNestedASLoop;
iNestedASLoop = NULL;
delete iRemoteCallsProxy;
iRemoteCallsProxy = NULL;
}
CSlavesManager::CSlavesManager( CTestRunner* aTestRunner, CTestModuleIf& aTestModuleIf )
:CActive( EPriorityNormal ), iTestRunner( aTestRunner ),
iTestModuleIf( aTestModuleIf ), iOperationTimeout( 30000000 )
{
CActiveScheduler::Add( this );
}
void CSlavesManager::ConstructL()
{
iOperationTimeoutTimer.CreateLocal();
iRemoteCallsProxy = CRemoteCallsProxy::NewL( iTestModuleIf, LOGGER );
iNestedASLoop = new(ELeave)CActiveSchedulerWait;
iRemoteCallsProxy->SetReceiveErrorHandler( this );
iRemoteCallsProxy->SetSlaveAllocateFreeMonitor( this );
iRemoteCallsProxy->SetRemoteTestCasesMonitor( this );
iRemoteCallsProxy->SetRemoteEventsMonitor( this );
iRemoteCallsProxy->SetRemoteSendReceiveMonitor( this );
}
void CSlavesManager::SlaveAllocateL( const TDesC& aName, const TDesC& aType )
{
if ( iOperation != ESMOIdle )
{
User::Leave( KErrInUse );
}
if ( GetSlave( aName ) != NULL )
{
User::Leave( KErrAlreadyExists );
}
delete iSlaveForAllocate;
iSlaveForAllocate = NULL;
CSlave* slaveForAllocate = CSlave::NewL();
CleanupStack::PushL( slaveForAllocate );
slaveForAllocate->SetNameL( aName );
slaveForAllocate->SetMasterId( KRemoteProtocolMasterId );
iRemoteCallsProxy->AllocateL( KRemoteProtocolMasterId, aType );
CleanupStack::Pop( slaveForAllocate );
iSlaveForAllocate = slaveForAllocate;
iOperation = ESMOSlaveAllocate;
iLastOperationResult = KErrNone;
iOperationTimeoutTimer.After( iStatus, iOperationTimeout );
SetActive();
iNestedASLoop->Start();
User::LeaveIfError( iLastOperationResult );
}
void CSlavesManager::SlaveFreeL( const TDesC& aName )
{
if ( iOperation != ESMOIdle )
{
User::Leave( KErrInUse );
}
CSlave* slave = GetSlave( aName );
if ( slave == NULL )
{
User::Leave( KErrNotFound );
}
if ( slave->HasRunningTestCases() )
{
}
iSlaves.Remove( iSlaves.Find( slave ) );
TUint32 masterId = slave->GetMasterId();
TUint16 slaveId = slave->GetSlaveId();
delete slave;
iRemoteCallsProxy->FreeL( masterId, slaveId );
iOperation = ESMOSlaveFree;
iLastOperationResult = KErrNone;
iOperationTimeoutTimer.After( iStatus, iOperationTimeout );
SetActive();
iNestedASLoop->Start();
User::LeaveIfError( iLastOperationResult );
}
void CSlavesManager::SendReceiveL( CSlave* aSlave, const TDesC& aMessage )
{
if ( iOperation != ESMOIdle )
{
User::Leave( KErrInUse );
}
iRemoteCallsProxy->SendReceiveL( aSlave->GetMasterId(),
aSlave->GetSlaveId(), aMessage );
iOperation = ESMOSendReceiveWaitForStarted;
iOperationTimeoutTimer.After( iStatus, iOperationTimeout );
SetActive();
iNestedASLoop->Start();
User::LeaveIfError( iLastOperationResult );
}
void CSlavesManager::SendUnknownL( CSlave* aSlave, const TDesC& aCommand, const TDesC& aMessage )
{
if ( iOperation != ESMOIdle )
{
User::Leave( KErrInUse );
}
iRemoteCallsProxy->SendUnknownL( aSlave->GetMasterId(),
aSlave->GetSlaveId(), aCommand, aMessage );
iOperation = ESMOSendUnknown;
iOperationTimeoutTimer.After( iStatus, iOperationTimeout );
SetActive();
iNestedASLoop->Start();
User::LeaveIfError( iLastOperationResult );
}
CSlave* CSlavesManager::GetSlave( const TDesC& aName )
{
for ( TInt i = 0; i < iSlaves.Count(); i++ )
{
if ( iSlaves[ i ]->GetName() == aName )
{
return iSlaves[ i ];
}
}
return NULL;
}
CSlave* CSlavesManager::GetSlave( TUint16 aSlaveId )
{
for ( TInt i = 0; i < iSlaves.Count(); i++ )
{
if ( iSlaves[ i ]->GetSlaveId() == aSlaveId )
{
return iSlaves[ i ];
}
}
return NULL;
}
RPointerArray<CSlave>& CSlavesManager::GetSlaves()
{
return iSlaves;
}
CRemoteCallsProxy* CSlavesManager::GetRemoteCallsProxy()
{
return iRemoteCallsProxy;
}
void CSlavesManager::EventRequestL( CSlave* aSlave, TEventTS* aEvent )
{
if ( iOperation != ESMOIdle )
{
User::Leave( KErrInUse );
}
iEventForRequest = aEvent;
iRemoteCallsProxy->RequestEventL( aSlave->GetMasterId(),
aSlave->GetSlaveId(), iEventForRequest->Name() );
iOperation = ESMOEventRequest;
iLastOperationResult = KErrNone;
iOperationTimeoutTimer.After( iStatus, iOperationTimeout );
SetActive();
iNestedASLoop->Start();
iEventForRequest = NULL;
User::LeaveIfError( iLastOperationResult );
}
void CSlavesManager::EventReleaseL( CSlave* aSlave, const TDesC& aEventName )
{
if ( iOperation != ESMOIdle )
{
User::Leave( KErrInUse );
}
iRemoteCallsProxy->ReleaseEventL( aSlave->GetMasterId(),
aSlave->GetSlaveId(), aEventName );
iOperation = ESMOEventRelease;
iOperationTimeoutTimer.After( iStatus, iOperationTimeout );
SetActive();
iNestedASLoop->Start();
User::LeaveIfError( iLastOperationResult );
}
void CSlavesManager::EventSetL( CSlave* aSlave, const TDesC& aEventName, TEventIf::TEventType aEventType )
{
if ( iOperation != ESMOIdle )
{
User::Leave( KErrInUse );
}
iRemoteCallsProxy->SetEventL( aSlave->GetMasterId(),
aSlave->GetSlaveId(), aEventName, aEventType );
iOperation = ESMOEventSet;
iOperationTimeoutTimer.After( iStatus, iOperationTimeout );
SetActive();
iNestedASLoop->Start();
User::LeaveIfError( iLastOperationResult );
}
void CSlavesManager::EventUnsetL( CSlave* aSlave, const TDesC& aEventName )
{
if ( iOperation != ESMOIdle )
{
User::Leave( KErrInUse );
}
iRemoteCallsProxy->UnsetEventL( aSlave->GetMasterId(),
aSlave->GetSlaveId(), aEventName );
iOperation = ESMOEventUnset;
iOperationTimeoutTimer.After( iStatus, iOperationTimeout );
SetActive();
iNestedASLoop->Start();
User::LeaveIfError( iLastOperationResult );
}
void CSlavesManager::NotifySlaveAllocatedL( TUint16 aSlaveId )
{
Cancel(); // Stop operation timeout monitor
if( iOperation != ESMOSlaveAllocate )
{
iLastOperationResult = KErrNotReady;
delete iSlaveForAllocate;
iSlaveForAllocate = NULL;
User::Leave( KErrNotReady );
}
else
{
iSlaveForAllocate->SetSlaveId( aSlaveId );
iSlaves.AppendL( iSlaveForAllocate );
iSlaveForAllocate = NULL;
iLastOperationResult = KErrNone;
}
iOperation = ESMOIdle;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::NotifySlaveFreedL( TUint16 /*aSlaveId*/ )
{
Cancel(); // Stop operation timeout monitor
if( iOperation != ESMOSlaveFree )
{
User::Leave( KErrNotReady );
}
iLastOperationResult = KErrNone;
iOperation = ESMOIdle;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::NotifyTestCaseStartedL( TUint16 aSlaveId, TUint16 aSlaveTestId )
{
for ( TInt i = 0; i < iSlaves.Count(); i++ )
{
if ( iSlaves[ i ]->GetSlaveId() == aSlaveId )
{
RPointerArray<CRemoteSubTestCaseRunner>& remoteTestCases =
iSlaves[ i ]->GetSubTestCases();
for ( TInt k = 0; k < remoteTestCases.Count(); k++ )
{
if ( remoteTestCases[ k ]->IsRunSubTestCaseRequestOngoing() )
{
remoteTestCases[ k ]->NotifyTestCaseStartedL( aSlaveTestId );
// There should be only one test case which waits for
// run test case request response
return;
}
}
}
}
// There is no test case which waits for run request response
User::Leave( KErrNotFound );
}
void CSlavesManager::NotifyTestCaseRunErrorL( TUint16 aSlaveId, const TFullTestResult& aTestCaseResult )
{
for ( TInt i = 0; i < iSlaves.Count(); i++ )
{
if ( iSlaves[ i ]->GetSlaveId() == aSlaveId )
{
RPointerArray<CRemoteSubTestCaseRunner>& remoteTestCases =
iSlaves[ i ]->GetSubTestCases();
for ( TInt k = 0; k < remoteTestCases.Count(); k++ )
{
if ( remoteTestCases[ k ]->IsRunSubTestCaseRequestOngoing() )
{
remoteTestCases[ k ]->NotifyTestCaseRunError( aTestCaseResult );
// There should be only one test case which waits for
// run test case request response
return;
}
}
}
}
// There is no test case which waits for run request response
User::Leave( KErrNotFound );
}
void CSlavesManager::NotifyTestCaseFinishedL( TUint16 aSlaveId, TUint16 aSlaveTestId, const TFullTestResult& aTestCaseResult )
{
for ( TInt i = 0; i < iSlaves.Count(); i++ )
{
if ( iSlaves[ i ]->GetSlaveId() == aSlaveId )
{
RPointerArray<CRemoteSubTestCaseRunner>& remoteTestCases =
iSlaves[ i ]->GetSubTestCases();
for ( TInt k = 0; k < remoteTestCases.Count(); k++ )
{
if ( remoteTestCases[ k ]->GetTestCaseId() == aSlaveTestId )
{
remoteTestCases[ k ]->NotifyTestCaseFinishedL( aTestCaseResult );
// There should be only one test case which waits for
// run test case request response
return;
}
}
}
}
// There is no test case which waits for run request response
User::Leave( KErrNotFound );
}
void CSlavesManager::NotifyTestCasePausedL( TUint16 aSlaveId, TUint16 aSlaveTestId )
{
for ( TInt i = 0; i < iSlaves.Count(); i++ )
{
if ( iSlaves[ i ]->GetSlaveId() == aSlaveId )
{
RPointerArray<CRemoteSubTestCaseRunner>& remoteTestCases =
iSlaves[ i ]->GetSubTestCases();
for ( TInt k = 0; k < remoteTestCases.Count(); k++ )
{
if ( remoteTestCases[ k ]->GetTestCaseId() == aSlaveTestId )
{
remoteTestCases[ k ]->NotifyTestCasePausedL();
// There should be only one test case which waits for
// run test case request response
return;
}
}
}
}
// There is no test case which waits for run request response
User::Leave( KErrNotFound );
}
void CSlavesManager::NotifyTestCaseResumedL( TUint16 aSlaveId, TUint16 aSlaveTestId )
{
for ( TInt i = 0; i < iSlaves.Count(); i++ )
{
if ( iSlaves[ i ]->GetSlaveId() == aSlaveId )
{
RPointerArray<CRemoteSubTestCaseRunner>& remoteTestCases =
iSlaves[ i ]->GetSubTestCases();
for ( TInt k = 0; k < remoteTestCases.Count(); k++ )
{
if ( remoteTestCases[ k ]->GetTestCaseId() == aSlaveTestId )
{
remoteTestCases[ k ]->NotifyTestCaseResumedL();
// There should be only one test case which waits for
// run test case request response
return;
}
}
}
}
// There is no test case which waits for run request response
User::Leave( KErrNotFound );
}
void CSlavesManager::NotifyTestCaseCancelledL( TUint16 aSlaveId, TUint16 aSlaveTestId )
{
for ( TInt i = 0; i < iSlaves.Count(); i++ )
{
if ( iSlaves[ i ]->GetSlaveId() == aSlaveId )
{
RPointerArray<CRemoteSubTestCaseRunner>& remoteTestCases =
iSlaves[ i ]->GetSubTestCases();
for ( TInt k = 0; k < remoteTestCases.Count(); k++ )
{
if ( remoteTestCases[ k ]->GetTestCaseId() == aSlaveTestId )
{
remoteTestCases[ k ]->NotifyTestCaseCancelledL();
// There should be only one test case which waits for
// run test case request response
return;
}
}
}
}
// There is no test case which waits for run request response
User::Leave( KErrNotFound );
}
void CSlavesManager::NotifyEventRequestedL( TUint16 /*aSlaveId*/,
const TDesC& aEventName,
CStifTFwIfProt::TEventStatus aEventStatus,
TEventIf::TEventType /*aEventType*/,
TInt aResult )
{
if ( iOperation != ESMOEventRequest )
{
User::Leave( KErrNotReady );
}
Cancel(); // Stop operation timeout monitor
iLastOperationResult = KErrNone;
switch( aEventStatus )
{
case CStifTFwIfProt::EEventActive:
__TRACE( KMessage, (_L("Event %S active"), &aEventName ));
break;
case CStifTFwIfProt::EEventError:
__TRACE( KMessage, (_L("Event %S error %d"), &aEventName, aResult ));
iLastOperationResult = aResult;
break;
default:
User::Leave( KErrGeneral );
}
iOperation = ESMOIdle;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::NotifyEventStateChangedL( TUint16 aSlaveId,
const TDesC& aEventName,
CStifTFwIfProt::TEventStatus aEventStatus,
TEventIf::TEventType aEventType,
TInt aResult )
{
switch( aEventStatus )
{
case CStifTFwIfProt::EEventSet:
{
__TRACE( KMessage, (_L("Event %S set"), &aEventName ));
// Set event
CSlave* slave = GetSlave( aSlaveId );
if ( slave != NULL )
{
TEventTS* event = slave->GetEvent( aEventName );
if ( event != NULL )
{
event->SetEvent( aEventType );
}
else
{
User::Leave( KErrNotFound );
}
}
else
{
User::Leave( KErrNotFound );
}
}
break;
case CStifTFwIfProt::EEventUnset:
{
__TRACE( KMessage, (_L("Event %S set"), &aEventName ));
// Set event
CSlave* slave = GetSlave( aSlaveId );
if ( slave != NULL )
{
TEventTS* event = slave->GetEvent( aEventName );
if ( event != NULL )
{
event->SetType( TEventIf::EUnsetEvent );
}
else
{
User::Leave( KErrNotFound );
}
}
else
{
User::Leave( KErrNotFound );
}
}
break;
case CStifTFwIfProt::EEventError:
{
__TRACE( KMessage, (_L("Event %S error %d"), &aEventName, aResult ));
User::Leave( aResult );
}
break;
default:
{
User::Leave( KErrGeneral );
}
}
}
void CSlavesManager::NotifyEventReleasedL( TUint16 /*aSlaveId*/,
const TDesC& /*aEventName*/, TInt aResult )
{
if ( iOperation != ESMOEventRelease )
{
User::Leave( KErrNotReady );
}
Cancel(); // Stop operation timeout monitor
iOperation = ESMOIdle;
iLastOperationResult = aResult;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::NotifyEventSetCompletedL( TUint16 /*aSlaveId*/,
const TDesC& /*aEventName*/, TInt aResult )
{
if ( iOperation != ESMOEventSet )
{
User::Leave( KErrNotReady );
}
Cancel(); // Stop operation timeout monitor
iOperation = ESMOIdle;
iLastOperationResult = aResult;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::NotifyEventUnsetCompletedL( TUint16 /*aSlaveId*/,
const TDesC& /*aEventName*/, TInt aResult )
{
if ( iOperation != ESMOEventUnset )
{
User::Leave( KErrNotReady );
}
Cancel(); // Stop operation timeout monitor
iOperation = ESMOIdle;
iLastOperationResult = aResult;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::NotifySendReceiveStartedL( TUint16 /*aSlaveId*/ )
{
if ( iOperation != ESMOSendReceiveWaitForStarted )
{
User::Leave( KErrNotReady );
}
Cancel(); // Stop operation timeout monitor
iOperation = ESMOSendReceiveWaitForReady;
}
void CSlavesManager::NotifySendReceiveResultL(
TUint16 /*aSlaveId*/,
CStifTFwIfProt::TRunStatus /*aRunStatus*/,
TInt aRunResult )
{
if ( ( iOperation != ESMOSendReceiveWaitForStarted ) &&
( iOperation != ESMOSendReceiveWaitForReady ) )
{
User::Leave( KErrNotReady );
}
iLastOperationResult = aRunResult;
if ( iOperation == ESMOSendReceiveWaitForStarted )
{
Cancel(); // Stop operation timeout monitor
}
iOperation = ESMOIdle;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::NotifySendUnknownL( TUint16 aSlaveId, TInt aResult )
{
if ( iOperation != ESMOSendUnknown )
{
User::Leave( KErrNotReady );
}
Cancel(); // Stop operation timeout monitor
CSlave* slave = GetSlave( aSlaveId );
if( slave == NULL )
{
User::Leave( KErrNotFound );
}
iOperation = ESMOIdle;
iLastOperationResult = aResult;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::HandleRemoteReceiveError( TInt aError, const TDesC& aErrorDescription )
{
iTestRunner->HandleRemoteReceiveError( aError, aErrorDescription );
}
void CSlavesManager::RunL()
{
// Last operation timeouted
if ( iOperation == ESMOSlaveAllocate )
{
delete iSlaveForAllocate;
iSlaveForAllocate = NULL;
}
iLastOperationResult = KErrTimedOut;
iOperation = ESMOIdle;
iNestedASLoop->AsyncStop();
}
void CSlavesManager::DoCancel()
{
iOperationTimeoutTimer.Cancel();
}
// EOF