/*
* Copyright (c) 2002 - 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:  Base Class Scripted STIF cases
*
*/

// INCLUDE FILES
#include <e32svr.h>
#include <StifParser.h>
#include <Stiftestinterface.h>
#include "basetest.h"


// -----------------------------------------------------------------------------
// CBaseTest::CCollectionHelperTest
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
EXPORT_C CBaseTest::CBaseTest( CTestModuleIf& aTestModuleIf ):
        CScriptBase( aTestModuleIf ), 
        iTestModuleIf(aTestModuleIf)
    {   
    }
    
// Destructor
EXPORT_C CBaseTest::~CBaseTest()
    { 
    // Delete logger
    delete iLog; 
    delete iTimeoutController;
    }

// -----------------------------------------------------------------------------
// CBaseTest::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CBaseTest::ConstructL()
{
    iTimeoutController = CSimpleTimeout::NewL (this, iLog);
}

// -----------------------------------------------------------------------------
// CBaseTest::EventName
// Return descriptor with the notification description
// -----------------------------------------------------------------------------
EXPORT_C TPtrC CBaseTest::EventName( TInt aKey )
{
    static TText* const badKeyword = (TText*)L"BadKeyword";
    static TText* const keywords[] = {
        (TText*)L"EColHandleCollectionMessage",
        (TText*)L"EColHandleOpen",
        (TText*)L"EColHandleAddFileComplete",
        (TText*)L"EColHandleRemove",
        (TText*)L"EColHandleFindAllComplete",
        (TText*)L"EPlaHandlePlaybackMessage1",
        (TText*)L"EPlaHandlePlaybackMessage2"
    };

    if( (TUint)aKey >= (sizeof( keywords )/sizeof(TText*)) )
    {
        iLog->Log(_L("Keyword out of bounds"));
        TPtrC keyword( badKeyword );
        return keyword;
    }
    else
    {
        TPtrC keyword( keywords[aKey] );
        return keyword;
    }
}

// -----------------------------------------------------------------------------
// CBaseTest::AddExpectedEvent
// Add an event to the expected events' list
// -----------------------------------------------------------------------------
EXPORT_C void CBaseTest::AddExpectedEvent(TExpectedEvent event, TInt ms)
{
    FTRACE(FPrint(_L("CBaseTest::AddExpectedEvent")));
    iExpectedEvents.Append(event);
    TPtrC eventName = EventName(event);
    iLog->Log(_L("Adding expected event:(0x%02x)%S Total=%d"), event, 
            &eventName, iExpectedEvents.Count() );

    if ( iTimeoutController && !iTimeoutController->IsActive() )
    {
        if (ms > 0)
        {
            iTimeoutController->Start( TTimeIntervalMicroSeconds(ms * 1000) );
        }
        else
        {
            iLog->Log(_L("Timeout with default value (1s)"));
            iTimeoutController->Start( TTimeIntervalMicroSeconds(1000000) );
        }
    }
}

// -----------------------------------------------------------------------------
// CBaseTest::RemoveExpectedEvent
// Remove the indicated event from the expected events' list
// Returns: ETrue: Event found.
//          EFalse: Event not found.
// -----------------------------------------------------------------------------
EXPORT_C TBool CBaseTest::RemoveExpectedEvent(TExpectedEvent aEvent)
{
    FTRACE(FPrint(_L("CBaseTest::RemoveExpectedEvent")));
    TBool match = EFalse;
    for (TUint i=0; i < iExpectedEvents.Count() ; i++)
    {
        if (iExpectedEvents[i] == aEvent)
        {
            iExpectedEvents.Remove(i);
            match = ETrue;
            break;
        }
    }

    return match;
}


// -----------------------------------------------------------------------------
// CBaseTest::RemoveAllExpectedEvents
// Remove the indicated event from the expected events' list
// -----------------------------------------------------------------------------
EXPORT_C void CBaseTest::RemoveAllExpectedEvents()
{
    FTRACE(FPrint(_L("CBaseTest::RemoveAllExpectedEvents")));
    iLog->Log(_L("Removing all expected events"));

    iExpectedEvents.Reset();
    iOcurredEvents.Reset();
}


// -----------------------------------------------------------------------------
// CBaseTest::ProcessEvent
// Process events.
// -----------------------------------------------------------------------------
EXPORT_C void CBaseTest::ProcessEvent(TExpectedEvent aEvent, TInt aError)
{
    FTRACE(FPrint(_L("CBaseTest::ProcessExpectedEvent")));
    TPtrC nameEvent = EventName(aEvent);

    // Check for error
    if (aError == KErrNone)
    {
        // Remove the event
        if (RemoveExpectedEvent(aEvent))
        {
            iLog->Log(_L("Expected Event: (0x%02x)%S has ocurred Total=%d"), 
                    aEvent, &nameEvent,iExpectedEvents.Count());
        }
        else
        {
            iLog->Log(_L("Event: (0x%02x)%S has ocurred"), aEvent, &nameEvent);
            return;
        }

        // All expected events have ocurred
        if (iExpectedEvents.Count() == 0 )
        {
            Signal();
            iTimeoutController->Cancel();
        }
    }
    else
    {
        iLog->Log(_L("[Error] Event: (0x%02x)%S return with error code=%d"), 
                aEvent, &nameEvent, aError);
        
        if (iExpectedEvents.Count() != 0 )
        {
            RemoveExpectedEvent(aEvent);
        }
        
        iTimeoutController->Cancel();
        Signal(KErrCallbackErrorCode);
    }
}

// -----------------------------------------------------------------------------
// CBaseTest::HandleTimeout
// Review if all the expected events have ocurred once the time is over
// -----------------------------------------------------------------------------
EXPORT_C void CBaseTest::HandleTimeout(TInt aError)
{
    FTRACE(FPrint(_L("CBaseTest::HandleTimeout")));
    // All expected events have ocurred
    if (aError != KErrNone)
    {
        if (iExpectedEvents.Count() == 0 )
        {
            iLog->Log(_L("Timing out but events have ocurred"));
            Signal();
        }
        else
        {
            RemoveAllExpectedEvents();
            iLog->Log(_L("Timing out and events still pending"));
            Signal(KErrEventPending);
        }
    }
    else
    {
        iLog->Log(_L("Timing out return a error %d"), aError);
        Signal(aError);
    }
}

// -----------------------------------------------------------------------------
// CBaseTest::SetTimeout
// Create a timer and set a timeout
// When the timeout is reached the test case is marked as failed
// It's used rather than the "timeout" keyword in the configuration file
// because in this way the log continues
// -----------------------------------------------------------------------------
EXPORT_C TInt CBaseTest::SetTimeout( CStifItemParser& aItem )
{
    FTRACE(FPrint(_L("CBaseTest::SetTimeout")));
    TInt timeout=0;
    TInt error = aItem.GetNextInt(timeout) ;
    if ( iTimeoutController )
    {
        if ( timeout > 0 )
        {
            iTimeoutController->Start( TTimeIntervalMicroSeconds(timeout*1000) );
        }
        else
        {
            iTimeoutController->Start( TTimeIntervalMicroSeconds(1000000) );
        }
    }
    else
    {
        iLog->Log(_L("Timeout Controller doesn't exist"));
        error = KErrTimeoutController;
    }
    return error;
}


// -----------------------------------------------------------------------------
// Uses the TestModuleBase API to allow a panic as exit reason for a test case
// Returns: Symbian OS errors.
// -----------------------------------------------------------------------------
EXPORT_C TInt CBaseTest::SetAllowedPanic( CStifItemParser& aItem )
{
    FTRACE(FPrint(_L("CBaseTest::SetAllowedPanic")));
    TInt error = KErrNone;
    TInt panicCode;
    TPtrC panicType;
    if (  ( KErrNone == aItem.GetNextString(panicType) ) &&
    ( KErrNone == aItem.GetNextInt(panicCode) )  )
    {
        iLog->Log(_L("Allowing panic: %S %d"), &panicType, panicCode);
        iTestModuleIf.SetExitReason( CTestModuleIf::EPanic, panicCode );
        iNormalExitReason = EFalse;
    }
    else
    {
        iLog->Log(KMsgBadTestParameters);
        error = KErrBadTestParameter;
    }
    return error;
}

// -----------------------------------------------------------------------------
// CBaseTest::SetExpectedEvents()
// Returns: Symbian OS errors.
// -----------------------------------------------------------------------------
EXPORT_C TInt CBaseTest::SetExpectedEvents( CStifItemParser& aItem )
{
    FTRACE(FPrint(_L("CBaseTest::SetExpectedEvents")));
    TInt error = KErrNone;
    TInt event=0;
    while ( KErrNone == aItem.GetNextInt(event))
    {
        AddExpectedEvent(static_cast<TExpectedEvent>(event), 0); // Default timeout value
    }
    return error;
}