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


	}