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

CTestManager::CTestManager(RPointerArray<CComponentInfo>* aTestList, 

						   CDataLogger& aDataLogger,

						   MManagerObserver& aObserver,

						   RTest* aRTest)

: CActive(CActive::EPriorityStandard),

iObserver(aObserver),

iTestList(aTestList),

iDataLogger(aDataLogger),

iRTest(aRTest)

	{

	}

CTestManager* CTestManager::NewL(RPointerArray<CComponentInfo>* aTestList, 

								 CDataLogger& aDataLogger,

								 MManagerObserver& aObserver,

								 RTest* aRTest)

	{

	CTestManager* self = new (ELeave) CTestManager(aTestList, aDataLogger, aObserver, aRTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CTestManager::ConstructL()

	{

	CActiveScheduler::Add(this);

	// Say we are stopping just in case RunTests never gets called

	// - if it does get called this will get unset

	iAmStopping = ETrue;

	}

CTestManager::~CTestManager()

	{

	Cancel();

	delete iCurrentTester;

	}

void CTestManager::RunL()

	{

	delete iCurrentTester;

	iCurrentTester = NULL;

	if((iCurrentTestLoad < iTestList->Count()) && !iAmStopping)

		{

		iStatus = KRequestPending;

		SetActive();

		TestComponentL(iCurrentTestLoad);

		// Next time run the next test

		++iCurrentTestLoad;

		// Set the flag for the next state.

		iAmStopping = iCurrentTestLoad == iTestList->Count();

		}

	else if(iAmStopping)

		iObserver.TestsComplete();

	}

TInt CTestManager::RunError(TInt /*aErrorCode*/)

	{

	// Do nothing because anything that needs to be cleaned up should be on the cleanup

	// stack. We want any remaining tests to carry on.

	return KErrNone;

	}

void CTestManager::DoCancel()

	{

	_LIT(KTestsCancelled,"TestBed cancelled at user request.");

	iDataLogger.LogInformation(KTestsCancelled());

	iDataLogger.ReportInformation(KTestsCancelled());

	delete iCurrentTester;

	iCurrentTester = NULL;

	iObserver.TestsComplete();

	}

void CTestManager::RunTests(RPointerArray<TTestInfo>* aTests)

	{

	iTestsToRun = aTests;

	if(iTestList->Count() >0)

		iAmStopping = EFalse;

	else

		{

		// If someone tried to call RunTests when there are no tests

		// complete immediately

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		}

	if(!IsActive())

		{

		SetActive();

		if(!iAmStopping)

			{

			TRequestStatus* status = &iStatus;

			User::RequestComplete(status, KErrNone);

			}

		else

			iStatus = KRequestPending;

		}

	}

/**

	@fn				CleanupTestArray(TAny* aArray)

	Intended Useage:The CleanupTestArray method is used for cleanup support 

					of locally declared arrays

	@internalComponent

	@since			7.0

	@param			aArray is the array whose contents should be destroyed

*/

static void CleanupTestArray(TAny* aArray)

	{

	// Whilst this array is an RPointerArray, it does not own the pointers

	// and therefor should not destroy them

	// This should be changed to an RArray

	RPointerArray<TTestInfo>* array = REINTERPRET_CAST(RPointerArray<TTestInfo>*, aArray);

	array->Reset();

	delete array;

	}

void CTestManager::Complete(CComponentTester* /*aTester*/, TInt /*aUnitTestId*/)

	{

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

void CTestManager::TestComponentL(TInt aComponentIndex)

	{

	// This should be changed to an RArray<TTestInfo*> and be typedefd

	RPointerArray<TTestInfo>* tests = NULL;

	if(iTestsToRun != NULL)

		{

		tests = new(ELeave) RPointerArray<TTestInfo>;

		TCleanupItem cleanup(CleanupTestArray, tests);

		CleanupStack::PushL(cleanup);

		// Work out which tests to run

		for(TInt index = 0; index < iTestsToRun->Count(); ++index)

			{

			if((*iTestsToRun)[index]->iComponentId == aComponentIndex)

				User::LeaveIfError(tests->Append((*iTestsToRun)[index]));

			}

		if(tests->Count() == 0)

			{

			CleanupStack::PopAndDestroy();	// cleanup

			Complete(NULL, 0);

			return;

			}

		}

	// Create the EXEs derived CComponentTester for this test iteration.

	ComponentTesterInitialiserLC createLC = (*iTestList)[aComponentIndex]->GlobalEntryFunc();

	iCurrentTester= createLC(iDataLogger, *this);

	CleanupStack::Pop(iCurrentTester);

	iCurrentTester->SetRTest(iRTest);

	if(iTestsToRun != NULL)

		CleanupStack::Pop();				// cleanup

	// Execute unit tests for the current component

	iCurrentTester->TestComponent(tests);

	}

TBool CTestManager::StartedTests() const

	{

	return iCurrentTestLoad > 0;

	}