// 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 testpolicy.cpp

 // @internalComponent

 // 

 //

 #include "TestPolicy.h"

 #include "TestCaseFactory.h"

 #include "BaseTestCase.h"

 #include "TestCaseFactory.h"

 #include "testdebug.h"

 namespace NUnitTesting_USBDI

 	{

 CBasicTestPolicy* CBasicTestPolicy::NewL()

 	{

 	CBasicTestPolicy* self = new (ELeave) CBasicTestPolicy;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CBasicTestPolicy::CBasicTestPolicy()

 :	CActive(EPriorityStandard)

 	{

 	CActiveScheduler::Add(this);

 	}

 CBasicTestPolicy::~CBasicTestPolicy()

 	{

 	LOG_FUNC

 	Cancel();

 	}

 void CBasicTestPolicy::ConstructL()

 	{

 	}

 void CBasicTestPolicy::RunTestCaseL(const TDesC& aTestCaseId,TRequestStatus& aNotifierStatus)

 	{

 	LOG_FUNC

 	iNotifierStatus = &aNotifierStatus;

 	// Create the specified test case

 	iTestCase = RTestFactory::CreateTestCaseL(aTestCaseId,EFalse);

 	iTestCase->SetTestPolicy(this);

 	iTestCase->PerformTestL();

 	// Set the request of the notifier to pending

 	*iNotifierStatus = iStatus = KRequestPending;

 	SetActive();

 	}

 void CBasicTestPolicy::DoCancel()

 	{

 	LOG_FUNC

 	// Cancel running the test cases

 	iTestCase->Cancel();

 	// Notify the test case controller that test case execution was cancelled

 	User::RequestComplete(iNotifierStatus,KErrCancel);

 	}

 void CBasicTestPolicy::SignalTestComplete(TInt aCompletionCode)

 	{

 	LOG_FUNC

 	// Complete the test policy request with the test case completion code

 	// (Basically self completion)

 	TRequestStatus* s = &iStatus;	

 	User::RequestComplete(s,aCompletionCode);

 	}

 void CBasicTestPolicy::RunL()

 	{

 	LOG_FUNC

 	// Complete the request of the notifier with the test case 

 	// completion code

 	User::RequestComplete(iNotifierStatus,iStatus.Int());

 	// Destroy the test case

 	delete iTestCase;

 	}

 TInt CBasicTestPolicy::RunError(TInt aError)

 	{

 	LOG_FUNC

 	aError = KErrNone;

 	return aError;

 	}

 CThreadTestPolicy* CThreadTestPolicy::NewL()

 	{

 	CThreadTestPolicy* self = new (ELeave) CThreadTestPolicy;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CThreadTestPolicy::CThreadTestPolicy()

 	{

 	}

 CThreadTestPolicy::~CThreadTestPolicy()

 	{

 	iTestThread.Close();

 	if(iTestCaseId)

 		{

 		delete iTestCaseId;

 		iTestCaseId = NULL;

 		}

 	}

 void CThreadTestPolicy::ConstructL()

 	{

 	}

 void CThreadTestPolicy::RunTestCaseL(const TDesC& aTestCaseId,TRequestStatus& aNotifierStatus)

 	{

 	LOG_FUNC

 	iNotifierStatus = &aNotifierStatus;

 	RDebug::Printf("Creating thread for test case '%S'",&aTestCaseId);

 	if(iTestCaseId)

 		{

 		delete iTestCaseId;

 		iTestCaseId = NULL;

 		}

 	iTestCaseId = HBufC::NewL(aTestCaseId.Length()); 

 	*iTestCaseId = aTestCaseId;

 	// Create the thread to run the test case in

 	TInt err(iTestThread.Create(aTestCaseId,CThreadTestPolicy::ThreadFunction,

 			KDefaultStackSize,NULL,reinterpret_cast<TAny*>(iTestCaseId)));

 	if(err != KErrNone)

 		{

 		RDebug::Printf("Test thread creation unsuccessful: %d",err);

 		User::Leave(err);

 		}

 	RDebug::Printf("Test thread '%S' created",&aTestCaseId);

 	// Start the test case in the thread

 	iTestThread.Logon(iStatus);

 	SetActive();

 	iTestThread.Resume();

 	*iNotifierStatus = KRequestPending;

 	}

 void CThreadTestPolicy::SignalTestComplete(TInt aCompletionCode)

 	{

 	LOG_FUNC

 	if(aCompletionCode == KErrNone)

 		{

 		RDebug::Printf("CActiveScheduler::Stop CThreadTestPolicy::SignalTestComplete");

 		CActiveScheduler::Stop();

 		}

 	else

 		{

 		RDebug::Printf("Killing thread with: %d",aCompletionCode);

 		iTestThread.Kill(aCompletionCode);

 		}

 	}

 void CThreadTestPolicy::DoCancel()

 	{

 	LOG_FUNC

 	iTestCase->Cancel();

 	LOG_POINT(1)

 	TInt err(iTestThread.LogonCancel(iStatus));

 	if(err != KErrNone)

 		{

 		RDebug::Printf("Unable to cancel thread logon: %d",err);

 		}

 	LOG_POINT(2)

 	TRequestStatus cancelStatus;

 	iTestThread.Logon(cancelStatus);

 	LOG_POINT(3)

 	iTestThread.Kill(KErrCancel);		

 	LOG_POINT(4)

 	User::RequestComplete(iNotifierStatus,cancelStatus.Int());

 	}

 TInt CThreadTestPolicy::ThreadFunction(TAny* aThreadParameter)

 	{

 	LOG_CFUNC

 	TInt err(KErrNone);

 	TInt leaveCode(KErrNone);

 	HBufC* testCaseId = reinterpret_cast<HBufC*>(aThreadParameter);

 	// Create the cleanup stack for this thread

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	if(cleanup == NULL)

 		{

 		return KErrNoMemory;

 		}

 	TRAP(leaveCode,err = CThreadTestPolicy::DoTestL(*testCaseId));

 	if(leaveCode != KErrNone)

 		{

 		RDebug::Printf("<Error %d> Thread '%S' DoTest",leaveCode,&testCaseId);

 		err = leaveCode;

 		}

 	delete cleanup;

 	return err;

 	}

 TInt CThreadTestPolicy::DoTestL(const TDesC& aTestCaseId)

 	{

 	LOG_CFUNC

 	TInt err(KErrNone);

 	// Create a new active scheduler for this thread

 	CActiveScheduler* sched = new (ELeave) CActiveScheduler;

 	CleanupStack::PushL(sched);

 	CActiveScheduler::Install(sched);

 	CBaseTestCase* testCase = RTestFactory::CreateTestCaseL(aTestCaseId,ETrue);

 	CleanupStack::PushL(testCase);

 	// Do the test

 	testCase->PerformTestL();

 	if(!testCase->IsHostOnly())

 		{

 		// Loop for active objects

 		RDebug::Printf("CActiveScheduler::Start in CThreadTestPolicy::DoTestL");	

 		CActiveScheduler::Start();

 		}	

 	// Get the test case execution result 

 	err = testCase->TestResult();

 	// Destroy test case

 	CleanupStack::PopAndDestroy(testCase);

 	// Destroy the active scheduler	

 	CleanupStack::PopAndDestroy(sched);

 	return err;

 	}

 void CThreadTestPolicy::RunL()

 	{

 	LOG_FUNC

 	TInt completionCode(iStatus.Int());

 	TExitType exitType(iTestThread.ExitType());

 	TExitCategoryName exitName(iTestThread.ExitCategory());

 	TInt exitReason(iTestThread.ExitReason());

 	RDebug::Printf("Test thread '%S' completed with completion code %d",&iTestThread.Name(),completionCode);

 	switch(exitType)

 		{

 		// The test thread has panicked

 		// This will occur if test API panics or RTest expression is false (i.e. test case fails)

 		case EExitPanic:

 			{

 			RDebug::Printf("Test thread '%S' has panicked with category '%S' reason %d",

 						&iTestThread.Name(),&exitName,exitReason);

 			// May require to stop and start host/client USB depending on what panic category it is

 			// can no longer trust RUsbHubDriver/RDevUsbcClient to be in good state

 			completionCode = KErrAbort;

 			}

 			break;

 		// The thread has been terminated

 		case EExitTerminate:

 			{

 			RDebug::Printf("Test thread '%S' terminated with category %s reason %d",

 				&iTestThread.Name(),&exitName,exitReason);

 			}

 			break;

 		// The thread has been killed

 		// This will occur when the test thread executes normally or is cancelled

 		case EExitKill:

 			{

 			RDebug::Printf("Test thread '%S' has been killed with reason %d",&iTestThread.Name(),exitReason);

 			}

 			break;

 		// These cases should not occur at this stage

 		case EExitPending: //follow through

 		default:

 			gtest(EFalse); // Panic main thread

 			break;

 		}

 	// Close the just executed test thread

 	iTestThread.Close();

 	// Complete the notifier's request status

 	User::RequestComplete(iNotifierStatus,completionCode);

 	}

 TInt CThreadTestPolicy::RunError(TInt aError)

 	{

 	RDebug::Printf("<Error %d><Test Policy> RunError",aError);

 	return KErrNone;

 	}

 	}