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