--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/usbho/t_usbdi/src/TestCaseController.cpp	Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,268 @@
+// 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;
+	}
+
+
+	}
+
+
+
+