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


	}