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

#include <ecom/test_bed/transition.h>
#include <ecom/test_bed/datalogger.h>
#include <ecom/test_bed/testbeddefinitions.h>

EXPORT_C CTransition::CTransition(const TDesC&					aTransitionId, 
										CUnitTestContext&		aUTContext,
										TTransitionValidator&	aValidator) 
:	CActive(CActive::EPriorityStandard),
iTransitionId(aTransitionId),
iUTContext(aUTContext),
iValidator(aValidator),
iTransitionInfo(iTransitionId, iUTContext.DataLogger()) 
	{
	CActiveScheduler::Add(this);
	}


EXPORT_C CTransition::~CTransition()
	{
	Cancel();
	}


EXPORT_C void CTransition::SetStartStateL()
	{
	// Do nothing here
	}


EXPORT_C const TDesC& CTransition::TransitionId() const
	{
	return iTransitionId;
	}

EXPORT_C void CTransition::DoCancel()
	{
	// Complete the unit test so that this test will now finish
	// if the transition has not finished then we haven't even had to chance
	// to run yet so complete the UnitTest with a Cancel message
	// If the transition has finished then we must have an outstanding async
	// transition so Complete the observer to ensure it gets removed from the list
	// of outstanding transitions
	if(!iTransitionFinished)
		User::RequestComplete(iUnitTestStatus, KTestBedTestCancel);
	else
		iUTContext.TransitionObserver().Complete(*this, KTestBedTestCancel);
	}


EXPORT_C void CTransition::RunTransition(TRequestStatus* aUnitTestStatus)
	{
	iUnitTestStatus = aUnitTestStatus;
	iTransitionFinished = EFalse;

	// Reset the iRepeat flag - if this transition should be repeated it will be
	// set during the execution of TransitMethodL().
	iRepeatThis = EFalse;

	if(!iValidator.ValidatePreConditions())
		{
		User::RequestComplete(iUnitTestStatus, KTestBedFailedPreConditions);
		}
	else
		{
		SetActive();
		TRequestStatus* status = &iStatus;
		User::RequestComplete(status, KErrNone);
		}
	}

EXPORT_C void CTransition::RunL()
	{
	iUTContext.TransitionObserver().SetCurrentTransition(*this);
	if(!iTransitionFinished)
		{
		++iTransitionInfo.iIteration;
		TransitMethodL();
		iTransitionFinished = ETrue;
		PostTransitionCleanup();		// Allow the derived transition class to do something before
										// PostCondition validation.

		// If the user called an asynchronous function then SetActive so that we run again
		// when the async function completes
		iAsyncTransition = iStatus == KRequestPending;
		if(iAsyncTransition)
			{
			SetActive();
			}

		TTestBedAsyncState asyncState = iAsyncTransition ? EAsyncCalled : EAsyncCompleted;
		if(!iValidator.ValidatePostConditions(asyncState))
			{
			if(iAsyncTransition)
				{
				//Cancel the request
				Cancel();
				}
			User::RequestComplete(iUnitTestStatus, KTestBedFailedPostConditions);
			}
		else if(iAsyncTransition)
			User::RequestComplete(iUnitTestStatus, KTestBedAsynchronousTransition);
		else if(iRepeatThis)
			User::RequestComplete(iUnitTestStatus, KTestBedRepeatTest);
		else
			User::RequestComplete(iUnitTestStatus, KErrNone);
		}
	else
		{
		if(iAsyncTransition && !iValidator.ValidatePostConditions(EAsyncCompleted))
			iUTContext.TransitionObserver().Complete(*this, KTestBedFailedPostConditions);
		else
			iUTContext.TransitionObserver().Complete(*this, KErrNone);
		}
	}

EXPORT_C const TTransitionInfo& CTransition::TransitionInfo() const
	{
	return iTransitionInfo;
	}

EXPORT_C void CTransition::RepeatOnce()
	{
	iRepeatThis = ETrue;
	}

EXPORT_C TInt CTransition::RunError(TInt aErrorCode)
	{
	// Record the leave and signal completed with a leave code
	_LIT(KTransitionRunError, "CTransition::TransitMethodL() leaving error %d.");
	iUTContext.DataLogger().LogInformationWithParameters(KTransitionRunError, aErrorCode);

	iLeaveError = aErrorCode;
	// Check if the leave is associated with a repeat request
	// I.e. it was an execution path test from a stub.
	if(iLeaveError == KTestBedRepeatTest && iRepeatThis)
		User::RequestComplete(iUnitTestStatus, KTestBedRepeatTest);
	else
		User::RequestComplete(iUnitTestStatus, KTestBedTestLeft);
	return KErrNone;
	}

EXPORT_C TBool CTransition::IsBlockingTransition() const
	{
	return iBlockingTransition;
	}

EXPORT_C void CTransition::SetBlockingTransition(TBool aBlocking)
	{
	iBlockingTransition = aBlocking;
	}

EXPORT_C TInt CTransition::GetErrorCode() const
	{
	return iLeaveError;
	}

EXPORT_C void CTransition::PostTransitionCleanup()
	{
	// Default behaviour is to do nothing
	}