// 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 "ComponentTester.h"

 #include <ecom/test_bed/datalogger.h>

 #include <ecom/test_bed/testbeddefinitions.h>

 EXPORT_C CComponentTester::CComponentTester(CDataLogger&			aDataLogger, 

 											MComponentTestObserver& aObserver)

 : CActive(CActive::EPriorityStandard),

 iDataLogger(aDataLogger),

 iObserver(aObserver)

 	{

 	CActiveScheduler::Add(this);

 	}

 EXPORT_C CComponentTester::~CComponentTester()

 	{

 	Cancel();

 	// This should only be true during if TransitionSetsL() left and we are being

 	// destroyed as part of cleanup

 	if(iTransitionSets)

 		{

 		iTransitionSets->ResetAndDestroy();

 		delete iTransitionSets;

 		}

 	iParameterizedTests.Reset();

 	if(iUnitTests)

 		{

 		iUnitTests->ResetAndDestroy();

 		delete iUnitTests;

 		}

 	if(iUnitTestsToRun)

 		{

 		// We own the list but not the things on it.  So reset the list and delete it

 		iUnitTestsToRun->Reset();

 		delete iUnitTestsToRun;

 		}

 	}

 EXPORT_C void CComponentTester::ComponentTesterConstructL()

 	{

 	iUnitTests = new(ELeave) RPointerArray<CUnitTest>;

 	}

 EXPORT_C RPointerArray<CUnitTestInfo>* CComponentTester::TransitionSetsL() const

 	{

 	// Create the array in a member variable to ensure correct cleanup but we do not

 	// own this object.  Ownership is passed at the return

 	iTransitionSets = new(ELeave) RPointerArray<CUnitTestInfo>;

 	if(iUnitTests)

 		{

 		TInt numTests = iUnitTests->Count();

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

 			{

 			CUnitTestInfo* newSet = (*iUnitTests)[index]->TransitionSetL();

 			CleanupStack::PushL(newSet);

 			User::LeaveIfError(iTransitionSets->Append(newSet));

 			CleanupStack::Pop(newSet); // now owned by iTransitionSets

 			}

 		}

 	// Return the pointer and null our member variable because we don't own it

 	RPointerArray<CUnitTestInfo>* transitionSets = iTransitionSets;

 	iTransitionSets = 0;

 	return transitionSets;

 	}

 EXPORT_C void CComponentTester::Complete(CUnitTest* aUnitTest)

 	{

 	if(iUnitTestsToRun != 0)

 		{

 		if(iCurrentUnitTest == iUnitTestsToRun->Count())

 			{

 			iObserver.Complete(this, iUnitTests->Find(aUnitTest));

 			}

 		else

 			{

 			TRequestStatus* status = &iStatus;

 			User::RequestComplete(status, KErrNone);

 			}

 		}

 	else

 		{

 		if(iCurrentUnitTest == iUnitTests->Count())

 			{

 			iObserver.Complete(this, iUnitTests->Find(aUnitTest));

 			}

 		else

 			{

 			TRequestStatus* status = &iStatus;

 			User::RequestComplete(status, KErrNone);

 			}

 		}

 	}

 EXPORT_C void CComponentTester::AddUnitTestL(const CUnitTest* aUnitTest)

 	{

 	CUnitTest* thisTest = CONST_CAST(CUnitTest*, aUnitTest);

 	CleanupStack::PushL(thisTest);

 	User::LeaveIfError(iUnitTests->Append(thisTest));

 	CleanupStack::Pop(thisTest);

 	}

 EXPORT_C void CComponentTester::AddParamUnitTestL(const CUnitTest* aUnitTest)

 	{

 	CUnitTest* thisTest = CONST_CAST(CUnitTest*, aUnitTest);

 	CleanupStack::PushL(thisTest);

 	User::LeaveIfError(iUnitTests->Append(thisTest));

 	CleanupStack::Pop(thisTest);

 	TInt testId = iUnitTests->Find(thisTest);

 	User::LeaveIfError(iParameterizedTests.Append(testId));

 	}

 EXPORT_C void CComponentTester::TestComponent(RPointerArray<TTestInfo>* aTests)

 	{

 	_LIT(KStartingTestMessage, "Starting CComponentTester::TestComponent()...");

 	iDataLogger.LogInformation(KStartingTestMessage);

 	iUnitTestsToRun = aTests;

 	SetActive();

 	TRequestStatus* status = &iStatus;

 	User::RequestComplete(status, KErrNone);

 	}

 EXPORT_C void CComponentTester::RunL()

 	{

 	TBool lastTestRun = EFalse;

 	if(iUnitTestsToRun == 0)

 		{

 		TBool startFromFirst = iCurrentUnitTest == 0;

 		TBool haveRunTest = EFalse;

 		while((iCurrentUnitTest < iUnitTests->Count()) && !haveRunTest)

 			{

 			if(iParameterizedTests.Find(iCurrentUnitTest) == -1)

 				{

 				(*iUnitTests)[iCurrentUnitTest]->PrepareUnitTestL();

 				(*iUnitTests)[iCurrentUnitTest]->RunTest(0);

 				haveRunTest = ETrue;

 				}

 			++iCurrentUnitTest;

 			lastTestRun = iCurrentUnitTest == iUnitTests->Count();

 			}

 		if(startFromFirst && !haveRunTest)

 			iObserver.Complete(this, KErrNotFound);

 		}

 	else

 		{

 		if(iCurrentUnitTest < iUnitTestsToRun->Count())

 			{

 			TInt testToRun = (*iUnitTestsToRun)[iCurrentUnitTest]->iUnitTestId;

 			TTimeIntervalMicroSeconds32 time = (*iUnitTestsToRun)[iCurrentUnitTest]->iRunTime;

 			(*iUnitTests)[testToRun]->SetParametersL((*iUnitTestsToRun)[iCurrentUnitTest]->iParameters);

 			(*iUnitTests)[testToRun]->PrepareUnitTestL();

 			(*iUnitTests)[testToRun]->RunTest(time);

 			++iCurrentUnitTest;

 			lastTestRun = iCurrentUnitTest == iUnitTestsToRun->Count();

 			}

 		}

 	// We don't need to be active for the last test because we don't RunL again

 	if(!lastTestRun)

 		{

 		iStatus = KRequestPending;

 		SetActive();

 		}

 	}

 EXPORT_C void CComponentTester::DoCancel()

 	{

 	// If we have started a test then we have already advanced iCurrentUnitTest so cancel 

 	// the previous test

 	if(iCurrentUnitTest > 0)

 		(*iUnitTests)[iCurrentUnitTest - 1]->Cancel();

 	iObserver.Complete(this, KTestBedTestCancel);

 	}

 EXPORT_C void CComponentTester::SetRTest(RTest* aRTest)

 	{

 	// Record a handle on the RTest object to use in component testing.

 	iRTest = aRTest;

 	// We have a new RTest, best tell the unit tests we know about

 	for (int ut=0; ut < iUnitTests->Count(); ut++)

 		(*iUnitTests)[ut]->SetRTest(aRTest);

 	}