// Copyright (c) 2007-2009 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"

_LIT(KClientDeviceDriverName,"EUSBC");

_LIT(KHostDeviceDriverName,"usbhubdriver");

_LIT(KHostDeviceInterfaceDriverName,"usbdi");

_LIT(KOtgdiLddFileName, "otgdi");

namespace NUnitTesting_USBDI

	{

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

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

:	CActive(EPriorityStandard),

	iTestEngine(aTestEngine),

	iHostRole(aHostRole)

	{

	// Add to current threads active scheduler

	CActiveScheduler::Add(this);

	}

CTestCaseController::~CTestCaseController()

	{

	LOG_FUNC 

	Cancel(); // Cancels any oustanding test cases

	delete iTestPolicy;

	if(iHostRole)

		{	

		TInt err = User::FreeLogicalDevice(KHostDeviceInterfaceDriverName);

		if(err != KErrNone)

			{

			RDebug::Printf("<Error %d> Unable to unload driver: %S",err,&KHostDeviceInterfaceDriverName);

			}

		err = User::FreeLogicalDevice(KHostDeviceDriverName);

		if(err != KErrNone)

			{

			RDebug::Printf("<Error %d> Unable to unload driver: %S",err,&KHostDeviceDriverName);

			}

		err = User::FreeLogicalDevice(KOtgdiLddFileName);

		if(err != KErrNone)

			{

			RDebug::Printf("<Error %d> Unable to unload driver: %S",err,&KHostDeviceDriverName);

			}			

		}

	else

		{

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

		if(err != KErrNone)

			{

			RDebug::Printf("<Error %d> Unable to unload driver: %S",err,&KClientDeviceDriverName);

			}		

		}

	}

void CTestCaseController::ConstructL()

	{

	LOG_FUNC

	TInt err = KErrNone;

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

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

	// loading drivers

	if(iHostRole)

		{

		gtest.Printf(KLoadingNamedDriverString,&KHostDeviceDriverName);		

		// Load both Host USB device drivers

		err = User::LoadLogicalDevice(KHostDeviceDriverName);

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

		gtest.Printf(KLoadedNamedDriverString,&KHostDeviceDriverName);

		RDebug::Print(KLoadingNamedDriverString,&KHostDeviceInterfaceDriverName);

		err = User::LoadLogicalDevice(KHostDeviceInterfaceDriverName);

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

		gtest.Printf(KLoadedNamedDriverString,&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);

		err = User::LoadLogicalDevice(KClientDeviceDriverName);

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

		gtest.Printf(KLoadedNamedDriverString,&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();

	}

void CTestCaseController::DoCancel()

	{

	// Cancel the outstanding test case running

	iTestPolicy->Cancel();

	}

void CTestCaseController::RunL()

	{

	LOG_FUNC

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

		}

	else

		{

		iTestCasesResults.Append(ETrue);

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

		}

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

	err = iTestEngine.NextTestCaseId(iTestCaseId);

	if(err == KErrNone)

		{

		RDebug::Printf("\n");

		RDebug::Printf("\n");

		RDebug::Printf("\n");

		gtest.Next(iTestCaseId);

		RDebug::Printf("                              --------------------");

		RDebug::Printf("\n");

		RDebug::Printf("\n");

		RDebug::Printf("\n");

		// Run the next test case

		iTestPolicy->RunTestCaseL(iTestCaseId,iStatus);

		SetActive();

		}

	else if(err == KErrNotFound)

		{

		RDebug::Printf("All specified test cases performed");

		RDebug::Printf("----------------------------------");

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

				}

			}

		RDebug::Printf("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())

			{

			RDebug::Printf("The number of tests that should have been run (%d) DOES NOT EQUAL the actual number of tests run (%d).", 

						  nbTests, iTestCasesResults.Count());

			RDebug::Printf("This test suite will now PANIC!");

			}

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

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

			{

			if(iTestEngine.NumRepeats() > 1)

				{

				RDebug::Printf("Test Case Loop %d..........",	repeat+1);			

				}

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

				{

				if(iTestCasesResults[testIndex])

					{

					RDebug::Print(_L("Test Case: %S : PASSED"),	(iTestEngine.TestCasesIdentities())[testIndex]);			

					}

				else

					{

					RDebug::Print(_L("Test Case: %S : FAILED"),	(iTestEngine.TestCasesIdentities())[testIndex]);

					}

				}

			}

		RDebug::Printf("CActiveScheduler::Stop CTestCaseController::RunL");

		CActiveScheduler::Stop();

		}

	else

		{

		RDebug::Printf("<Error %d> Unknown error from CTestEngine::NextTestCaseId",err);

		User::Leave(err);

		}

	}

TInt CTestCaseController::RunError(TInt aError)

	{

	LOG_FUNC

	switch(aError)

		{

		case KErrNoMemory: //follow through

		default:

			// Panic the test module

			gtest(EFalse);

			break;

		}

	return KErrNone;

	}

	}