/*
* Copyright (c) 2004 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:
*
*/


// INCLUDE FILES
#include <ctfatesttimer.h>
#include <ctfatestlog.h>
#include <tftypes.h>
#include "siftrace.h"
#include "ctfdoscontrol.h"
#include "ctfdoscontroltestcase.h"
#include "ctfdoscontroltestcaseparam.h"

CTFDosControlTestCaseParam::CTFDosControlTestCaseParam( void )
    {
    }


void CTFDosControlTestCaseParam::ConstructL( const TTFDosServerControlTestCaseState* aStates, TInt aStateCount )
    {
    TRACE_ASSERT( aStates != NULL );
    TRACE_ASSERT( aStateCount > 0 );
    iStates = REINTERPRET_CAST( TTFDosServerControlTestCaseState*, User::Alloc( sizeof ( TTFDosServerControlTestCaseState ) * aStateCount ) );
    User::LeaveIfNull( iStates );
    Mem::Copy( iStates, aStates, sizeof ( TTFDosServerControlTestCaseState ) * aStateCount );
    iStateCount = aStateCount;
    }

    
CTFDosControlTestCaseParam::~CTFDosControlTestCaseParam( void )
    {
    User::Free( iStates );
    iStates = NULL;
    }
    
    
const TTFDosServerControlTestCaseState* CTFDosControlTestCaseParam::States( void ) const
    {
    return iStates;
    }
    
    
TInt CTFDosControlTestCaseParam::StateCount( void ) const
    {
    return iStateCount;
    }
    
    
CTFDosControlTestCase::CTFDosControlTestCase( CTFDosControlTestCaseParam* aParameters )
: CTFStubTestCase( KTFStubTypeDosServerControl )
, iParameters( aParameters )
    {
    TRACE_ASSERT( aParameters != NULL );
    if ( aParameters != NULL )
        {
        TRACE_ASSERT( aParameters->States() != NULL );
        TRACE_ASSERT( aParameters->StateCount() > 0 );
        }
    }
    
    
void CTFDosControlTestCase::ConstructL( void )
    {
    iTimer = CTFATestTimer::NewL( *this );
    }
    
    
CTFDosControlTestCase::~CTFDosControlTestCase( void )
    {
    delete iParameters;
    delete iTimer;
    }


void CTFDosControlTestCase::Log( TInt aDepth )
    {
    _LIT( KStart, "DosServer control component, %d states" );
    _LIT( KState, "Flags: %d %d %d %d %d" );
    Logger().WriteList( aDepth, KStart, iParameters->StateCount() );
    for ( TInt i = 0; i < iParameters->StateCount(); i++ )
        {
        Logger().WriteList( aDepth + 1, KState, 
            iParameters->States()[i].iDosFunction,
            iParameters->States()[i].iArg1,
            iParameters->States()[i].iArg2,
            iParameters->States()[i].iExpectedResult,
            iParameters->States()[i].iCompletionEvent );
        }
    }
    
    
void CTFDosControlTestCase::InitL( void )
	{
    iCleanupWait = EFalse;
	iCurrentStateIndex = 0;
    iCurrentState = iParameters->States()[iCurrentStateIndex];
	}


void CTFDosControlTestCase::ActiveTestRunL( void )
    {
    if ( iCleanupWait )
        {
        CActiveScheduler::Stop();
        }
    else
        {
        RunL();
        }
    }
    

void CTFDosControlTestCase::RunL( void )
    {
    TInt result = KErrNone;    
    if ( iCurrentState.iDosFunction != 0 )
        {
        if ( iCurrentState.iDosFunction == ETFDosEvent_Synchronized )
            {
            // Wait event to start next state!
            }
        else
            {
            TRAP( result, CallCurrentDosFunctionL() );
            StartNextState( result );    
            }            
        }  
    }
    
    
void CTFDosControlTestCase::Teardown( void )
	{
	// If the test is terminated by a failing stub test case, 
	// the timer may be left active and thus must be cancelled. 
	iTimer->Cancel();
    iTimer->After( 100000 ); // 100-ms timeout to wait for pending events.
    iCleanupWait = ETrue;
    CActiveScheduler::Start();
	}
    

void CTFDosControlTestCase::NotifyDosEvent( TInt aEvent, TInt aParameter )
    {
    TEST_CASE_TRACE( ( _L( "CTFDosServerControlTestCase::NotifyDosEvent(%d, %d)"), aEvent, aParameter ) );
    
    iCurrentState = iParameters->States()[iCurrentStateIndex];
    
    if ( !IsComplete() )
        {
        if ( aEvent == iCurrentState.iCompletionEvent && iCurrentState.iArg1 == aParameter )
            {
            StartNextState( KErrNone );
            }
            else
            {
            DoCompleteTest( KTFErrDosUnexpectedEvent );    
            }        
        }
    else
        {
        TEST_CASE_TRACE( ( _L( "CTFDosServerControlTestCase::NotifyDosEvent() - Test already finished" ) ) );
        }
    }
    
    
void CTFDosControlTestCase::DoCompleteTest( TInt aResult )
    {
    iTimer->Cancel();
    CompleteTest( aResult );
    }
    
    
void CTFDosControlTestCase::CallCurrentDosFunctionL( void )
    {
    TRACE_ASSERT( iStub != NULL );
    if ( iStub != NULL )
        {
        STATIC_CAST( CTFDosControl*, iStub )->CallDosFunctionL( iCurrentState );
        }
    else
        {
        User::Leave( KTFErrNoStub );
        }
    }
    
    
CTFDosControlTestCaseParam& CTFDosControlTestCase::Parameters( void )
    {
    return *iParameters;
    }
    
    
TTFDosFunction CTFDosControlTestCase::CurrentDosFunction( void ) const
    {
    return iCurrentState.iDosFunction;
    }
    
    
TInt CTFDosControlTestCase::CurrentArg1( void ) const
    {
    return iCurrentState.iArg1;
    }
    
    
TInt CTFDosControlTestCase::CurrentStateIndex( void ) const
    {
    return iCurrentStateIndex;
    }
    
    
CTFATestTimer* CTFDosControlTestCase::Timer( void )
    {
    return iTimer;
    }
    
    
void CTFDosControlTestCase::StartNextState( TInt aResult )
    {
    if ( aResult != KErrNone )
        {
	    TEST_CASE_TRACE( ( _L( "CTFDosServerControlTestCase::StartNextState() - Test case failed: %d" ), aResult ) );
	    TEST_CASE_TRACE( ( _L( "CTFDosServerControlTestCase::StartNextState() - Failed state: %d" ), iCurrentStateIndex ) );
        DoCompleteTest( aResult );

        }
    else if ( iCurrentStateIndex == iParameters->StateCount() - 1 )
        {
	    TEST_CASE_TRACE( ( _L( "CTFDosServerControlTestCase::StartNextState() - Test case complete" ) ) );
        DoCompleteTest( KErrNone );
        }
    else
        {
        TEST_CASE_TRACE( ( _L( "CTFDosServerControlTestCase::StartNextState() - Starting state %d" ), iCurrentStateIndex + 1 ) );
        iCurrentStateIndex++;
        iCurrentState = iParameters->States()[iCurrentStateIndex];        
        if ( !iTimer->IsActive() )
            {
        	iTimer->After( 100000 ); // Timer calls RunL
    	    }
        }
    }   
    
TInt CTFDosControlTestCase::CheckResult( TInt aResult )
    {    
    
    TInt result(KErrNone);
          
    if ( aResult == iParameters->States()[iCurrentStateIndex].iExpectedResult )
        {                        
        result = KErrNone;    
        }
        else
        {
        result = aResult;            
        }
        
    return result;
    }