// 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:

 // Implementation of the CUnitTest base class.

 // 

 //

 #include <ecom/test_bed/unittest.h>

 #include <ecom/test_bed/transition.h>

 #include <ecom/test_bed/datalogger.h>

 #include <ecom/test_bed/testbeddefinitions.h>

 EXPORT_C CUnitTest::~CUnitTest()

 	{

 	Cancel();

 	// Delete any outstanding asynchronous transitions

 	if(iOutstandingTransitions)

 		{

 		iOutstandingTransitions->Reset();

 		delete iOutstandingTransitions;

 		}

 	if(iTransitions)

 		{

 		iTransitions->ResetAndDestroy();

 		delete iTransitions;

 		}

 	iLeaveErrorArray.Reset();

 	delete iFileMan;

 	iFs.Close();

 	}

 EXPORT_C void CUnitTest::UnitTestConstructL()

 	{

 	User::LeaveIfError(iFs.Connect());

 	iFileMan = CFileMan::NewL(iFs);

 	CTimer::ConstructL();

 	iTransitions = new(ELeave) RPointerArray<CTransition>;

 	iOutstandingTransitions = new(ELeave) RPointerArray<CTransition>;

 	_LIT(KConstructingUnitTestMsg, "Constructed Unit Test named %S");

 	iDataLogger.LogInformationWithParameters(KConstructingUnitTestMsg, &iUnitTestName);

 	}

 CUnitTestInfo* CUnitTest::TransitionSetL() const

 	{

 	CUnitTestInfo* transitionSet = CUnitTestInfo::NewL(iUnitTestName);

 	return transitionSet;

 	}

 EXPORT_C void CUnitTest::RunTest(TTimeIntervalMicroSeconds32 aTimeAfter /*= 0*/)

 	{

 	After(aTimeAfter);

 	_LIT(KTxtSeparator, "-----------------------------------------------------------------------------------");

 	_LIT(KStartingUnitTest, "Beginning Unit Test named %S");

 	iDataLogger.LogInformation(KTxtSeparator);

 	iDataLogger.LogInformationWithParameters(KStartingUnitTest, &iUnitTestName);

 	iDataLogger.ReportInformationWithParameters(KStartingUnitTest, &iUnitTestName);

 	}

 EXPORT_C void CUnitTest::RunL()

 	{

 	_LIT(KUnitTestRunLPanic, "CUnitTest::RunL");

 	TInt status = iStatus.Int();

 	switch(status)

 		{

 		case (KTestBedRepeatTest):			/* A stub has requested repeat of the last test */

 			// Go back one so that we repeat the last test

 			--iNextTransitionIndex;

 			break;

 		case (KTestBedTestLeft):				/* The last transition's RunL left */

 		case (KTestBedTestCancel):				/* The last transition was cancelled */

 		case (KTestBedLeakTestLoopDetected):	/* A leak test detected an infinite loop */

 		case (KTestBedFailedPreConditions):		/* The last transition failed it's pre conditions */

 		case (KTestBedFailedPostConditions):	/* The last transition failed it's post conditions */

 			// Go to the end of the test so that it finishes

 			iNextTransitionIndex = iTransitions->Count();

 			break;

 		case (KTestBedAsynchronousTransition):	/* The last transition started an async request */

 			// Remember that we have an outstanding request and then carry on

 			iOutstandingTransitions->Append((*iTransitions)[iNextTransitionIndex - 1]);

 			break;

 		case (KErrNone):

 			break;

 		default:

 			User::Panic(KUnitTestRunLPanic, KTestBedInvalidStatus);

 		}

 	// If we still have more transitions to run

 	if(iNextTransitionIndex < iTransitions->Count())

 		{

 		iStatus = KRequestPending;

 		SetActive();

 		// If the next transition is a blocking one then wait for all outstanding async

 		// requests to complete.  Otherwise just run the next transition

 		if(((*iTransitions)[iNextTransitionIndex]->IsBlockingTransition()) && 

 			(iOutstandingTransitions->Count() > 0))

 			{

 			iWaitingForCompletion = ETrue;

 			}

 		else

 			{

 			(*iTransitions)[iNextTransitionIndex]->RunTransition(&iStatus);

 			++iNextTransitionIndex;

 			}

 		}

 	else

 		{

 		// If we still have outstanding async requests then wait for these to complete

 		// otherwise we have finished this test

 		if(iOutstandingTransitions->Count() > 0)

 			{

 			iWaitingForCompletion = ETrue;

 			iStatus = KRequestPending;

 			SetActive();

 			}

 		else

 			{

 			iUnitTestObserver.Complete(this);

 			_LIT(KInfoPrintFailed, "Failed: Unit Test");

 			_LIT(KTestLeft, "Failed: Unit Test %S left");

 			_LIT(KTestLeftWithUnexpectedError, "Failed: Test %S left with unexpected error");

 			_LIT(KTestFailed, "Failed: Unit Test %S failed a pre/post condition validation check");

 			_LIT(KTestLeftWithExpectedError, "Test %S left with an anticipated error");

 			_LIT(KTestCancelled, "Cancelled: Unit Test Transition %S was cancelled");

 			_LIT(KTestEnteredInfiniteLoop, "Unit Test Transition %S aborted (infinitely looping)");

 			_LIT(KEndingUnitTest, "Successfully completed Unit Test %S");

 			// We use RTest if it is present in the framework to validate

 			// status codes for errors. Note: not all non KErrNone code mean 

 			// there was an error and so we need to selective over which 

 			// cases below we use RTest().

 			switch(status)

 				{

 				case (KTestBedTestLeft):

 					{

 					TInt leaveCode = iCurrentlyExecutingTransition->GetErrorCode();

 					//Check to see if the leave code is NOT on the list of known leaving codes

 					if(iLeaveErrorArray.Find(leaveCode) == KErrNotFound)

 						{

 						iDataLogger.LogInformationWithParameters(KTestLeft, &iUnitTestName);

 						iDataLogger.ReportInformationWithParameters(KTestLeft, &iUnitTestName);

 						if(iRTest) 

 							{

 							(*iRTest)(status==KErrNone);

 							}

 						}

 					else	//Leave code is on the list 

 						{

 						TInt count = iTransitions->Count();

 						//Check transition number and if it is the last transition then this is an expected error

 						CTransition* lastTransition = (*iTransitions)[count-1];

 						if(iCurrentlyExecutingTransition == lastTransition)

 							{

 							iDataLogger.LogInformationWithParameters(KTestLeftWithExpectedError, &iUnitTestName);

 							iDataLogger.ReportInformationWithParameters(KEndingUnitTest, &iUnitTestName);

 							}

 						else	//Otherwise, if not the last transition, the test failed with an unexpected error

 							{

 							User::InfoPrint(KInfoPrintFailed);

 							User::InfoPrint(iUnitTestName);

 							iDataLogger.LogInformationWithParameters(KTestLeftWithUnexpectedError, &iUnitTestName);

 							iDataLogger.ReportInformationWithParameters(KTestLeftWithUnexpectedError, &iUnitTestName);

 							if(iRTest) 

 								{

 								(*iRTest)(status==KErrNone);

 								}

 							}

 						}

 					}

 					break;

 				case (KTestBedFailedPreConditions):

 				case (KTestBedFailedPostConditions):

 					{

 					User::InfoPrint(KInfoPrintFailed);

 					User::InfoPrint(iUnitTestName);

 					iDataLogger.LogInformationWithParameters(KTestFailed, &iUnitTestName);

 					iDataLogger.ReportInformationWithParameters(KTestFailed, &iUnitTestName);

 					if(iRTest) 

 						{

 						(*iRTest)(status==KErrNone);

 						}

 					}

 					break;

 				case (KTestBedTestCancel):

 					iDataLogger.LogInformationWithParameters(KTestCancelled, &iUnitTestName);

 					iDataLogger.ReportInformationWithParameters(KTestCancelled, &iUnitTestName);

 					if(iRTest) 

 						{

 						(*iRTest)(status==KErrNone);

 						}

 					break;

 				case (KTestBedLeakTestLoopDetected):

 					iDataLogger.LogInformationWithParameters(KTestEnteredInfiniteLoop, &iUnitTestName);

 					iDataLogger.ReportInformationWithParameters(KTestEnteredInfiniteLoop, &iUnitTestName);

 					if(iRTest) 

 						{

 						(*iRTest)(status==KErrNone);

 						}

 					break;

 				case (KErrNone):

 					iDataLogger.LogInformationWithParameters(KEndingUnitTest, &iUnitTestName);

 					iDataLogger.ReportInformationWithParameters(KEndingUnitTest, &iUnitTestName);

 					break;

 				default:

 					User::Panic(KUnitTestRunLPanic, KTestBedInvalidStatus);

 				}

 			}

 		}

 	}

 EXPORT_C void CUnitTest::AddTransitionL(CTransition* aTransition)

 	{

 	__ASSERT_DEBUG(aTransition, User::Panic(_L("CUnitTest"), KErrTestBedInvalidTransition));

 	CleanupStack::PushL(aTransition);

 	User::LeaveIfError(iTransitions->Append(aTransition));

 	CleanupStack::Pop(aTransition);

 	}

 EXPORT_C void CUnitTest::AddBlockingTransitionL(CTransition* aTransition)

 	{

 	__ASSERT_DEBUG(aTransition, User::Panic(_L("CUnitTest"), KErrTestBedInvalidTransition));

 	aTransition->SetBlockingTransition(ETrue);

 	CleanupStack::PushL(aTransition);

 	User::LeaveIfError(iTransitions->Append(aTransition));

 	CleanupStack::Pop(aTransition);

 	}

 EXPORT_C void CUnitTest::AddLeaveErrorCodeL(TInt aLeaveErrorCode)

 	{

 	User::LeaveIfError(iLeaveErrorArray.Append(aLeaveErrorCode));

 	}

 EXPORT_C CTransition& CUnitTest::GetCurrentTransition() const

 	{

 	// Check fror a stray stub call

 	// We will always have a valid pointer here IF called

 	// from a stub in response to that transition's call 

 	// on the stub's methods.

 	__ASSERT_DEBUG(iCurrentlyExecutingTransition, User::Invariant());

 	return *iCurrentlyExecutingTransition;

 	}

 EXPORT_C void CUnitTest::SetCurrentTransition(CTransition& aTransition)

 	{

 	iCurrentlyExecutingTransition = &aTransition;

 	}

 EXPORT_C void CUnitTest::Complete(CTransition& aTransition, TInt aAsyncPostCheckError)

 	{

 	// Should never be NULL at this point

 	__ASSERT_DEBUG(iCurrentlyExecutingTransition, User::Invariant());

 	if(iCurrentlyExecutingTransition == &aTransition)

 		iCurrentlyExecutingTransition = NULL;	// Clear the current transition

 	// Oops the code will crash if this is ever false

 	__ASSERT_DEBUG(iOutstandingTransitions, User::Invariant());

 	// Look-up the transition passed in...

 	TInt index = iOutstandingTransitions->Find(&aTransition);

 	if(index != KErrNotFound)

 		{

 		// ... and remove from the set of outstanding ones.

 		iOutstandingTransitions->Remove(index);

 		// Did we fail a second-phase post-condition validation on an asynchronous transition?

 		// Or was it a normal transition completion?  Regardless, we go for another iteration 

 		// of the AO, passing through the error code.

 		TBool completeIt = (aAsyncPostCheckError != KErrNone);

 		if(iWaitingForCompletion && (iOutstandingTransitions->Count() == 0))

 			completeIt = ETrue;

 		if (completeIt)

 			{

 			TRequestStatus* status = &iStatus;

 			User::RequestComplete(status, aAsyncPostCheckError);

 			}

 		}

 	else

 		{

 		__ASSERT_DEBUG(ETrue, 

 			User::Panic(_L("CUnitTest"), KErrTestBedInvalidTransition));

 		}

 	}

 EXPORT_C void CUnitTest::SetParametersL(TAny* /*aParams*/)

 	{

 	// Do nothing

 	}

 EXPORT_C void CUnitTest::DoCancel()

 	{

 	CTimer::DoCancel();

 	if(iCurrentlyExecutingTransition)

 		iCurrentlyExecutingTransition->Cancel();

 	// Cancel any outstanding asynchronous transitions

 	if(iOutstandingTransitions)

 		{

 		TInt count = iOutstandingTransitions->Count();

 		for(TInt index = 0; index < count; ++index)

 			{

 			(*iOutstandingTransitions)[index]->Cancel();

 			}

 		}

 	iUnitTestObserver.Complete(this);

 	}