// Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// @file testcasecontroller.cpp

// @internalComponent

// 

//

#include "basetestcase.h"

#include "testcasecontroller.h"

#include "testcasefactory.h"

#include "testengine.h"

#include "testpolicy.h"

#include "testdebug.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "TestCaseControllerTraces.h"

#endif

_LIT(KClientDeviceDriverName,"EUSBC");

_LIT(KHostDeviceDriverName,"usbhubdriver");

_LIT(KHostDeviceInterfaceDriverName,"usbdi");

_LIT(KOtgdiLddFileName, "otgdi");

namespace NUnitTesting_USBDI

	{

CTestCaseController* CTestCaseController::NewL(CTestEngine& aTestEngine,TBool aHostRole)

	{

	OstTraceFunctionEntryExt( CTESTCASECONTROLLER_NEWL_ENTRY, 0 );

	CTestCaseController* self = new (ELeave) CTestCaseController(aTestEngine,aHostRole);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	OstTraceFunctionExit1( CTESTCASECONTROLLER_NEWL_EXIT, ( TUint )( self ) );

	return self;

	}

CTestCaseController::CTestCaseController(CTestEngine& aTestEngine,TBool aHostRole)

:	CActive(EPriorityStandard),

	iTestEngine(aTestEngine),

	iHostRole(aHostRole)

	{

	OstTraceFunctionEntryExt( CTESTCASECONTROLLER_CTESTCASECONTROLLER_ENTRY, this );

	// Add to current threads active scheduler

	CActiveScheduler::Add(this);

	OstTraceFunctionExit1( CTESTCASECONTROLLER_CTESTCASECONTROLLER_EXIT, this );

	}

CTestCaseController::~CTestCaseController()

	{

    OstTraceFunctionEntry1( CTESTCASECONTROLLER_CTESTCASECONTROLLER_ENTRY_DUP01, this );

	Cancel(); // Cancels any oustanding test cases

	delete iTestPolicy;

	if(iHostRole)

		{	

		TInt err = User::FreeLogicalDevice(KHostDeviceInterfaceDriverName);

		if(err != KErrNone)

			{

			OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_DCTESTCASECONTROLLER, "<Error %d> Unable to unload driver: %S",err,KHostDeviceInterfaceDriverName());

			}

		err = User::FreeLogicalDevice(KHostDeviceDriverName);

		if(err != KErrNone)

			{

			OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_DCTESTCASECONTROLLER_DUP01, "<Error %d> Unable to unload driver: %S",err,KHostDeviceDriverName());

			}

		err = User::FreeLogicalDevice(KOtgdiLddFileName);

		if(err != KErrNone)

			{

			OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_DCTESTCASECONTROLLER_DUP02, "<Error %d> Unable to unload driver: %S",err,KHostDeviceDriverName());

			}			

		}

	else

		{

		TInt err(User::FreeLogicalDevice(KClientDeviceDriverName));

		if(err != KErrNone)

			{

			OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_DCTESTCASECONTROLLER_DUP03, "<Error %d> Unable to unload driver: %S",err,KClientDeviceDriverName());

			}		

		}

	OstTraceFunctionExit1( CTESTCASECONTROLLER_CTESTCASECONTROLLER_EXIT_DUP01, this );

	}

void CTestCaseController::ConstructL()

	{

	OstTraceFunctionEntry1( CTESTCASECONTROLLER_CONSTRUCTL_ENTRY, this );

	TInt err = KErrNone;

	_LIT(KLoadingNamedDriverString,"loading driver: %S\n");

	_LIT(KLoadedNamedDriverString,"loaded driver: %S\n");

	// loading drivers

	if(iHostRole)

		{

		gtest.Printf(KLoadingNamedDriverString,&KHostDeviceDriverName);		

		OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL, "loading driver: %S\n", KHostDeviceDriverName());		

		// Load both Host USB device drivers

		err = User::LoadLogicalDevice(KHostDeviceDriverName);

		gtest((err == KErrNone) || (err == KErrAlreadyExists));

		gtest.Printf(KLoadedNamedDriverString,&KHostDeviceDriverName);

		OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP01, "loaded driver: %S\n",KHostDeviceDriverName());

		OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP02, "loading driver: %S\n",KHostDeviceInterfaceDriverName());

		err = User::LoadLogicalDevice(KHostDeviceInterfaceDriverName);

		gtest((err == KErrNone) || (err == KErrAlreadyExists));

		gtest.Printf(KLoadedNamedDriverString,&KHostDeviceInterfaceDriverName);

		OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP03, "loaded driver: %S\n",KHostDeviceInterfaceDriverName());

		// If test cases are running USB host side actions

		// then run each test case in its own thread		

		iTestPolicy = CThreadTestPolicy::NewL();

		}

	else

		{

		// Load the USB client driver	

		gtest.Printf(KLoadingNamedDriverString,&KClientDeviceDriverName);

		OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP04, "loading driver: %S\n",KClientDeviceDriverName());

		err = User::LoadLogicalDevice(KClientDeviceDriverName);

		gtest((err == KErrNone) || (err == KErrAlreadyExists));

		gtest.Printf(KLoadedNamedDriverString,&KClientDeviceDriverName);

		OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP05, "loaded driver: %S\n",KClientDeviceDriverName());

		// Run each test case in the main thread as its not new API 

		// and not expected to panic

		iTestPolicy = CBasicTestPolicy::NewL();		

		}

	// Get the identity of the next test case to run	

	err = iTestEngine.NextTestCaseId(iTestCaseId);

	gtest.Next(iTestCaseId);

	// Run the test case	

	iTestPolicy->RunTestCaseL(iTestCaseId,iStatus);

	SetActive();

	OstTraceFunctionExit1( CTESTCASECONTROLLER_CONSTRUCTL_EXIT, this );

	}

void CTestCaseController::DoCancel()

	{

	OstTraceFunctionEntry1( CTESTCASECONTROLLER_DOCANCEL_ENTRY, this );

	// Cancel the outstanding test case running

	iTestPolicy->Cancel();

	OstTraceFunctionExit1( CTESTCASECONTROLLER_DOCANCEL_EXIT, this );

	}

void CTestCaseController::RunL()

	{

    OstTraceFunctionEntry1( CTESTCASECONTROLLER_RUNL_ENTRY, this );

	// Retrieve the completion code of the last test case run

	TInt err(iStatus.Int());

	TBuf<64> log;

	if(err != KErrNone)

		{

		iTestCasesResults.Append(EFalse);

		gtest.Printf(_L("FAILED err=%d\n"),err);

		OstTrace1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL, "FAILED err=%d\n",err);

		}

	else

		{

		iTestCasesResults.Append(ETrue);

		gtest.Printf(_L("PASSED\n"));

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP01, "PASSED\n");

		}

	// Get the identity of the next test case to run

	err = iTestEngine.NextTestCaseId(iTestCaseId);

	if(err == KErrNone)

		{

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP02, "\n");

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP03, "\n");

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP04, "\n");

		gtest.Next(iTestCaseId);

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP05, "                              --------------------");

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP06, "\n");

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP07, "\n");

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP08, "\n");

		// Run the next test case

		iTestPolicy->RunTestCaseL(iTestCaseId,iStatus);

		SetActive();

		}

	else if(err == KErrNotFound)

		{

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP09, "All specified test cases performed");

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP10, "----------------------------------");

		// count nb failures

		TUint nbFailures = 0;

		for(TInt test = 0; test < iTestCasesResults.Count() ; test++)

			{

			if(!iTestCasesResults[test])

				//NB iTestCasesResults is a boolean array added to each time a test is run...

				//   ...even if it is a repeat.

				{

				nbFailures++;

				}

			}

		OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP11, "There are %d test case results, %d failures", iTestCasesResults.Count(), nbFailures);

		// Number of tests that should have been run (including repeats)

		TUint nbTests = iTestEngine.TestCasesIdentities().Count() * iTestEngine.NumRepeats();

		if(nbTests!=iTestCasesResults.Count())

			{

			OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP12, "The number of tests that should have been run (%d) DOES NOT EQUAL the actual number of tests run (%d).", 

						  nbTests, iTestCasesResults.Count());

			OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP13, "This test suite will now PANIC!");

			}

		ASSERT((nbTests==iTestCasesResults.Count()));

		for(TInt repeat = 0; repeat < iTestEngine.NumRepeats() ; repeat++)

			{

			if(iTestEngine.NumRepeats() > 1)

				{

				OstTrace1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP14, "Test Case Loop %d..........",	repeat+1);			

				}

			for(TInt testIndex = 0; testIndex < iTestEngine.TestCasesIdentities().Count() ; testIndex++)

				{

				if(iTestCasesResults[testIndex])

					{

					OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP15, "Test Case: %S : PASSED",	*(iTestEngine.TestCasesIdentities())[testIndex]);			

					}

				else

					{

					OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP16, "Test Case: %S : FAILED",	*(iTestEngine.TestCasesIdentities())[testIndex]);

					}

				}

			}

		OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP17, "CActiveScheduler::Stop CTestCaseController::RunL");

		CActiveScheduler::Stop();

		}

	else

		{

		OstTrace1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP18, "<Error %d> Unknown error from CTestEngine::NextTestCaseId",err);

		User::Leave(err);

		}

	OstTraceFunctionExit1( CTESTCASECONTROLLER_RUNL_EXIT, this );

	}

TInt CTestCaseController::RunError(TInt aError)

	{

	OstTraceFunctionEntryExt( CTESTCASECONTROLLER_RUNERROR_ENTRY, this );

	switch(aError)

		{

		case KErrNoMemory: //follow through

		default:

			// Panic the test module

			gtest(EFalse);

			break;

		}

	OstTraceFunctionExitExt( CTESTCASECONTROLLER_RUNERROR_EXIT, this, KErrNone );

	return KErrNone;

	}

	}