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

	}

	}