// 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);
	}