/*

* 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 <DiagPlugin.h>                     // MDiagPlugin

#include <DiagTestPlugin.h>                 // MDiagTestPlugin

#include <DiagFrameworkDebug.h>             // LOGSTRING

#include <DiagResultsDbItemBuilder.h>       // CDiagResultsDbItemBuilder

#include <DiagTestExecParam.h>              // TDiagTestExecParam

#include <DiagResultsDatabase.h>            // 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: