/*
* Copyright (c) 2002 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:  CCommonTestClass implementation for STIF Test Framework TestScripter.
*
*/



// INCLUDE FILES
#include <Stiftestinterface.h>
#include "commontestclass.h"


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

// -----------------------------------------------------------------------------
// CCommonTestClass::CCommonTestClass
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CCommonTestClass::CCommonTestClass( 
    CTestModuleIf& aTestModuleIf ):
        CScriptBase( aTestModuleIf ), 
        iTestModuleIf(aTestModuleIf)
    {
    }

// -----------------------------------------------------------------------------
// CCommonTestClass::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCommonTestClass::ConstructL()
    {
    iLog = CStifLogger::NewL( KCommonTestClassLogPath, 
                          KCommonTestClassLogFile,
                          CStifLogger::ETxt,
                          CStifLogger::EFile,
                          EFalse );
	iTimeoutController = CSimpleTimeout::NewL (this, iLog);
    // Print title of the test case
    TName title;
    TestModuleIf().GetTestCaseTitleL(title);
    iLog->Log(_L("[Title] %S"), &title);
    }

// -----------------------------------------------------------------------------
// CCommonTestClass::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCommonTestClass* CCommonTestClass::NewL(CTestModuleIf& aTestModuleIf )
    {
    CCommonTestClass* self = new (ELeave) CCommonTestClass( aTestModuleIf );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// Destructor
CCommonTestClass::~CCommonTestClass()
    { 
    Delete();
    // Delete logger
    delete iLog; 
	delete iTimeoutController;
    }

// -----------------------------------------------------------------------------
// CCommonTestClass::EventName
// Return descriptor with the notification description
// -----------------------------------------------------------------------------
TPtrC CCommonTestClass::EventName( TInt aKey )
    {
	TText* const badKeyword = (TText*)L"BadKeyword";
	TText* const keywords[] =
	    {
		(TText*)L"ERequestComplete"
	    };
	
	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;
	    }
    }

// -----------------------------------------------------------------------------
// CCommonTestClass::AddExpectedEvent
// Add an event to the expected events' list
// -----------------------------------------------------------------------------
void CCommonTestClass::AddExpectedEvent(TMPXTestExpectedEvent event, TInt ms)
    {
	FTRACE(FPrint(_L("CCommonTestClass::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) );
		    }
	    }
    }

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


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

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


// -----------------------------------------------------------------------------
// CCommonTestClass::ProcessEvent
// Process events.
// -----------------------------------------------------------------------------
void CCommonTestClass::ProcessEvent(TMPXTestExpectedEvent aEvent, TInt aError)
    {
	FTRACE(FPrint(_L("CCommonTestClass::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);
	    }
    }

// -----------------------------------------------------------------------------
// CCommonTestClass::HandleTimeout
// Review if all the expected events have ocurred once the time is over
// -----------------------------------------------------------------------------
void CCommonTestClass::HandleTimeout(TInt aError)
    {
	FTRACE(FPrint(_L("CCommonTestClass::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);
	    }
    }

// -----------------------------------------------------------------------------
// CCommonTestClass::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
// -----------------------------------------------------------------------------
TInt CCommonTestClass::SetTimeout( CStifItemParser& aItem )
    {
	FTRACE(FPrint(_L("CCommonTestClass::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.
// -----------------------------------------------------------------------------
TInt CCommonTestClass::SetAllowedPanic( CStifItemParser& aItem )
    {
	FTRACE(FPrint(_L("CCommonTestClass::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;
    }

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





// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
// LibEntryL is a polymorphic Dll entry point.
// Returns: CScriptBase: New CScriptBase derived object
// -----------------------------------------------------------------------------
//
EXPORT_C CScriptBase* LibEntryL( 
    CTestModuleIf& aTestModuleIf ) // Backpointer to STIF Test Framework
    {
    return ( CScriptBase* ) CCommonTestClass::NewL( aTestModuleIf );
    }

//  End of File