/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

* 

* Description: This module contains implementation of 

* CTestCaseController class member functions.

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <e32uid.h>

#include <StifLogger.h>

#include "StifTFwIfProt.h"

#include "TestCaseController.h"

#include "TestModuleController.h"

#include "TestReport.h"

#include "Logging.h"

#include "StifHWReset.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 =======================================

// None

#define LOGGER iEngine->Logger()

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

/*

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

    Class: CTestCaseController

    Method: CTestCaseController

    Description: Default constructor

    C++ default constructor can NOT contain any code, that

    might leave.

    Parameters: CTestEngine* aEngine: in: Pointer to CTestEngine

                RTestExecution aTestExecution: in: Handle to RTestExecution

                CAtsLogger& aAtsLogger: in: Reference to CAtsLogger

                RTestExecution aTestExecution: in: Handle to RTestExecution

                const TTestInfo& aTestInfo: in: Test Info

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

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

*/

CTestCaseController::CTestCaseController( CTestEngine* aEngine,

                                          CTestReport* aTestReport,

                                          CAtsLogger& aAtsLogger,

                                          RTestExecution aTestExecution,

                                          const TTestInfo& aTestInfo ) :

    CActive( CActive::EPriorityStandard ),

    iEngine( aEngine ),

    iTestReport( aTestReport ),

    iTestExecution( aTestExecution ),

    iTestInfo( aTestInfo ),

    iState( ETestCaseIdle ),

    iResultPckg( iResult ),

    iAtsLogger( aAtsLogger )

    {

    CActiveScheduler::Add( this );

    }

/*

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

    Class: CTestCaseController

    Method: ConstructL

    Description: Symbian OS second phase constructor

    Symbian OS default constructor can leave.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CTestCaseController::ConstructL()

    {

    __TRACE( KVerbose, ( _L( "CTestCaseController::ConstructL, [%S]" ), &iTestInfo.iTestCaseInfo.iTitle ) );

    // Logger settings

    TLoggerSettings loggerSettings;

    loggerSettings.iCreateLogDirectories = EFalse;

    loggerSettings.iOverwrite = ETrue;

    loggerSettings.iTimeStamp = EFalse;

    loggerSettings.iLineBreak = EFalse;

    loggerSettings.iEventRanking = EFalse;

    loggerSettings.iThreadId = EFalse;

    loggerSettings.iHardwareFormat = CStifLogger::ETxt;

    loggerSettings.iHardwareOutput = CStifLogger::ERDebug;

    loggerSettings.iEmulatorFormat = CStifLogger::ETxt;

    loggerSettings.iEmulatorOutput = CStifLogger::ERDebug;

    loggerSettings.iUnicode = EFalse;

    loggerSettings.iAddTestCaseTitle = EFalse;

    iRDebugLogger = CStifLogger::NewL( _L( "" ), _L( "" ), loggerSettings );

    // If timeout is specified, then create timeout handler.

    if ( iTestInfo.iTestCaseInfo.iTimeout > TTimeIntervalMicroSeconds(0) )

        {

        iTimeout = CTestCaseTimeout::NewL ( this,

                                            iTestInfo.iTestCaseInfo.iTimeout );

        }

    }

/*

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

    Class: CTestCaseController

    Method: NewL

    Description: Two-phased constructor.

    Parameters: CTestEngine* aEngine: in: Pointer to CTestEngine

                CTestReport* aTestReport: in: Pointer to CTestReport

                CAtsLogger& aAtsLogger: in: Reference to CAtsLogger

                RTestExecution aTestExecution: in: Handle to RTestExecution

                const TTestInfo& aTestInfo: in: Test Info

    Return Values: CTestCaseController* : pointer to created object

    Errors/Exceptions: Leaves if construction of CTestCaseController fails

    Status: Approved

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

*/

CTestCaseController* CTestCaseController::NewL( CTestEngine* aEngine,

                                               CTestReport* aTestReport,

                                               CAtsLogger& aAtsLogger,

                                               RTestExecution aTestExecution,

                                               const TTestInfo& aTestInfo )

    {

    CTestCaseController* self = new ( ELeave ) CTestCaseController( aEngine,

        aTestReport, aAtsLogger, aTestExecution, aTestInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

/*

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

    Class: CTestCaseController

    Method: ~CTestCaseController

    Description: Destructor

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CTestCaseController::~CTestCaseController()

    {

    __TRACE( KVerbose, ( _L( "CTestCaseController::~CTestCaseController" ) ) );

    Cancel();

    delete iRDebugLogger;

    delete iTimeout;

    delete iTestCaseArguments;

    }

/*

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

    Class: CTestCaseController

    Method: StartL

    Description: Start active object

    Parameters: const RMessage& aMessage: in: Server message

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CTestCaseController::StartL( const RMessage2& aMessage )

    {

    iRDebugLogger->Log( _L( "Starting testcase [%S]" ), &iTestInfo.iTestCaseInfo.iTitle );

    __TRACE( KInit, ( _L(" Starting testcase [%S]"), &iTestInfo.iTestCaseInfo.iTitle ) );

    // Check that this request is not pending!!

    __ASSERT_ALWAYS( iState != ETestCaseRunning,

                            iEngine->PanicClient( EReqPending, aMessage ) );

    iMessage = aMessage;

    iState = ETestCaseRunning;

    delete iTestCaseArguments;

    iTestCaseArguments = NULL;

    TInt testCaseArgumentsLength = iMessage.GetDesLength( 1 );

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

        {

        iTestCaseArguments = HBufC::NewL( testCaseArgumentsLength );

        TPtr testCaseArgumentsPtr( iTestCaseArguments->Des() );

        User::LeaveIfError( iMessage.Read( 1, testCaseArgumentsPtr ) );

        iTestExecution.RunTestCase( iResultPckg, *iTestCaseArguments, iStatus );        

        }

    else

        {    

        iTestExecution.RunTestCase( iResultPckg, iStatus );

        }

    SetActive();

    // If testcase has timeout (handler), then start it

    if ( iTimeout )

        {

        iTimeout->Start();

        }

    }

/*

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

    Class: CTestCaseController

    Method: Timeout

    Description: Timeouts active request.

    - Cancel request

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CTestCaseController::Timeout()

    {

    if ( iState == ETestCaseRunning )

        {

        iState = ETestCaseTimeout;

        Cancel();

        }

    }

/*

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

    Class: CTestCaseController

    Method: RunL

    Description: RunL handles completed requests. Leaves are handled in

                 RunError method

    Parameters: None

    Return Values: None

    Errors/Exceptions: Leaves if AddTestCaseResultL leaves

    Status: Approved

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

*/

void CTestCaseController::RunL()

    {

    iState = ETestCaseCompleted;

    // "iStatus.Int()" error code is received from system's framework not from

    // test case execution.

    if ( iStatus.Int() != KErrNone )

        {

            if ( iStatus.Int() == KErrServerTerminated )

            {

            // something went badly wrong!

            __TRACE( KInit, ( CStifLogger::ERed, 

                _L( "TestCase [%S] cannot be executed, STIF panics with[%d]" ),

                &iTestInfo.iTestCaseInfo.iTitle,

                iStatus.Int() ) );       

            __TRACE( KInit, ( CStifLogger::ERed, 

                _L( "Possible reason: Test case has paniced seriously" ) ) );

            // We don't leave here but we write information to 

            // forward(testreport etc.)

            _LIT( KLeaveInfo, "Test case execution fails" );

            // Sets test case to crash category

            iResult.iCaseExecutionResultCode = iStatus.Int();

            // Test case result

            iResult.iTestResult.iResult = iStatus.Int();

            iResult.iTestResult.iResultDes = KLeaveInfo;

            } 

            else

            {   

        // For example testmodule's NewL or testmodule's constructor has

        // leaved and STIF cannot connect to test module

        __TRACE( KInit, ( CStifLogger::ERed, 

            _L( "TestCase [%S] cannot execute, TestModule loading operations fails with[%d]" ),

            &iTestInfo.iTestCaseInfo.iTitle,

            iStatus.Int() ) );

        __TRACE( KInit, ( CStifLogger::ERed, 

            _L( "Possible reason: TestModule's NewL or Constructor has leaved and STIF cannot connect to test module" ) ) );

        // We don't leave here but we write information to 

        // forward(testreport etc.)

        _LIT( KLeaveInfo, "TestModule loading fails, cannot connect to the TestModule" );

        // Sets test case to crash category

        iResult.iCaseExecutionResultCode = iStatus.Int();

        // Test case result

        iResult.iTestResult.iResult = iStatus.Int();

        iResult.iTestResult.iResultDes = KLeaveInfo;

            }

        }

	else

	{

    // Cancel event request, because the testcase is completed

    iTestExecution.CancelAsyncRequest( ETestExecutionNotifyEvent );        

	}

    // Test case is executed

    if( iTestInfo.iTestCaseInfo.iTitle.Length() > 0 )

        {

        iRDebugLogger->Log( _L( "TestCase [%S] finished with verdict[%d]" ),

                            &iTestInfo.iTestCaseInfo.iTitle,

                            iResult.iTestResult.iResult );

        __TRACE( KInit, ( _L( " TestCase [%S] finished with verdict[%d]" ),

                            &iTestInfo.iTestCaseInfo.iTitle,

                            iResult.iTestResult.iResult ) );

        }

    else

        {

        iRDebugLogger->Log( _L( "TestCase [%d] finished with verdict[%d]" ),

                            iTestInfo.iTestCaseInfo.iCaseNumber,

                            iResult.iTestResult.iResult );

        __TRACE( KInit, ( _L( " TestCase [%d] finished with verdict[%d]" ),

                            iTestInfo.iTestCaseInfo.iCaseNumber,

                            iResult.iTestResult.iResult ) );

        }

    __TRACE( KVerbose, ( 

            _L( "CTestCaseController::RunL: iStatus=[%d]" ), iStatus.Int() ));

    GenerateXmlLogL();

    // Report test case result

    if( iTestReport )

        {

        iTestReport->AddTestCaseResultL( iTestInfo, iResult, iStatus.Int() );

        iTestReport->UpdateReportSummaryL();

        }

    TRAPD( ret, iMessage.WriteL( 0, iResultPckg ) );

    // Case done

    iMessage.Complete( ret );

    }

/*

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

    Class: CTestCaseController

    Method: DoCancel

    Description: Cancel active request

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CTestCaseController::DoCancel()

    {

    switch ( iState )

        {

        case ETestCaseRunning:

            iTestExecution.CancelAsyncRequest( ETestExecutionRunTestCase );

            if( iTestInfo.iTestCaseInfo.iTitle.Length() > 0 )

                {

                iRDebugLogger->Log( _L( "TestCase [%S] execution aborted" ),

                                    &iTestInfo.iTestCaseInfo.iTitle );

                __TRACE( KInit, ( _L( "TestCase [%S] execution aborted" ),

                                    &iTestInfo.iTestCaseInfo.iTitle ) );

                }

            else

                {

                iRDebugLogger->Log( _L( "TestCase [%S] execution aborted" ),

                                    iTestInfo.iTestCaseInfo.iCaseNumber );

                __TRACE( KInit, ( _L( "TestCase [%S] execution aborted" ),

                                    iTestInfo.iTestCaseInfo.iCaseNumber ) );

                }

            break;

        case ETestCaseTimeout:

            iTestExecution.CancelAsyncRequest( ETestExecutionRunTestCase );

            // Update result to timeout

            iResult.iCaseExecutionResultType = TFullTestResult::ECaseTimeout;

            iResult.iTestResult.iResultDes = _L("Test case was timeouted and cancelled");

            if( iTestReport )

                {

                iTestReport->AddTestCaseResultL( iTestInfo, iResult, KErrTimedOut );

                }

            if( iTestInfo.iTestCaseInfo.iTitle.Length() > 0 )

                {

                iRDebugLogger->Log( _L( "TestCase [%S] finished with verdict[%d]" ),

                                    &iTestInfo.iTestCaseInfo.iTitle,

                                    iResult.iTestResult.iResult );

                __TRACE( KInit, ( _L( " TestCase [%S] finished with verdict[%d]" ),

                                    &iTestInfo.iTestCaseInfo.iTitle,

                                    iResult.iTestResult.iResult ) );

                }

            else

                {

                iRDebugLogger->Log( _L( "TestCase [%d] finished with verdict[%d]" ),

                                    iTestInfo.iTestCaseInfo.iCaseNumber,

                                    iResult.iTestResult.iResult );

                __TRACE( KInit, ( _L( " TestCase [%d] finished with verdict[%d]" ),

                                    iTestInfo.iTestCaseInfo.iCaseNumber,

                                    iResult.iTestResult.iResult ) );

                }            

            break;

        case ETestCaseSuicided:

            {

            //Store current results because cancel operation overwrites it

            TInt currentTestResult = iResult.iTestResult.iResult;

            TInt currentExecutionResult = iResult.iCaseExecutionResultCode;

            iTestExecution.CancelAsyncRequest(ETestExecutionRunTestCase);

            // Update result to suicide

            switch(iStopExecutionType)

                {

                case EOk:

                    iResult.iCaseExecutionResultType = TFullTestResult::ECaseExecuted;

                    iResult.iTestResult.iResultDes = _L("Test case passed (StopExecution())");

                    break;

                case EFail:

                    iResult.iCaseExecutionResultType = TFullTestResult::ECaseExecuted;

                    iResult.iTestResult.iResultDes = _L("Test case failed (StopExecution())");

                    break;

                default: //EAbort

                    iResult.iCaseExecutionResultType = TFullTestResult::ECaseSuicided;

                    iResult.iTestResult.iResultDes = _L("Test case killed (StopExecution())");

                }

            iResult.iTestResult.iResult = currentTestResult;