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

 	}