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

// @internalComponent

// 

//

#include "PBASE-T_USBDI-0486.h"

#include "testpolicy.h"

#include "testdebug.h"

#include "modelleddevices.h"

namespace NUnitTesting_USBDI

	{

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

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

const TInt KBulkTranferId = 2;

const TInt KExpectedDataSize = 26;

CUT_PBASE_T_USBDI_0486* CUT_PBASE_T_USBDI_0486::NewL(TBool aHostRole)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;  

	} 

CUT_PBASE_T_USBDI_0486::CUT_PBASE_T_USBDI_0486(TBool aHostRole)

:	CBaseBulkTestCase(KTestCaseId,aHostRole),

	iCaseStep(EWaitForDeviceCConnection)

	{

	} 

void CUT_PBASE_T_USBDI_0486::ConstructL()

	{

	BaseBulkConstructL();

	iTestDeviceC = new RUsbDeviceC(this);  // TODO check tree for device C, once inserted

	}

CUT_PBASE_T_USBDI_0486::~CUT_PBASE_T_USBDI_0486()

	{

	LOG_FUNC

	delete iTestDeviceC;

	}

/**

Called when the device has reported any kind of error in its operation

or when the device has been informed by the host to report success

*/

void CUT_PBASE_T_USBDI_0486::DeviceRunL()

	{

	LOG_FUNC	

	// Complete the test case request	

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

	}

void CUT_PBASE_T_USBDI_0486::DeviceDoCancel()

	{

	LOG_FUNC

	iTestDeviceC->CancelSubscriptionToReports();

	}

TBool CUT_PBASE_T_USBDI_0486::CheckSN(const TDesC16& aSerialNumberGot, const TDesC& aExpectedSerialNumber)

	{

	TBool areSNsIdenticals = (aSerialNumberGot.Compare(aExpectedSerialNumber) == 0);	

	if(!areSNsIdenticals)

		{

		// Incorrect device for this test case	

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

			KErrNotFound,&aSerialNumberGot, &aExpectedSerialNumber);

		}

	return areSNsIdenticals;

	}

void CUT_PBASE_T_USBDI_0486::Ep0TransferCompleteL(TInt aCompletionCode)

	{

	LOG_FUNC

	RDebug::Printf("Ep0TransferCompleteL with aCompletionCode = %d",aCompletionCode);

	RDebug::Printf("--->Ep0TransferCompleteL, case step = %d", iCaseStep);

	switch(iCaseStep)

		{

		case EDeviceCConnected:

			{

			if(aCompletionCode != KErrNone)

				{

				RDebug::Printf("<Error %d> aCompletionCode != KErrNone",aCompletionCode);

				return TestFailed(aCompletionCode);

				}

			// close interface 0			

			iUsbInterface0.Close();			

			iCaseStep = EWaitForDeviceCDisconnection;

			}

			break; 

		case EPassed:

			TestPassed();

			break;		

		default:

			TestFailed(KErrCompletion);

			break;

		}

	}

void CUT_PBASE_T_USBDI_0486::TransferCompleteL(TInt aTransferId,TInt aCompletionCode)

	{

	LOG_FUNC

	Cancel();

	RDebug::Printf("--->TransferCompleteL, case step = %d", iCaseStep);

	if(aTransferId == KBulkTranferId)

		{							

		if(aCompletionCode != KErrCancel && aCompletionCode != KErrUsbIOError)

			{

			TBuf<256> msg;

			msg.Format(_L("<Error %d> The transfer completed with no errors but should have done so"),aCompletionCode);

			RDebug::Print(msg);

			TTestCaseFailed request(KErrCorrupt,msg);

			return iControlEp0->SendRequest(request,this);

			} 					

		}

	else

		{

		RDebug::Printf("<Error> a transfer completed (id=%d) that was not expected",aTransferId);

		return TestFailed(KErrCorrupt);

		}	

	}	

void CUT_PBASE_T_USBDI_0486::DeviceInsertedL(TUint aDeviceHandle)

	{

	LOG_FUNC

	RDebug::Printf("--->DeviceInsertedL, case step = %d", iCaseStep);

	// Cancel the timeout timer	

	Cancel();	

	TInt err(KErrNone);

	// Validate that device is as expected	

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

	// Perform the correct test step		

	switch(iCaseStep)

		{

		case EWaitForDeviceCConnection:

			{

			if(!CheckSN(testDevice.SerialNumber(), KTestDeviceC_SN()))

				{

				return TestFailed(KErrNotFound);

				}

			iCaseStep = EDeviceCConnected;

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

			if(err != KErrNone)

				{

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

				TestFailed(err);

				} 

			// Open the interface	

			err = iUsbInterface0.Open(iToken0DeviceC);

			if(err != KErrNone)

				{

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

				TestFailed(err);

				}

			TUint32 token1;

			err = testDevice.Device().GetTokenForInterface(1,token1);

			if(err != KErrNone)

				{

				TBuf<256> msg;

				msg.Format(_L("<Error %d> Token for interface 1 could not be retrieved"),err);

				RDebug::Print(msg);

				iCaseStep = EFailed;

				TTestCaseFailed request(err,msg);

				return iControlEp0->SendRequest(request,this);

				}

			err = iUsbInterface1.Open(token1); // Default interface setting 0

			if(err != KErrNone)

				{

				TBuf<256> msg;

				msg.Format(_L("<Error %d> Unable to open interface 1 using token %d"),err,token1);

				RDebug::Print(msg);

				iCaseStep = EFailed;

				TTestCaseFailed request(err,msg);

				return iControlEp0->SendRequest(request,this);

				}

			TInt endpointAddress;

			// Queue a bulk in transfer on endpoint 2	

			err = GetEndpointAddress(iUsbInterface1,0,KTransferTypeBulk,KEpDirectionIn,endpointAddress);

			if(err != KErrNone)

				{

				TBuf<256> msg;

				msg.Format(_L("<Error %d> Address for bulk in endpoint could not be obtained"),err);

				RDebug::Print(msg);

				iCaseStep = EFailed;

				TTestCaseFailed request(err,msg);

				return iControlEp0->SendRequest(request,this);

				}

			RDebug::Printf("Endpoint adress %08x",endpointAddress);

			err = iUsbInterface1.OpenPipeForEndpoint(iTestPipeInterface1BulkIn,endpointAddress,ETrue);

			if(err != KErrNone)

				{

				TBuf<256> msg;

				msg.Format(_L("<Error %d> Unable to open pipe for endpoint %08x"),err,endpointAddress);

				RDebug::Print(msg);

				iCaseStep = EFailed;

				TTestCaseFailed request(err,msg);

				return iControlEp0->SendRequest(request,this);

				}

			// Create the bulk transfers	

			iInTransfer[0] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkIn,iUsbInterface1,256,*this, KBulkTranferId);

			// Initialise the descriptors for transfer		

			RDebug::Printf("Initialising the transfer descriptors");

			err = iUsbInterface1.InitialiseTransferDescriptors();

			if(err != KErrNone)

				{

				TBuf<256> msg;

				msg.Format(_L("<Error %d> Unable to initialise transfer descriptors"),err);

				RDebug::Print(msg);

				iCaseStep = EFailed;

				TTestCaseFailed request(err,msg);

				return iControlEp0->SendRequest(request,this);

				}				

			iInTransfer[0]->TransferIn(KExpectedDataSize);

			// 	disconnect device C and connect device A								

			TDisconnectDeviceCThenConnectDeviceARequest request;

			iControlEp0->SendRequest(request,this);	

			// Monitor for the reconnection from the client		

			iActorFDF->Monitor();

			TimeoutIn(30);

			}

			break; 

		case EWaitForDeviceAConnection:

			{

			if(!CheckSN(testDevice.SerialNumber(), TestCaseId()))

				{

				return TestFailed(KErrNotFound);

			    }

			// try to open interface 0			

			err = iUsbInterface0.Open(iToken0DeviceC);

			if(err != KErrNotFound) // invalid token

				{

				RDebug::Printf("iUsbInterface0.Open(iToken0DeviceC) === %d", err);

				TestFailed(err);

				}

			// get token now 

			TUint32 token0DeviceA; 

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

			if(err != KErrNone)

				{

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

				TestFailed(err);

				} 

			// Open the interface	

			err = iUsbInterface0.Open(token0DeviceA);

			if(err != KErrNone)

				{

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

				TestFailed(err);

				}

			// ok, send EPassed request			

			iCaseStep = EPassed;

			// Send test case passed request to client

			User::After(2000000);	

			TTestCasePassed request;

			iControlEp0->SendRequest(request,this);			

			} 

			break;

		default:

			{

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

			TestFailed(KErrCorrupt);

			}	

			break;

		}	

	}

void CUT_PBASE_T_USBDI_0486::DeviceRemovedL(TUint aDeviceHandle)

	{

	LOG_FUNC

	Cancel();	

	RDebug::Printf("--->DeviceRemovedL, case step = %d", iCaseStep);

	switch(iCaseStep)

		{

		case EWaitForDeviceCDisconnection: // device C is disconnected now, interface 0 has been closed before

			{

			iCaseStep = EWaitForDeviceAConnection;

			iActorFDF->Monitor();

			}

			break;		

		default:

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

			TestFailed(KErrCorrupt);

			break;

			}

	}

void CUT_PBASE_T_USBDI_0486::HandleDeviceDConnection()

	{

	LOG_FUNC

	iTestDevice->SubscribeToReports(iStatus);

	SetActive();

	}

void CUT_PBASE_T_USBDI_0486::ExecuteDeviceTestCaseL()	

	{ 

	LOG_FUNC

	// Create the test device	

	iTestDeviceC->OpenL(KTestDeviceC_SN());

	iTestDeviceC->SubscribeToReports(iStatus);

	SetActive();

	// Connect the device to the host	

	iTestDeviceC->SoftwareConnect();

	}

RUsbDeviceC* CUT_PBASE_T_USBDI_0486::TestDeviceC()

	{

	return iTestDeviceC;

	}

RUsbDeviceD* CUT_PBASE_T_USBDI_0486::TestDeviceD()

	{

	return iTestDevice; //from CBaseBulkTestCase

	}

	}