// Copyright (c) 2001-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:
// The unit test class implementations for the CTransition class.
// 
//

#include "TransitionUnitTest.h"

// ______________________________________________________________________________
//
_LIT(KTransitionCreateAndDestroyUnitTest,"CTransition_CreateAndDestroy_UnitTest");

CTransition_CreateAndDestroy_UnitTest* CTransition_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CTransition_CreateAndDestroy_UnitTest* self = 
					new(ELeave) CTransition_CreateAndDestroy_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self; 
	}

inline TInt CTransition_CreateAndDestroy_UnitTest::RunError(TInt aError)
	{
	// The RunL left so chain to the base first and then cleanup
	TInt error = CUnitTest::RunError(aError);	// Chain to base
	delete iUTContext;
	iUTContext = NULL;
	delete iStateAccessor;
	iStateAccessor = NULL;
	/* delete any validators used */
	delete iCtorValidator;
	iCtorValidator = NULL;
	delete iDtorValidator;
	iDtorValidator = NULL;
	return error;
	}

inline CTransition_CreateAndDestroy_UnitTest::~CTransition_CreateAndDestroy_UnitTest()
	{
	// Simply delete our test class instance
	delete iUTContext;
	delete iStateAccessor;
	/* delete any validators used */
	delete iCtorValidator;
	delete iDtorValidator;
	}

inline CTransition_CreateAndDestroy_UnitTest::CTransition_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,
																	MUnitTestObserver& aObserver)
: CUnitTest(KTransitionCreateAndDestroyUnitTest, aDataLogger, aObserver)
	{
	//Do nothing
	}

// Now the Individual transitions need to be added.
inline void CTransition_CreateAndDestroy_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TTransition_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);

	// Provide a valid context and validator for the target transition class under test.
	iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
	iUTContext->iTargetValidator  = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));

	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));

	iDtorValidator = new(ELeave) TTransition_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

// ______________________________________________________________________________
//
_LIT(KTransitionTransitMethodLUnitTest,"CTransition_TransitMethodL_UnitTest");

CTransition_TransitMethodL_UnitTest* CTransition_TransitMethodL_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CTransition_TransitMethodL_UnitTest* self = 
					new(ELeave) CTransition_TransitMethodL_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self; 
	}

inline TInt CTransition_TransitMethodL_UnitTest::RunError(TInt aError)
	{
	// The RunL left so chain to the base first and then cleanup
	TInt error = CUnitTest::RunError(aError);	// Chain to base
	delete iUTContext;
	iUTContext = NULL;
	delete iStateAccessor;
	iStateAccessor = NULL;
	/* delete any validators used */
	delete iCtorValidator;
	iCtorValidator = NULL;
	delete iTransitMethodLValidator;
	iTransitMethodLValidator = NULL;
	delete iRepeatOnceValidator;
	iRepeatOnceValidator = NULL;
	delete iTransitionIdValidator;
	iTransitionIdValidator = NULL;
	delete iTransitionInfoValidator;
	iTransitionInfoValidator = NULL;
	delete iIsBlockingValidator;
	iIsBlockingValidator = NULL;
	delete iSetBlockingValidator;
	iSetBlockingValidator = NULL;
	delete iTransitMethodLValidator;
	iTransitMethodLValidator = NULL;
	delete iDtorValidator;
	iDtorValidator = NULL;
	return error;
	}

inline CTransition_TransitMethodL_UnitTest::~CTransition_TransitMethodL_UnitTest()
	{
	// Simply delete our test class instance
	delete iUTContext;
	delete iStateAccessor;
	/* delete any validators used */
	delete iCtorValidator;
	delete iTransitionIdValidator;
	delete iTransitionInfoValidator;
	delete iIsBlockingValidator;
	delete iSetBlockingValidator;
	delete iTransitMethodLValidator;
	delete iRepeatOnceValidator;
	delete iDtorValidator;
	}

inline CTransition_TransitMethodL_UnitTest::CTransition_TransitMethodL_UnitTest(CDataLogger& aDataLogger,
																	MUnitTestObserver& aObserver)
: CUnitTest(KTransitionTransitMethodLUnitTest, aDataLogger, aObserver)
	{
	//Do nothing
	}

// Now the Individual transitions need to be added.
inline void CTransition_TransitMethodL_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TTransition_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
	// Provide a valid context and validator for the target transition class under test.
	iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
	iUTContext->iTargetValidator  = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));

	// Test the flag setting
	iTransitionIdValidator = new(ELeave) TTransition_TransitionId_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_TransitionId_Transition(*iUTContext,*iTransitionIdValidator));
	iTransitionInfoValidator = new(ELeave) TTransition_TransitionInfo_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_TransitionInfo_Transition(*iUTContext,*iTransitionInfoValidator));
	iIsBlockingValidator = new(ELeave) TTransition_IsBlocking_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));
	iSetBlockingValidator = new(ELeave) TTransition_SetBlocking_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_SetBlocking_Transition(*iUTContext,*iSetBlockingValidator));
	AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));
	AddTransitionL(new(ELeave)CTransition_SetBlocking_Transition(*iUTContext,*iSetBlockingValidator));
	AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));

	// The transit
	iTransitMethodLValidator = new(ELeave) TTransition_TransitMethodL_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_TransitMethodL_Transition(*iUTContext,*iTransitMethodLValidator));
	// The repeat flag
	iRepeatOnceValidator = new(ELeave) TTransition_RepeatOnce_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_RepeatOnce_Transition(*iUTContext,*iRepeatOnceValidator));
	AddTransitionL(new(ELeave)CTransition_TransitMethodL_Transition(*iUTContext,*iTransitMethodLValidator));
	// We are expecting the Abort code on the repeat call So no dtor required.
	AddLeaveErrorCodeL(KErrAbort);
	}


// ______________________________________________________________________________
//
_LIT(KTransitionAsyncOperationUnitTest,"CTransition_AsyncOperation_UnitTest");

CTransition_AsyncOperation_UnitTest* CTransition_AsyncOperation_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CTransition_AsyncOperation_UnitTest* self = 
					new(ELeave) CTransition_AsyncOperation_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self; 
	}

inline TInt CTransition_AsyncOperation_UnitTest::RunError(TInt aError)
	{
	// The RunL left so chain to the base first and then cleanup
	TInt error = CUnitTest::RunError(aError);	// Chain to base
	delete iUTContext;
	iUTContext = NULL;
	delete iStateAccessor;
	iStateAccessor = NULL;
	/* delete any validators used */
	delete iCtorValidator;
	iCtorValidator = NULL;
	delete iRunTransitionValidator;
	iRunTransitionValidator = NULL;
	delete iCancelValidator;
	iCancelValidator = NULL;
	delete iGetErrorCodeValidator;
	iGetErrorCodeValidator = NULL;
	delete iDtorValidator;
	iDtorValidator = NULL;
	return error;
	}

inline CTransition_AsyncOperation_UnitTest::~CTransition_AsyncOperation_UnitTest()
	{
	// Simply delete our test class instance
	delete iUTContext;
	delete iStateAccessor;
	/* delete any validators used */
	delete iCtorValidator;
	delete iRunTransitionValidator;
	delete iCancelValidator;
	delete iGetErrorCodeValidator;
	delete iDtorValidator;
	}

inline CTransition_AsyncOperation_UnitTest::CTransition_AsyncOperation_UnitTest(CDataLogger& aDataLogger,
																	MUnitTestObserver& aObserver)
: CUnitTest(KTransitionAsyncOperationUnitTest, aDataLogger, aObserver)
	{
	//Do nothing
	}

// Now the Individual transitions need to be added.
inline void CTransition_AsyncOperation_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TTransition_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
	// Provide a valid context and validator for the target transition class under test.
	iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
	iUTContext->iTargetValidator  = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	/*	Examples of C'tor and D'tor transitions on CTransition class.
		using ctor and dtor validators */
	iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));

	// Run the target transition asynchronously, cancel, check the error code, 
	// and then run asynchronously again to completion
	iRunTransitionValidator = new(ELeave) TTransition_RunTransition_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_RunTransition_Transition(*iUTContext,*iRunTransitionValidator));
	iCancelValidator = new(ELeave) TTransition_Cancel_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_Cancel_Transition(*iUTContext,*iRunTransitionValidator));
	iGetErrorCodeValidator = new(ELeave) TTransition_GetErrorCode_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CTransition_GetErrorCode_Transition(*iUTContext,*iGetErrorCodeValidator));
	AddTransitionL(new(ELeave)CTransition_RunTransition_Transition(*iUTContext,*iRunTransitionValidator));

	iDtorValidator = new(ELeave) TTransition_Dtor_TransitionValidator(*iUTContext);
	AddBlockingTransitionL(new(ELeave)CTransition_Dtor_Transition(*iUTContext,*iDtorValidator));
	}