diff -r b183ec05bd8c -r 19bba8228ff0 devicediagnosticsfw/diagframework/src/diagexecplanentryimpltest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/devicediagnosticsfw/diagframework/src/diagexecplanentryimpltest.cpp Wed Sep 01 12:27:42 2010 +0100 @@ -0,0 +1,857 @@ +/* +* Copyright (c) 2007 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: Class definition of CDiagExecPlanEntryImplTest +* +*/ + + +// CLASS DECLARATION +#include "diagexecplanentryimpltest.h" + +// SYSTEM INCLUDE FILES +#include // MDiagPlugin +#include // MDiagTestPlugin +#include // LOGSTRING +#include // CDiagResultsDbItemBuilder +#include // TDiagTestExecParam +#include // RDiagResultsDatabaseRecord + +// USER INCLUDE FILES +#include "diagframework.pan" // Panic Codes +#include "diagexecplanentryimplobserver.h" // MDiagExecPlanEntryImplObserver +#include "diagengineconfig.h" // TDiagEngineConfig + + +// DATA + +// MACROS + +// LOCAL DATA TYPES + + +// ======== LOCAL FUNCTIONS ======== + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::NewL +// --------------------------------------------------------------------------- +// +CDiagExecPlanEntryImplTest* CDiagExecPlanEntryImplTest::NewL( + MDiagEngineCommon& aEngine, + const TDiagEngineConfig& aEngineConfig, + MDiagExecPlanEntryImplObserver& aObserver, + MDiagTestPlugin& aPlugin, + TBool aAsDependency, + CDiagResultsDatabaseItem::TResult aResult ) + { + CDiagExecPlanEntryImplTest* self = NewLC( aEngine, + aEngineConfig, + aObserver, + aPlugin, + aAsDependency, + aResult ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::NewLC +// --------------------------------------------------------------------------- +// +CDiagExecPlanEntryImplTest* CDiagExecPlanEntryImplTest::NewLC( + MDiagEngineCommon& aEngine, + const TDiagEngineConfig& aEngineConfig, + MDiagExecPlanEntryImplObserver& aObserver, + MDiagTestPlugin& aPlugin, + TBool aAsDependency, + CDiagResultsDatabaseItem::TResult aResult ) + { + CDiagExecPlanEntryImplTest* self = + new ( ELeave ) CDiagExecPlanEntryImplTest ( aEngine, + aEngineConfig, + aObserver, + aPlugin, + aAsDependency, + aResult ); + CleanupStack::PushL( self ); + return self; + } + + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::CDiagExecPlanEntryImplTest +// --------------------------------------------------------------------------- +// +CDiagExecPlanEntryImplTest::CDiagExecPlanEntryImplTest( + MDiagEngineCommon& aEngine, + const TDiagEngineConfig& aEngineConfig, + MDiagExecPlanEntryImplObserver& aObserver, + MDiagTestPlugin& aPlugin, + TBool aAsDependency, + CDiagResultsDatabaseItem::TResult aResult ) + : CDiagExecPlanEntryImpl( + aEngine, + aEngineConfig, + aObserver, + aPlugin, + aAsDependency, + ETypeTestExec ), + iResult( aResult ) + { + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::~CDiagExecPlanEntryImplTest +// --------------------------------------------------------------------------- +// +CDiagExecPlanEntryImplTest::~CDiagExecPlanEntryImplTest() + { + StopAll(); // deletes timer as well. + if ( CDiagExecPlanEntryImpl::State() != EStateCompleted ) + { + // TRAP is needed since this is being called in destructor. + TRAP_IGNORE( StopExecutionAndIgnoreResultL() ) + } + delete iCachedResult; + iCachedResult = NULL; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::Result +// --------------------------------------------------------------------------- +// +CDiagResultsDatabaseItem::TResult CDiagExecPlanEntryImplTest::Result() const + { + return iResult; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::SetResult +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::SetResult( CDiagResultsDatabaseItem::TResult aResult ) + { + iResult = aResult; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::TestPlugin +// --------------------------------------------------------------------------- +// +MDiagTestPlugin& CDiagExecPlanEntryImplTest::TestPlugin() + { + // It is safe to typecast here, since CDiagExecPlanEntryImplTest::NewL + // accepts only MDiagTestPlugin&. + return static_cast< MDiagTestPlugin& >( Plugin() ); + } + +// --------------------------------------------------------------------------- +// From CDiagExecPlanEntryImpl +// CDiagExecPlanEntryImplTest::ExecuteL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::ExecuteL() + { + #ifdef _DEBUG + HBufC* pluginName = Plugin().GetPluginNameL( + MDiagPlugin::ENameLayoutListSingle ); + + LOGSTRING3( "---- TEST BEGIN ---- [ 0x%08x %S ] ---- TEST BEGIN ---- {", + Plugin().Uid().iUid, + pluginName ) + delete pluginName; + pluginName = NULL; + #endif // _DEBUG + + __ASSERT_DEBUG( State() == EStateQueued, + Panic( EDiagFrameworkCorruptStateMachine ) ); + + + // Case 1) Item was already executed. (Resume scenario) + // Just go straight to EStateCompleted and let engine know that + // it was completed. + if ( Result() != CDiagResultsDatabaseItem::EQueuedToRun ) + { + // it was already executed. Report result immediately. + ChangeStateL( EStateCompleted ); + Observer().ExecPlanEntryExecutedL( *this ); + return; + } + + // Notify observer that progress is 0 so that application will know that + // plug-in execution has now started. + Observer().ExecPlanEntryProgressL( *this, 0, TestPlugin().TotalSteps() ); + + // Case 2) Initial delay was specified. Start delay timer. + if ( EngineConfig().TestPluginInitialDelay().Int() > 0 ) + { + // timer value is specified. Start timer. + ChangeStateL( EStateInitDelay ); + StopInitDelayTimer(); + iInitDelayTimer = CPeriodic::NewL( CActive::EPriorityStandard ); + iInitDelayTimer->Start( EngineConfig().TestPluginInitialDelay(), // initial delay + EngineConfig().TestPluginInitialDelay(), // repeat + TCallBack( HandleDelayTimerExpiredL, this ) ); + + return; + } + + // Case 3) Start test immediately. + DoExecuteTestPluginL(); + } + + + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::DoExecuteTestPluginL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::DoExecuteTestPluginL() + { + #ifdef _DEBUG + HBufC* pluginName = Plugin().GetPluginNameL( + MDiagPlugin::ENameLayoutListSingle ); + + LOGSTRING3( "CDiagExecPlanEntryImplTest::DoExecuteTestPluginL() " + L"Starting test plugin Uid 0x%x (%S)", + Plugin().Uid().iUid, + pluginName ) + delete pluginName; + pluginName = NULL; + #endif // _DEBUG + + // Real test starts now, so reset watchdog timer. + if ( TestPlugin().RunMode() == MDiagTestPlugin::EAutomatic ) + { + ResetWatchdog( EDiagEngineWatchdogTypeAutomatic ); + } + else + { + ResetWatchdog( EDiagEngineWatchdogTypeInteractive ); + } + + ChangeStateL( EStateRunning ); + + + // Create a result in case test fails during RunTestL(). + // It needs to be created at this point to make sure that + // test start time is recorded correctly, since RunTestL() may + // take some time to finish. + CDiagResultsDbItemBuilder* resultBuilder = + CDiagResultsDbItemBuilder::NewLC( Plugin().Uid(), AsDependency() ); + + TDiagTestExecParam* execParam = + new ( ELeave ) TDiagTestExecParam( *this, // aObserver + Engine() /* aEngine */ ); + + // Trap when calling test. This makes sure that if a test fails during + // its RunTestL(), it will automatically be marked as failed. + TRAPD( err, TestPlugin().RunTestL( execParam, // ownership changed + Engine().IsDependencyDisabled(), + AsDependency(), + Engine().CustomParam() ) ); + execParam = NULL; //lint !e423 execParam ownership changed. + + if ( err != KErrNone ) + { + // Test failure. Call stop plug-in so that it may have a chance to + // clean up, but result is not needed. Discard it and replace it with + // CDiagResultsDatabaseItem::EFailed + LOGSTRING2( "CDiagExecPlanEntryImplTest::DoExecuteTestPluginL() " + L"RunTestL() for 0x%08x failed! Mark it as FAILED and continue", + Plugin().Uid().iUid ) + + StopExecutionAndIgnoreResultL(); + resultBuilder->SetTestCompleted( CDiagResultsDatabaseItem::EFailed ); + + CDiagResultsDatabaseItem* result = resultBuilder->ToResultsDatabaseItemL(); + + // Call test execution observer as if the real test is completed. + TestExecutionCompletedL( TestPlugin(), result ); + result = NULL; // ownership transferred above. + } + + CleanupStack::PopAndDestroy( resultBuilder ); + resultBuilder = NULL; + } + +// --------------------------------------------------------------------------- +// From MDiagTestObserver +// CDiagExecPlanEntryImplTest::TestProgressL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::TestProgressL( + const MDiagTestPlugin& aSender, + TUint aCurrentStep ) + { + __ASSERT_ALWAYS( aSender.Uid() == Plugin().Uid(), Panic( EDiagFrameworkPlugin ) ); + __ASSERT_ALWAYS( aCurrentStep <= TestPlugin().TotalSteps(), Panic( EDiagFrameworkPlugin ) ); + + // TestExecutionProgressL is accepted only if we were running. + if ( State() != EStateRunning ) + { + __ASSERT_DEBUG( 0, Panic( EDiagFrameworkCorruptStateMachine ) ); + return; + } + + ResetWatchdog(); + Observer().ExecPlanEntryProgressL( *this, aCurrentStep, TestPlugin().TotalSteps() ); + } + +// --------------------------------------------------------------------------- +// From MDiagTestObserver +// CDiagExecPlanEntryImplTest::TestExecutionCompletedL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::TestExecutionCompletedL( + const MDiagTestPlugin& aSender, + CDiagResultsDatabaseItem* aTestResult ) + { + __ASSERT_ALWAYS( aSender.Uid() == Plugin().Uid(), Panic( EDiagFrameworkPlugin ) ); + __ASSERT_ALWAYS( aTestResult, Panic( EDiagFrameworkNullTestResult ) ); + + // TestExecutionCompletedL is accepted only if we were running. + if ( State() == EStateCompleted ) + { + __ASSERT_DEBUG( 0, Panic( EDiagFrameworkCorruptStateMachine ) ); + return; + } + + // For view-switching plugins, ask the application to switch the view + // back. This allows the application to be in a known state. This must + // be done before logging the test result, because that may fail. + if ( TestPlugin().RunMode() == MDiagTestPlugin::EInteractiveView ) + { + TRAP_IGNORE( Engine().ExecuteAppCommandL( + EDiagAppCommandSwitchToMainView, + NULL, + NULL ) ) + } + // Writing to db is a non interactive step. + ResetWatchdog( EDiagEngineWatchdogTypeAutomatic ); + ChangeStateL( EStateStopped ); + + + // update cache. Cached result will be available until ResultsDbItem() + // is called. + delete iCachedResult; + iCachedResult = aTestResult; + aTestResult = NULL; + + iResult = iCachedResult->TestResult(); + + Engine().DbRecord().LogTestResult( iStatus, *iCachedResult ); + SetActive(); + } + +// --------------------------------------------------------------------------- +// From CActive +// CDiagExecPlanEntryImplTest::RunL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::RunL() + { + // Currently, this object only uses one request, which is + // Engine().DbRecord().LogTestResult(), which is sent only when state is + // EStateStopped + User::LeaveIfError( iStatus.Int() ); + + ChangeStateL( EStateCompleted ); + + #ifdef _DEBUG + HBufC* pluginName = Plugin().GetPluginNameL( + MDiagPlugin::ENameLayoutListSingle ); + + LOGSTRING4( "} ---- TEST END ---- [ 0x%08x %S %S ] ---- TEST END ----", + Plugin().Uid().iUid, + pluginName, + &TestResultString( iResult ) ) + + delete pluginName; + pluginName = NULL; + #endif // _DEBUG + + // Notify engine that test is completed. + Observer().ExecPlanEntryExecutedL( *this ); + } + +// --------------------------------------------------------------------------- +// From CActive +// CDiagExecPlanEntryImplTest::DoCancel +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::DoCancel() + { + // Currently, DbRecord().LogTestResult() is the only request this uses. + Engine().DbRecord().CancelLogTestResult(); + } + +// --------------------------------------------------------------------------- +// From CActive +// CDiagExecPlanEntryImplTest::RunError +// --------------------------------------------------------------------------- +// +TInt CDiagExecPlanEntryImplTest::RunError( TInt aError ) + { + Observer().ExecPlanEntryCriticalError( aError ); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::StopExecutionByWatchdogL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::StopExecutionByWatchdogL() + { + CDiagResultsDatabaseItem* result = StopTestPluginL( MDiagTestPlugin::EWatchdog ); + + if ( result == NULL ) + { + // It was not originally running, so no real result. Create + // a default that makes sense. + result = CDiagResultsDbItemBuilder::CreateSimpleDbItemL( + Plugin().Uid(), + AsDependency(), + CDiagResultsDatabaseItem::EWatchdogCancel ); + } + + TestExecutionCompletedL( TestPlugin(), result ); // ownership transferred. + result = NULL; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::DoStopExecutionByClientL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::DoStopExecutionByClientL( + MDiagEngineCommon::TCancelMode aCancelMode ) + { + MDiagTestPlugin::TStopReason stopReason; + + switch ( aCancelMode ) + { + case MDiagEngineCommon::ECancelAll: + stopReason = MDiagTestPlugin::ECancelAll; + break; + + case MDiagEngineCommon::ESkip: + stopReason = MDiagTestPlugin::ESkip; + break; + + default: + __ASSERT_DEBUG( 0, Panic( EDiagFrameworkInternal ) ); + stopReason = MDiagTestPlugin::ESkip; + break; + } + + CDiagResultsDatabaseItem* result = StopTestPluginL( stopReason ); + + if ( result == NULL ) + { + // it was not originally running, so no result was given by + // the plugin. Create one for them. + result = CDiagResultsDbItemBuilder::CreateSimpleDbItemL( + Plugin().Uid(), + AsDependency(), + CDiagResultsDatabaseItem::ESkipped ); + } + + TestExecutionCompletedL( TestPlugin(), result ); // ownership transferred. + result = NULL; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::StopExecutionAndIgnoreResultL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::StopExecutionAndIgnoreResultL() + { + CDiagResultsDatabaseItem* result = StopTestPluginL( MDiagTestPlugin::ESkip ); + delete result; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::StopTestPluginL +// --------------------------------------------------------------------------- +// +CDiagResultsDatabaseItem* CDiagExecPlanEntryImplTest::StopTestPluginL( + MDiagTestPlugin::TStopReason aReason ) + { + StopAll(); + + CDiagResultsDatabaseItem* result = NULL; + + switch ( State() ) + { + case EStateQueued: // fall through + case EStateInitDelay: + // Test was not actually running in these casese. + LOGSTRING3( "CDiagExecPlanEntryImplTest::StopTestPluginL()" + L"Plugin 0x%x. State = %d", + Plugin().Uid().iUid, + State() ) + break; + + case EStateStopped: + // Test was already completed. Return last result. + LOGSTRING3( "CDiagExecPlanEntryImplTest::StopTestPluginL()" + L"Plugin 0x%x. State = %d", + Plugin().Uid().iUid, + State() ) + result = GetLastTestResultL(); + break; + + case EStateRunning: // fall through + case EStateSuspended: + // Test was actually running in this case. + // Need to call execution stop and use result from plug-in. + LOGSTRING2( "CDiagEngineImpl::StopTestPluginL: " + L"Plugin 0x%x was in ERunning or ESuspended. Call Stop", + Plugin().Uid().iUid ) + result = TestPlugin().ExecutionStopL( aReason ); + __ASSERT_ALWAYS( result, Panic( EDiagFrameworkNullTestResult ) ); + break; + + case EStateCompleted: + default: + LOGSTRING3( "CDiagEngineImpl::StopTestPluginL: " + L"Plugin 0x%x = INVALID STATE! %d", + Plugin().Uid().iUid, + State() ) + __ASSERT_DEBUG( 0, Panic( EDiagFrameworkCorruptStateMachine ) ); + + // Use result from cache or DB. + result = GetLastTestResultL(); + break; + } + + return result; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::SuspendL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::SuspendL() + { + StopAll(); + + switch ( State() ) + { + case EStateQueued: // fall through + case EStateInitDelay: // fall through + // nothing to do. + LOGSTRING3( "CDiagExecPlanEntryImplTest::SuspendL(): " + L"Plugin 0x%08x state = %d. Was not running. Change to EQueued", + Plugin().Uid().iUid, + State() ) + + ChangeStateL( EStateQueued ); + break; + + case EStateRunning: + { + // it is currently running. suspend + LOGSTRING2( "CDiagExecPlanEntryImplTest::SuspendL(): " + L"Plugin 0x%08x = ERunning. Trying to stop", + Plugin().Uid().iUid ) + TRAPD( err, TestPlugin().SuspendL() ) + if ( err == KErrNone ) + { + LOGSTRING2( "CDiagExecPlanEntryImplTest::SuspendL(): " + L"Plugin 0x%08x Stop successful. To ESuspended", + Plugin().Uid().iUid ) + + ChangeStateL( EStateSuspended ); + } + else + { + // Suspend probably not supported. Try Stop + LOGSTRING2( "CDiagExecPlanEntryImplTest::SuspendL(): " + L"Plugin 0x%x Stop not successful. Try to Stop", + Plugin().Uid().iUid ) + + CDiagResultsDatabaseItem* result = + TestPlugin().ExecutionStopL( MDiagTestPlugin::ESkip ); + __ASSERT_ALWAYS( result, Panic( EDiagFrameworkNullTestResult ) ); + delete result; // not interested in result. + // force reset the plugin execution to queued so that + // it will be restarted + ChangeStateL( EStateQueued ); + } + } + break; + + case EStateStopped: + LOGSTRING2( "CDiagExecPlanEntryImplTest::SuspendL(): " + L"Plugin 0x%08x = EStateStopped. Do nothing.", + Plugin().Uid().iUid ) + // do nothing, When resumed, it will store temporary result to db + break; + + case EStateSuspended: + LOGSTRING2( "CDiagExecPlanEntryImplTest::SuspendL(): " + L"Plugin 0x%08x = ESuspended. Already suspended..", + Plugin().Uid().iUid ) + // do nothing. + break; + + case EStateCompleted: + // result already logged. do nothing. + LOGSTRING2( "CDiagExecPlanEntryImplTest::SuspendL(): " + L"Plugin 0x%08x = ECompleted. Stay completed.", + Plugin().Uid().iUid ) + break; + + default: + __ASSERT_DEBUG( 0, Panic( EDiagFrameworkCorruptStateMachine ) ); + } + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::ResumeL +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::ResumeL() + { + LOGSTRING3( "CDiagExecPlanEntryImplTest::ResumeL(): " + L"Plugin 0x%08x, State = %d", Plugin().Uid().iUid, State() ) + + // resumable states are: EStateQueued, EStateSuspended, EStateStopped + + switch ( State() ) + { + case EStateQueued: + ExecuteL(); + break; + + case EStateSuspended: + { + ChangeStateL( EStateRunning ); + + TestPlugin().ResumeL(); + } + break; + + case EStateStopped: + { + // There was a result not saved in DB yet. + // If test was suspended in EStopped state, there MUST BE a + // saved test result. + __ASSERT_DEBUG( iCachedResult, Panic( EDiagFrameworkInternal ) ); + + if ( iCachedResult ) //lint !e774 Will be evaluated in non DEBUG build. + { + // Simulate TestExecutionCompletedL from plug-in. + // Unset iCachedResult, since TestExecutionCompletedL() will try + // to deallocate iCachedResult. + CDiagResultsDatabaseItem* result = iCachedResult; + iCachedResult = NULL; + TestExecutionCompletedL( TestPlugin(), result ); // ownership passed + result = NULL; + } + } + break; + + default: + // already running. ignored. + break; + } + } + + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::GetLastTestResultL +// --------------------------------------------------------------------------- +// +CDiagResultsDatabaseItem* CDiagExecPlanEntryImplTest::GetLastTestResultL() + { + // Currently, cache is implemented such that calling + // GetLastTestResultL() once after test is completed will not + // require a request to DB. Any subsequent request will have to access + // database. + // + // This should satisfy most common usage of execution plan entry. + // It could be expanded to store for longer than that, however, it + // may take up too much memory if there are lots of tests in the + // execution plan. At this point, this should be sufficient. + + CDiagResultsDatabaseItem* result = NULL; + + if ( iCachedResult ) + { + if ( State() != EStateStopped ) + { + LOGSTRING2( "CDiagExecPlanEntryImplTest::GetLastTestResultL() " + L"Plugin 0x%08x. Cache hit", + Plugin().Uid().iUid ) + result = iCachedResult; + iCachedResult = NULL; + } + else + { + LOGSTRING2( "CDiagExecPlanEntryImplTest::GetLastTestResultL() " + L"Plugin 0x%08x. Cache hit, but need to duplicate.", + Plugin().Uid().iUid ) + // If we were in STOPPED state, make a copy, since it + // may not been fully written to db yet. + // Cached copy should be deleted only after it is written to db. + const CBufFlat* detailData = iCachedResult->DetailsData(); + CBufFlat* detailDataCopy = NULL; + + if ( detailData ) + { + detailDataCopy = CBufFlat::NewL( detailData->Size() ); + CleanupStack::PushL( detailDataCopy ); + + TPtr8 ptr = detailDataCopy->Ptr( 0 ); + detailData->Read( 0, ptr ); + } + + result = CDiagResultsDatabaseItem::NewL( + iCachedResult->TestUid(), + iCachedResult->WasDependency(), + iCachedResult->TestResult(), + iCachedResult->TimeStarted(), + iCachedResult->TimeCompleted(), + detailDataCopy ); + + if ( detailDataCopy ) + { + CleanupStack::Pop( detailDataCopy ); + } + } + } + else + { + LOGSTRING2( "CDiagExecPlanEntryImplTest::GetLastTestResultL() " + L"Plugin 0x%08x. Cache miss", + Plugin().Uid().iUid ) + // result was not avaiable in cache. Fetch it from database. + User::LeaveIfError( Engine().DbRecord().GetTestResult( Plugin().Uid(), result ) ); + } + + return result; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::HandleDelayTimerExpiredL +// --------------------------------------------------------------------------- +// +TInt CDiagExecPlanEntryImplTest::HandleDelayTimerExpiredL( TAny* aData ) + { + CDiagExecPlanEntryImplTest* self = static_cast< CDiagExecPlanEntryImplTest* >( aData ); + + self->StopInitDelayTimer(); + self->DoExecuteTestPluginL(); + return 0; + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::StopAll +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::StopAll() + { + Cancel(); + StopInitDelayTimer(); + StopWatchdogTemporarily(); + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::StopInitDelayTimer +// --------------------------------------------------------------------------- +// +void CDiagExecPlanEntryImplTest::StopInitDelayTimer() + { + if ( iInitDelayTimer ) + { + iInitDelayTimer->Cancel(); + delete iInitDelayTimer; + iInitDelayTimer = NULL; + } + } + +// --------------------------------------------------------------------------- +// CDiagExecPlanEntryImplTest::TestResultString +// --------------------------------------------------------------------------- +// +#ifdef _DEBUG +const TDesC& CDiagExecPlanEntryImplTest::TestResultString( + CDiagResultsDatabaseItem::TResult aResult ) + { + _LIT( KSuccess, "ESuccess" ); + _LIT( KFailed, "EFailed" ); + _LIT( KSkipped, "ESkipped" ); + _LIT( KCancelled, "ECancelled" ); + _LIT( KInterrupted, "EInterrupted" ); + _LIT( KNotPerformed, "ENotPerformed" ); + _LIT( KDependencyFailed, "EDependencyFailed" ); + _LIT( KWatchdogCancel, "EWatchdogCancel" ); + _LIT( KSuspended, "ESuspended" ); + _LIT( KQueuedToRun, "EQueuedToRun" ); + + switch( aResult ) + { + case CDiagResultsDatabaseItem::ESuccess: + return KSuccess(); + + case CDiagResultsDatabaseItem::EFailed: + return KFailed(); + + case CDiagResultsDatabaseItem::ESkipped: + return KSkipped(); + + case CDiagResultsDatabaseItem::ECancelled: + return KCancelled(); + + case CDiagResultsDatabaseItem::EInterrupted: + return KInterrupted(); + + case CDiagResultsDatabaseItem::ENotPerformed: + return KNotPerformed(); + + case CDiagResultsDatabaseItem::EDependencyFailed: + return KDependencyFailed(); + + case CDiagResultsDatabaseItem::EWatchdogCancel: + return KWatchdogCancel(); + + case CDiagResultsDatabaseItem::ESuspended: + return KSuspended(); + + case CDiagResultsDatabaseItem::EQueuedToRun: + return KQueuedToRun(); + + default: + _LIT( KUnknown, "* Unknown *" ); + return KUnknown(); + } + } + +#else // #if _DEBUG + +// non-debug version. +const TDesC& CDiagExecPlanEntryImplTest::TestResultString( + CDiagResultsDatabaseItem::TResult /* aResult */ ) + { + _LIT( KNonDebugResultName, "?" ); + return KNonDebugResultName(); + } + +#endif // #else _DEBUG + +// End of File +