// 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 <e32std.h>

#include <e32uid.h>

#include "TestController.h"

#include "ComponentTester.h"

#include <ecom/test_bed/testbeddefinitions.h>

#include <ecom/test_bed/datalogger.h>

CTestController::CTestController(CActiveScheduler* aScheduler, RTest* aRTest)

: CBase(),

iScheduler(aScheduler),

iRTest(aRTest)

	{

	}

EXPORT_C CTestController::~CTestController()

	{

	// Cancel any outstanding tests

	Cancel();

	iTestList.ResetAndDestroy();

	delete iTestManager;

	if(iOwnScheduler)

		delete iScheduler;

	Dll::SetTls(NULL);

	delete iDataLogger;

	}

EXPORT_C CTestController* CTestController::NewLC(CActiveScheduler* aScheduler,

												 ComponentTesterInitialiserLC aEntryPoint,

												 RTest* aRTest,

												 TLoggingInfo* aLogInfo)

	{

	CTestController* self = new (ELeave) CTestController(aScheduler, aRTest);

	CleanupStack::PushL(self);

	self->ConstructL(aLogInfo, aEntryPoint);

	return self;

	}

EXPORT_C CTestController* CTestController::NewL(CActiveScheduler* aScheduler,

												ComponentTesterInitialiserLC aEntryPoint,

												RTest* aRTest,

												TLoggingInfo* aLogInfo)

	{

	CTestController* self = NewLC(aScheduler, aEntryPoint, aRTest, aLogInfo);

	CleanupStack::Pop();

	return self;

	}

void CTestController::ConstructL(TLoggingInfo* aLogInfo, ComponentTesterInitialiserLC aEntryPoint)

	{

	if(iScheduler == NULL)

		{

		  // Construct and install the active scheduler

		iScheduler = new (ELeave) CActiveScheduler;

		iOwnScheduler = ETrue;

		CActiveScheduler::Install(iScheduler); 

		}

	// Create a logging channel

	iDataLogger = CDataLogger::NewL(aLogInfo);

	Dll::SetTls(iDataLogger);

	// Create the component tester object required for testing

	InitialiseComponentTesterL(aEntryPoint);

	_LIT(KCreatingTestManager,"Creating a test manager");

	iDataLogger->LogInformation(KCreatingTestManager());

	iTestManager = CTestManager::NewL(&iTestList, *iDataLogger, *this, iRTest);

	}

EXPORT_C void CTestController::Start()

	{

	iTestManager->RunTests(NULL);

	iScheduler->Start();

	}

EXPORT_C void CTestController::Start(RPointerArray<TTestInfo>* aTests)

	{

	iTestManager->RunTests(aTests);

	iScheduler->Start();

	}

EXPORT_C void CTestController::Start(TRequestStatus* aStatus)

	{

	Start(aStatus, NULL);

	}

EXPORT_C void CTestController::Start(TRequestStatus* aStatus, RPointerArray<TTestInfo>* aTests)

	{

	__ASSERT_DEBUG(CActiveScheduler::Current(), User::Invariant());

	iClientStatus = aStatus;

	iTestManager->RunTests(aTests);

	}

EXPORT_C const RPointerArray<CComponentInfo>& CTestController::FindComponents() const

	{

	// Return the list of classes that can be tested

	return iTestList;

	}

/**

	@fn				CleanupArray(TAny* aArray)

	Intended Useage:The CleanupArray 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 CleanupArray(TAny* aArray)

	{

	RPointerArray<CUnitTestInfo>* array = 

		REINTERPRET_CAST(RPointerArray<CUnitTestInfo>*, aArray);

	array->ResetAndDestroy();

	delete array;

	}

void CTestController::InitialiseComponentTesterL(ComponentTesterInitialiserLC aEntryPointLC)

	{

	_LIT(KInitCompTester, "Initialising derived component tester object");

	iDataLogger->LogInformation(KInitCompTester());

	// Invoking the function passed in will result in a derived 

	// CComponentTester object being created and pushed on the clean up 

	// stack. Therefore we need to do a pop and destroy later.

	CComponentTester* componentTesterFromEXE =  aEntryPointLC(*iDataLogger,*iTestManager);

	_LIT(KCreateTranSets,"Creating component tester & Building Unit Test information.");

	iDataLogger->LogInformation(KCreateTranSets());

	RPointerArray<CUnitTestInfo>* unitTests = componentTesterFromEXE->TransitionSetsL();

	CleanupStack::PopAndDestroy(componentTesterFromEXE);	//componentTester as pushed by aEntryPoint

	TCleanupItem cleanup(CleanupArray, unitTests);

	CleanupStack::PushL(cleanup);

	CComponentInfo* info = CComponentInfo::NewL(aEntryPointLC, unitTests);

	CleanupStack::Pop(unitTests);	// unitTests, now owned by info

	CleanupStack::PushL(info);

	User::LeaveIfError(iTestList.Append(info));		// pass ownership onto the list.

	CleanupStack::Pop(info); // now owned by iTestList

	}

EXPORT_C CDataLogger& CTestController::DataLogger()

	{

	return *(REINTERPRET_CAST(CDataLogger*,Dll::Tls()));

	}

EXPORT_C void CTestController::Cancel()

	{

	if(iTestManager)

		{

		iTestManager->Cancel();

		if(!iTestManager->StartedTests() && iClientStatus)

			{

			User::RequestComplete(iClientStatus, KTestBedTestCancel);

			iClientStatus = NULL;

			}

		}

	}

void CTestController::TestsComplete()

	{

	if(iClientStatus)

		{

		User::RequestComplete(iClientStatus, KErrNone);

		iClientStatus = NULL;

		}

	else

		CActiveScheduler::Stop();

	}