// 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 PBASE-T_USBDI-0472.cpp

// @internalComponent

// 

//

#include "PBASE-T_USBDI-0472.h"

#include <e32test.h>

#include <d32usbc.h>

#include <e32debug.h>

#include "UsbDescriptorOffsets.h"

#include "TestPolicy.h"

namespace NUnitTesting_USBDI

	{

_LIT(KTestCaseId,"PBASE-T_USBDI-0472");

const TFunctorTestCase<CUT_PBASE_T_USBDI_0472,TBool> CUT_PBASE_T_USBDI_0472::iFunctor(KTestCaseId);	

CUT_PBASE_T_USBDI_0472* CUT_PBASE_T_USBDI_0472::NewL(TBool aHostRole)

	{

	CUT_PBASE_T_USBDI_0472* self = new (ELeave) CUT_PBASE_T_USBDI_0472(aHostRole);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CUT_PBASE_T_USBDI_0472::CUT_PBASE_T_USBDI_0472(TBool aHostRole)

:	CBaseTestCase(KTestCaseId,aHostRole)

	{

	} 

void CUT_PBASE_T_USBDI_0472::ConstructL()

	{

	iTestDevice = new RUsbDeviceVendor(this);

	BaseConstructL();

	}

CUT_PBASE_T_USBDI_0472::~CUT_PBASE_T_USBDI_0472()

	{

	LOG_FUNC

	Cancel();

	delete iClientAction;

	delete iActorFDF;

	if(!IsHost() && iTestDevice)

		{

		iTestDevice->Close();

		}		

	delete iTestDevice;

	}

void CUT_PBASE_T_USBDI_0472::ExecuteHostTestCaseL()

	{

	LOG_FUNC

	iActorFDF = CActorFDF::NewL(*this);

	iClientAction = new (ELeave) CEp0Transfer(iInterface0);

	iCaseStep = EConnectDevice;

	iActorFDF->Monitor();

	TimeoutIn(30);

	}

void CUT_PBASE_T_USBDI_0472::ExecuteDeviceTestCaseL()

	{

	LOG_FUNC

	iTestDevice->OpenL(TestCaseId());

	iTestDevice->SubscribeToReports(iStatus);	

	SetActive();

	iTestDevice->SoftwareConnect();

	}

void CUT_PBASE_T_USBDI_0472::HostDoCancel()

	{

	LOG_FUNC

	// Cancel the test step action timeout timer

	CancelTimeout();

	}

void CUT_PBASE_T_USBDI_0472::DeviceDoCancel()

	{

	LOG_FUNC

	// Cancel the test device

	iTestDevice->CancelSubscriptionToReports();

	}

void CUT_PBASE_T_USBDI_0472::DeviceInsertedL(TUint aDeviceHandle)

	{

	LOG_FUNC

	Cancel();

	TInt err(KErrNone);

	// Validate that device is as expected

	CUsbTestDevice& testDevice = iActorFDF->DeviceL(aDeviceHandle);

	if(testDevice.SerialNumber().Compare(TestCaseId()) != 0)

		{

		// Incorrect device for this test case	

		RDebug::Printf("<Warning %d> Incorrect device serial number (%S) connected for this test case (%S)",

			KErrNotFound,&testDevice.SerialNumber(),&TestCaseId());

		// Start the connection timeout again

		TimeoutIn(30);

		return;

		}	

	// Perform the correct test step

	switch(iCaseStep)

		{

		case EConnectDevice:

			{

			// Validate vendor identity

			RDebug::Printf("Vendor identity: 0x%04x",testDevice.VendorId());

			if(testDevice.VendorId() != 0x0E22)

				{

				RDebug::Printf("<Error> Vendor identity is not 0x0E22");

				return TestFailed(KErrCorrupt);

				}

			// Validate product information

			RDebug::Printf("Usb device supported specification: 0x%04x",testDevice.DeviceSpec());

			if(testDevice.DeviceSpec() != 0x0200)

				{

				RDebug::Printf("<Error> Usb device supported specification is not 2.0");

				return TestFailed(KErrCorrupt);

				}

			RDebug::Printf("Usb product identity: 0x%04x",testDevice.ProductId());

			if(testDevice.ProductId() != 0x0040)

				{

				RDebug::Printf("<Error> Usb product idenity is not 0x0040");

				return TestFailed(KErrCorrupt);

				}

			RDebug::Printf("testDevice.ConfigurationString() = %S",&testDevice.ConfigurationString());		

			gtest(KErrNone == testDevice.ConfigurationString().Compare(KConfigurationString()));		

			RDebug::Printf("testDevice.Manufacturer() = %S",&testDevice.Manufacturer());

			gtest(KErrNone == testDevice.Manufacturer().Compare(KManufacturer()));

			RDebug::Printf("testDevice.SerialNumber = %s",&testDevice.SerialNumber());	

			gtest(KErrNone == testDevice.SerialNumber().Compare(KTestCaseId()));

			RDebug::Printf("Waiting for device removal");

			iCaseStep = ERemoveDevice;

			TUint32 token;

			err = testDevice.Device().GetTokenForInterface(0,token);

			if(err != KErrNone)

				{

				RDebug::Printf("<Error %d> Unable to get token for interface 0",err);

				return TestFailed(err);

				}

			err = iInterface0.Open(token);

			if(err != KErrNone)

				{

				RDebug::Printf("<Error %d> Unable to open interface 0",err);

				return TestFailed(err);

				}

			// Send request to client to reconnect in 3 seconds

			TReconnectRequest request(3);

			iClientAction->SendRequest(request,this);

			// Monitor for the reconnection from the client

			iActorFDF->Monitor();

			TimeoutIn(30);

			}

			break;

		case EConnectCancelled:

			RDebug::Printf("<Error> Bus event cancellation not successful");

			TestFailed(KErrCorrupt);

			break;

		case EPassed:	// Test case has been successfully concluded

			{

			TUint32 token;

			err = testDevice.Device().GetTokenForInterface(0,token);

			if(err != KErrNone)

				{

				RDebug::Printf("<Error %d> Unable to get token for interface 0",err);

				return TestFailed(err);

				}

			err = iInterface0.Open(token);

			if(err != KErrNone)

				{

				RDebug::Printf("<Error %d> Unable to open interface 0",err);

				return TestFailed(err);

				}

			// Send test case passed request to client

			TTestCasePassed request;

			iClientAction->SendRequest(request,this);

			}

			break;

		default:

			RDebug::Printf("<Error> Test case actions out of sync");

			TestFailed(KErrCorrupt);

			break;

		}

	}

void CUT_PBASE_T_USBDI_0472::Ep0TransferCompleteL(TInt aCompletionCode)

	{

	LOG_FUNC

	switch(iCaseStep)

		{

		case EPassed:

			{

			TestPassed();

			}

			break;

		case EFailed:

			{

			TestFailed(KErrCompletion);

			}

			break;

		case ERemoveDevice:

			{

			// Doing nothing, client should be re-connecting

			}

			break;

		default:

			RDebug::Printf("<Error %d> Unknown test step",KErrCorrupt);

			TestFailed(KErrCorrupt);

			break;

		}

	}

void CUT_PBASE_T_USBDI_0472::DeviceRemovedL(TUint aDeviceHandle)

	{

	LOG_FUNC

	Cancel();

	switch(iCaseStep)

		{

		case ERemoveDevice:

			{

			iCaseStep = EConnectCancelled;

			// start timer now

			TimeoutIn(5);		

			}

			break;

		default:

			RDebug::Printf("<Error> Test case actions out of sync");

			TestFailed(KErrCorrupt);

			break;

		}

	}

void CUT_PBASE_T_USBDI_0472::BusErrorL(TInt aError)

	{

	// This test case handles no failiures on the bus

	TestFailed(aError);

	}

void CUT_PBASE_T_USBDI_0472::DeviceStateChangeL(RUsbDevice::TDeviceState aPreviousState,

	RUsbDevice::TDeviceState aNewState,TInt aCompletionCode)

	{

	LOG_FUNC

	}

void CUT_PBASE_T_USBDI_0472::HostRunL()

	{

	LOG_FUNC

	// Obtain the completion code

	TInt completionCode(iStatus.Int());

	if(completionCode == KErrNone)

		{		

		if(iCaseStep == EConnectCancelled)

			{

			// not a time-out 

			RDebug::Printf("Timer elapsed, reactivating notifications now");

			iCaseStep = EPassed;			

			iActorFDF->Monitor();

			}

		else

			{

			// Action timeout

			RDebug::Printf("<Error> Action timeout");

			TestFailed(KErrTimedOut);

			}	

		}

	else

		{

		RDebug::Printf("<Error %d> Timeout timer could not complete",completionCode);

		TestFailed(completionCode);

		}

	}

void CUT_PBASE_T_USBDI_0472::DeviceRunL()

	{

	LOG_FUNC

	// Disconnect the device

	iTestDevice->SoftwareDisconnect();

	// Complete the test case request

	TestPolicy().SignalTestComplete(iStatus.Int());

	}	

	}