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

	}