// Copyright (c) 2003-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:

 // e32test/device/t_usbapi.cpp

 // Overview:

 // USB API Test Program (a standalone USB test program).

 // API Information:

 // Details:

 // - Query whether the platform is operating HS (or it is connected to a HS host) or not,

 // and executes the appropiate tests in each case (see RunTests() for the actual code,

 // state machine enclosed for clarity):

 // - Load and open an EUSBC device driver (logical device)

 // - Setup the USB interface: query device capabilities, setup interface.

 // - Test allocating DMA and double buffering resources with

 // AllocateEndpointResource results in their use being correctly reported by

 // QueryEndpointResourceUse

 // - Test descriptor manipulation: validate the device, configuration,

 // interface, alternate interface, endpoint and string descriptor

 // manipulation.

 // HS: device_qualifier and other_speed_configuation descriptors.

 // - Check and validate the EndpointZeroMaxPacketSizes.

 // - Quick test that calling the following APIs doesn't generate errors: device

 // control, AlternateDeviceStatusNotify, EndpointStatusNotify

 // - Test HaltEndpoint and ClearHaltEndpoint correctly result in endpoint

 // status being reported as stalled/not stalled.

 // - Test OTG extensions: OTG descriptor manipulations; set/get OTG feature

 // - Close and free the logical device.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 #include <e32debug.h>

 #include <hal.h>

 #include <d32usbc.h>

 #include <d32otgdi.h>

 #include "t_usblib.h"

 // --- Local Top Level Variables

 static RTest test(_L("T_USBAPI"));

 static RDevUsbcClient gPort;

 static RUsbOtgDriver gOTG;

 static TBool gSupportsOtg;

 static TBool gSupportsHighSpeed;

 static TBool gUsingHighSpeed;

 static TBool gSoak;

 static TChar gKeychar = 'a';

 // Store the actual endpoint number(s) of our alternate interface

 static TInt INT_IN_ep = -1;

 _LIT(KUsbLddFilename, "eusbc");

 _LIT(KOtgdiLddFilename, "otgdi");

 _LIT(KUsbDeviceName, "Usbc");

 // --- Local Constants

 static const TInt KUsbDesc_SizeOffset = 0;

 static const TInt KUsbDesc_TypeOffset = 1;

 static const TInt KDevDesc_SpecOffset = 2;

 static const TInt KDevDesc_DevClassOffset = 4;

 static const TInt KDevDesc_DevSubClassOffset = 5;

 static const TInt KDevDesc_DevProtocolOffset = 6;

 static const TInt KDevDesc_Ep0SizeOffset = 7;

 static const TInt KDevDesc_VendorIdOffset = 8;

 static const TInt KDevDesc_ProductIdOffset = 10;

 static const TInt KDevDesc_DevReleaseOffset = 12;

 static const TInt KConfDesc_AttribOffset = 7;

 static const TInt KConfDesc_MaxPowerOffset = 8;

 static const TInt KIfcDesc_SettingOffset = 2;

 static const TInt KIfcDesc_ProtocolOffset = 7;

 static const TInt KEpDesc_PacketSizeOffset = 4;

 static const TInt KEpDesc_IntervalOffset = 6;

 static const TInt KEpDesc_SynchAddressOffset = 8;

 //

 // Helper.

 //

 static TEndpointState QueryEndpointState(TEndpointNumber aEndpoint)

 	{

 	TEndpointState ep_state = EEndpointStateUnknown;

 	TInt r = gPort.EndpointStatus(aEndpoint, ep_state);

 	test(r == KErrNone);

 	test.Printf(_L("Endpoint %d state: %s\n"), aEndpoint,

 				(ep_state == EEndpointStateNotStalled) ? _S("Not stalled") :

 				((ep_state == EEndpointStateStalled) ? _S("Stalled") :

 				 _S("Unknown...")));

 	return ep_state;

 	}

 // --- Class CActiveKeypressNotifier

 class CActiveKeypressNotifier : public CActive

 	{

 public:

 	static CActiveKeypressNotifier* NewL(CConsoleBase* aConsole);

 	~CActiveKeypressNotifier();

 	void RequestCharacter();

 	void ProcessKeyPressL(TChar aChar);

 private:

 	virtual void DoCancel();

 	virtual void RunL();

 	CActiveKeypressNotifier(CConsoleBase* aConsole);

 	void ConstructL() {};

 private:

 	CConsoleBase* iConsole;

 	};

 CActiveKeypressNotifier* CActiveKeypressNotifier::NewL(CConsoleBase* aConsole)

 	{

 	CActiveKeypressNotifier* self = new (ELeave) CActiveKeypressNotifier(aConsole);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CActiveScheduler::Add(self);

 	CleanupStack::Pop();

 	return self;

 	}

 CActiveKeypressNotifier::CActiveKeypressNotifier(CConsoleBase* aConsole)

 	: CActive(EPriorityNormal), iConsole(aConsole)

 	{}

 CActiveKeypressNotifier::~CActiveKeypressNotifier()

 	{

 	Cancel();												// base class cancel -> calls our DoCancel

 	}

 void CActiveKeypressNotifier::RunL()

 	{

 	gKeychar = (static_cast<TChar>(iConsole->KeyCode()));

 	RequestCharacter();

 	}

 void CActiveKeypressNotifier::DoCancel()

 	{

 	iConsole->ReadCancel();

 	}

 void CActiveKeypressNotifier::RequestCharacter()

 	{

 	// A request is issued to the CConsoleBase to accept a character from the keyboard.

 	if (IsActive())

 		{

 		return;

 		}

 	iConsole->Read(iStatus);

 	SetActive();

 	}

 // --- Actual Test Functions

 // 2nd Thread helper function

 static TInt TestThreadFunction(TAny* aPtr)

 	{

 	RThread* other = static_cast<RThread*>(aPtr);

 	RDevUsbcClient port = gPort;

 	// Now try to duplicate the USB channel handle

 	TInt r = port.Duplicate(*other);

  	// Wait for 1 second

  	User::After(1000000);

 	return r;

 	}

 static void OpenChannel()

 	{

 	test.Start(_L("Open Channel"));

 	test.Next(_L("Load USB LDD"));

 	TInt r = User::LoadLogicalDevice(KUsbLddFilename);

 	test(r == KErrNone || r == KErrAlreadyExists);

 	RDevUsbcClient port1;

 	test.Next(_L("Open local USB channel 1"));

 	r = port1.Open(0);

 	test(r == KErrNone);

 	test.Next(_L("Open global USB channel"));

 	r = gPort.Open(0);

 	test(r == KErrNone);

 	RDevUsbcClient port2;

 	test.Next(_L("Open local USB channel 2"));

 	r = port2.Open(0);

 	test(r == KErrNone);

 	test.Next(_L("Close USB channel 1"));

 	port1.Close();

 	RDevUsbcClient port3;

 	test.Next(_L("Open local USB channel 3"));

 	r = port3.Open(0);

 	test(r == KErrNone);

 	test.Next(_L("Close USB channel 2"));

 	port2.Close();

 	test.Next(_L("Close USB channel 3"));

 	port3.Close();

 	// Check for OTG support

 	TBuf8<KUsbDescSize_Otg> otg_desc;

 	r = gPort.GetOtgDescriptor(otg_desc);

 	test(r == KErrNotSupported || r == KErrNone);

 	gSupportsOtg = (r != KErrNotSupported) ? ETrue : EFalse;

 	// On an OTG device we have to start the OTG driver, otherwise the Client

 	// stack will remain disabled forever.

 	if (gSupportsOtg)

 		{

 		test.Printf(_L("Running on OTG device: loading OTG driver\n"));

 		test.Next(_L("Load OTG LDD"));

 		r = User::LoadLogicalDevice(KOtgdiLddFilename);

 		test((r == KErrNone) || (r == KErrAlreadyExists));

 		test.Next(_L("Open OTG channel"));

 		r = gOTG.Open();

 		test(r == KErrNone);

 		test.Next(_L("Start OTG stack"));

 		r = gOTG.StartStacks();

 		test(r == KErrNone);

 		}

 	// Try duplicating channel handle in a second thread

 	// (which should not work because we don't support it)

 	test.Next(_L("Create 2nd Thread"));

 	RThread me;

  	TThreadId me_id = me.Id();

 	// We need to open the RThread object, otherwise we'll only get the

 	// 'special' handle 0xFFFF8001.

 	test(me.Open(me_id) == KErrNone);

 	RThread test_thread;

 	TBuf<17> name = _L("tusbapitestthread");

 	test(test_thread.Create(name, TestThreadFunction, 0x1000, NULL, &me) == KErrNone);

 	test.Next(_L("Logon to 2nd Thread"));

 	TRequestStatus stat;

 	test_thread.Logon(stat);

 	test(stat == KRequestPending);

 	test_thread.Resume();

 	test.Next(_L("Wait for 2nd Thread to exit"));

 	User::WaitForRequest(stat);

 	// Check correct return value of RDevUsbcClient::Duplicate()

 	test(stat == KErrAccessDenied);

 	test.Next(_L("Close 2nd Thread"));

 	test_thread.Close();

 	test.End();

 	}

 static void TestResourceAllocation()

 	{

 	test.Start(_L("Test Endpoint Resource Allocation"));

 	test.Next(_L("Request DMA resource"));

 	const TInt dma = gPort.AllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDMA);

 	TBool res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDMA);

 	test.Printf(_L("DMA on endpoint 1 %s\n"),

 				res ? _S("now allocated") : _S("not allocated"));

 	if (dma == KErrNone)

 		// Only if DMA resource was successfully allocated should we expect truth here:

 		test(res);

 	else

 		test(!res);

 	test.Next(_L("Request Double Buffering resource"));

 	const TInt db = gPort.AllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

 	res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

 	test.Printf(_L("Double Buffering on endpoint 1 %s\n"),

 				res ? _S("now allocated") : _S("not allocated"));

 	if (db == KErrNone)

 		// Only if DB resource was successfully allocated should we expect truth here:

 		test(res);

 	else

 		test(!res);

 	test.Next(_L("Deallocate Double Buffering resource"));

 	TInt r = gPort.DeAllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

 	// Whether DB is dynamic or permanent - deallocation (if supported) should always return success:

 	if (db == KErrNone)

 		test(r == KErrNone);

 	else

 		test(r != KErrNone);

 	res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

 	test.Printf(_L("Double Buffering on endpoint 1 %s\n"),

 				res ? _S("still allocated") : _S("not (longer) allocated"));

 	test.Next(_L("Deallocate DMA resource"));

 	r = gPort.DeAllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDMA);

 	// Whether DMA is dynamic or permanent - deallocation (if supported) should always return success:

 	if (dma == KErrNone)

 		test(r == KErrNone);

 	else

 		test(r != KErrNone);

 	res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDMA);

 	test.Printf(_L("DMA on endpoint 1 %s\n"),

 				res ? _S("still allocated") : _S("not (longer) allocated"));

 	test.End();

 	}

 static void SetupInterface()

 	{

 	test.Start(_L("Query USB device caps and set up interface"));

 	// Device caps

 	test.Next(_L("Query USB device caps"));

 	TUsbDeviceCaps d_caps;

 	TInt r = gPort.DeviceCaps(d_caps);

 	test(r == KErrNone);

 	TInt n = d_caps().iTotalEndpoints;

 	// Global variable - we'll need this value later

 	gSupportsHighSpeed = d_caps().iHighSpeed;

 	test.Printf(_L("### USB device capabilities:\n"));

 	test.Printf(_L("Number of endpoints:                        %d\n"), n);

 	test.Printf(_L("Supports Software-Connect:                  %s\n"),

 				d_caps().iConnect ? _S("yes") : _S("no"));

 	test.Printf(_L("Device is Self-Powered:                     %s\n"),

 				d_caps().iSelfPowered ? _S("yes") : _S("no"));

 	test.Printf(_L("Supports Remote-Wakeup:                     %s\n"),

 				d_caps().iRemoteWakeup ? _S("yes") : _S("no"));

 	test.Printf(_L("Supports High-speed:                        %s\n"),

 				gSupportsHighSpeed ? _S("yes") : _S("no"));

 	test.Printf(_L("Supports OTG:                               %s\n"),

 				gSupportsOtg ? _S("yes") : _S("no"));

 	test.Printf(_L("Supports unpowered cable detection:         %s\n"),

 				(d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_CableDetectWithoutPower) ?

 				_S("yes") : _S("no"));

 	test.Printf(_L("Supports endpoint resource alloc scheme V2: %s\n"),

 				(d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) ?

 				_S("yes") : _S("no"));

 	test(n >= 2);

 	test.Printf(_L("(Device has sufficient endpoints.)\n"));

 	// Endpoint caps

 	test.Next(_L("Query USB endpoint caps"));

 	TUsbcEndpointData data[KUsbcMaxEndpoints];

 	TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));

 	r = gPort.EndpointCaps(dataptr);

 	test(r == KErrNone);

 	test.Printf(_L("### USB device endpoint capabilities:\n"));

 	for (TInt i = 0; i < n; i++)

 		{

 		const TUsbcEndpointCaps* caps = &data[i].iCaps;

 		test.Printf(_L("Endpoint: SizeMask = 0x%08x TypeDirMask = 0x%08x\n"),

 					caps->iSizes, caps->iTypesAndDir);

 		if (caps->iHighBandwidth)

 			{

 			test.Printf(_L("  (high-speed, high bandwidth endpoint)\n"));

 			// Must be HS Int or Iso ep

 			test(gSupportsHighSpeed);

 			test(caps->iTypesAndDir & (KUsbEpTypeIsochronous | KUsbEpTypeInterrupt));

 			}

 		}

 	test.Next(_L("Looking for suitable endpoints"));

 	// Set the active interface

 	TUsbcInterfaceInfoBuf ifc;

 	TInt ep_found = 0;

 	TBool foundBulkIN = EFalse;

 	TBool foundBulkOUT = EFalse;

 	for (TInt i = 0; i < n; i++)

 		{

 		const TUsbcEndpointCaps* caps = &data[i].iCaps;

 		const TInt mps = caps->MaxPacketSize();

 		if (!foundBulkIN &&

 			(caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirIn)) ==

 			(KUsbEpTypeBulk | KUsbEpDirIn))

 			{

 			// EEndpoint1 is going to be our TX (IN, write) endpoint

 			ifc().iEndpointData[0].iType = KUsbEpTypeBulk;

 			ifc().iEndpointData[0].iDir  = KUsbEpDirIn;

 			ifc().iEndpointData[0].iSize = mps;

 			foundBulkIN = ETrue;

 			if (++ep_found == 2)

 				break;

 			}

 		else if (!foundBulkOUT &&

 			(caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirOut)) ==

 				 (KUsbEpTypeBulk | KUsbEpDirOut))

 			{

 			// EEndpoint2 is going to be our RX (OUT, read) endpoint

 			ifc().iEndpointData[1].iType = KUsbEpTypeBulk;

 			ifc().iEndpointData[1].iDir  = KUsbEpDirOut;

 			ifc().iEndpointData[1].iSize = mps;

 			foundBulkOUT = ETrue;

 			if (++ep_found == 2)

 				break;

 			}

 		}

 	test(ep_found == 2);

 	test.Next(_L("Setting up main interface"));

 	_LIT16(string, "T_USBAPI Test Interface (Setting 0)");

 	ifc().iString = const_cast<TDesC16*>(&string);

 	ifc().iTotalEndpointsUsed = 2;

 	ifc().iClass.iClassNum	  = 0xff;

 	ifc().iClass.iSubClassNum = 0xff;

 	ifc().iClass.iProtocolNum = 0xff;

 	// Set up the interface.

 	r = gPort.SetInterface(0, ifc);

 	test(r == KErrNone);

 	TInt ifc_no = -1;

 	r = gPort.GetAlternateSetting(ifc_no);

 	test(r == KErrUsbDeviceNotConfigured);

 	// Some UDCs won't allow endpoint resource manipulation once the hardware has been

 	// configured and turned on. So we do it here & now:

 	TestResourceAllocation();

 	// On the other hand, since some UDCs won't let us test many features which require

 	// register access until the USB hardware is powered up (and because it might start

 	// out unpowered), we should turn it on here explicitly.

 	// (It will be turned off automatically by the PIL after all tests have been run,

 	// when the interface gets deleted.)

 	test.Next(_L("Powering up UDC (1)"));

 	r = gPort.PowerUpUdc();

 	if (!gSupportsOtg)

 		{

 		test(r == KErrNone);

 		}

 	else

 		{

 		test((r == KErrNone) || (r == KErrNotReady));

 		}

 	if (gSupportsOtg && (r == KErrNotReady))

 		{

 		test.Printf(_L("OTG device but not connected to Host, stopping subtest here.\n"));

 		test.End();

 		return;

 		}

 	// The board might be attached to a PC with HS controller, thus enabling us

 	// to test some HS-specific features. For that to work we have to connect

 	// the board to the PC. The "Found new device" box that may pop up on the PC

 	// in response to this can be ignored (i.e. just closed).

 	test.Next(_L("Connecting to Host (1)"));

 	r = gPort.DeviceConnectToHost();

 	test(r == KErrNone);

  	// Suspend thread to let things get stable on the bus.

 	test.Printf(_L("Waiting a short moment..."));

 	User::After(2000000);

 	test.Printf(_L(" done.\n"));

 	// Check the speed of the physical connection (if any).

 	gUsingHighSpeed = gPort.CurrentlyUsingHighSpeed();

 	if (gUsingHighSpeed)

 		{

 		test(gSupportsHighSpeed);							// sane?

 		test.Printf(_L("---> USB High-speed Testing\n"));

 		}

 	else

 		{

 		test.Printf(_L("---> USB Full-speed Testing\n"));

 		}

 	// By pulling down the interface/connection and bringing them up again we

 	// simulate a starting/stopping of the USB service by a control app.

 	test.Next(_L("Disconnecting from Host"));

 	r = gPort.DeviceDisconnectFromHost();

 	test(r == KErrNone);

 	test.Next(_L("Releasing interface"));

 	r = gPort.ReleaseInterface(0);

 	test(r == KErrNone);

 	test.Next(_L("Setting interface"));

 	r = gPort.SetInterface(0, ifc);

 	test(r == KErrNone);

  	// Suspend thread before connecting again.

 	test.Printf(_L("Waiting a short moment..."));

 	User::After(1000000);

 	test.Printf(_L(" done.\n"));

 	test.Next(_L("Powering up UDC (2)"));

 	r = gPort.PowerUpUdc();

 	if (!gSupportsOtg)

 		{

 		test(r == KErrNone);

 		}

 	else

 		{

 		test((r == KErrNone) || (r == KErrNotReady));

 		}

 	if (gSupportsOtg && (r == KErrNotReady))

 		{

 		test.Printf(_L("OTG device but not connected to Host, stopping subtest here.\n"));

 		test.End();

 		return;

 		}

 	test.Next(_L("Connecting to Host (2)"));

 	r = gPort.DeviceConnectToHost();

 	test(r == KErrNone);

 	// Suspend thread to let things get stable on the bus.

 	User::After(2000000);

 	test.End();

 	}

 static void TestDeviceDescriptor()

 	{

 	test.Start(_L("Device Descriptor Manipulation"));

 	test.Next(_L("GetDeviceDescriptorSize()"));

 	TInt desc_size = 0;

 	gPort.GetDeviceDescriptorSize(desc_size);

 	test(static_cast<TUint>(desc_size) == KUsbDescSize_Device);

 	test.Next(_L("GetDeviceDescriptor()"));

 	TBuf8<KUsbDescSize_Device> descriptor;

 	TInt r = gPort.GetDeviceDescriptor(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("SetDeviceDescriptor()"));

 	// Change the USB spec number to 2.30

 	descriptor[KDevDesc_SpecOffset]   = 0x30;

 	descriptor[KDevDesc_SpecOffset+1] = 0x02;

 	// Change the device vendor ID (VID) to 0x1234

 	descriptor[KDevDesc_VendorIdOffset]   = 0x34;			// little endian

 	descriptor[KDevDesc_VendorIdOffset+1] = 0x12;

 	// Change the device product ID (PID) to 0x1111

 	descriptor[KDevDesc_ProductIdOffset]   = 0x11;

 	descriptor[KDevDesc_ProductIdOffset+1] = 0x11;

 	// Change the device release number to 3.05

 	descriptor[KDevDesc_DevReleaseOffset]   = 0x05;

 	descriptor[KDevDesc_DevReleaseOffset+1] = 0x03;

 	r = gPort.SetDeviceDescriptor(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetDeviceDescriptor()"));

 	TBuf8<KUsbDescSize_Device> descriptor2;

 	r = gPort.GetDeviceDescriptor(descriptor2);

 	test(r == KErrNone);

 	test.Next(_L("Compare device descriptor with value set"));

 	r = descriptor2.Compare(descriptor);

 	test(r == KErrNone);

 	if (gUsingHighSpeed)

 		{

 		// HS only allows one possible packet size.

 		test(descriptor[KDevDesc_Ep0SizeOffset] == 64);

 		}

 	test.End();

 	}

 static void	TestDeviceQualifierDescriptor()

 	{

 	test.Start(_L("Device_Qualifier Descriptor Manipulation"));

 	if (!gSupportsHighSpeed)

 		{

 		test.Printf(_L("*** Not supported - skipping Device_Qualifier descriptor tests\n"));

 		test.End();

 		return;

 		}

 	test.Next(_L("GetDeviceQualifierDescriptor()"));

 	TBuf8<KUsbDescSize_DeviceQualifier> descriptor;

 	TInt r = gPort.GetDeviceQualifierDescriptor(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("SetDeviceQualifierDescriptor()"));

 	// Change the USB spec number to 3.00

 	descriptor[KDevDesc_SpecOffset]   = 0x00;

 	descriptor[KDevDesc_SpecOffset+1] = 0x03;

 	// Change the device class, subclass and protocol codes

 	descriptor[KDevDesc_DevClassOffset]    = 0xA1;

 	descriptor[KDevDesc_DevSubClassOffset] = 0xB2;

 	descriptor[KDevDesc_DevProtocolOffset] = 0xC3;

 	r = gPort.SetDeviceQualifierDescriptor(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetDeviceQualifierDescriptor()"));

 	TBuf8<KUsbDescSize_DeviceQualifier> descriptor2;

 	r = gPort.GetDeviceQualifierDescriptor(descriptor2);

 	test(r == KErrNone);

 	test.Next(_L("Compare Device_Qualifier desc with value set"));

 	r = descriptor2.Compare(descriptor);

 	test(r == 0);

 	if (!gUsingHighSpeed)

 		{

 		// HS only allows one possible packet size.

 		test(descriptor[KDevDesc_Ep0SizeOffset] == 64);

 		}

 	test.End();

 	}

 static void TestConfigurationDescriptor()

 	{

 	test.Start(_L("Configuration Descriptor Manipulation"));

 	test.Next(_L("GetConfigurationDescriptorSize()"));

 	TInt desc_size = 0;

 	gPort.GetConfigurationDescriptorSize(desc_size);

 	test(static_cast<TUint>(desc_size) == KUsbDescSize_Config);

 	test.Next(_L("GetConfigurationDescriptor()"));

 	TBuf8<KUsbDescSize_Config> descriptor;

 	TInt r = gPort.GetConfigurationDescriptor(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("SetConfigurationDescriptor()"));

 	// Invert Remote-Wakup support

 	descriptor[KConfDesc_AttribOffset] = (descriptor[KConfDesc_AttribOffset] ^ KUsbDevAttr_RemoteWakeup);

 	// Change the reported max power to 200mA (2 * 0x64)

 	descriptor[KConfDesc_MaxPowerOffset] = 0x64;

 	r = gPort.SetConfigurationDescriptor(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetConfigurationDescriptor()"));

 	TBuf8<KUsbDescSize_Config> descriptor2;

 	r = gPort.GetConfigurationDescriptor(descriptor2);

 	test(r == KErrNone);

 	test.Next(_L("Compare configuration desc with value set"));

 	r = descriptor2.Compare(descriptor);

 	test(r == KErrNone);

 	test.End();

 	}

 static void	TestOtherSpeedConfigurationDescriptor()

 	{

 	test.Start(_L("Other_Speed_Configuration Desc Manipulation"));

 	if (!gSupportsHighSpeed)

 		{

 		test.Printf(_L("*** Not supported - skipping Other_Speed_Configuration desc tests\n"));

 		test.End();

 		return;

 		}

 	test.Next(_L("GetOtherSpeedConfigurationDescriptor()"));

 	TBuf8<KUsbDescSize_OtherSpeedConfig> descriptor;

 	TInt r = gPort.GetOtherSpeedConfigurationDescriptor(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("SetOtherSpeedConfigurationDescriptor()"));

 	// Invert Remote-Wakup support

 	descriptor[KConfDesc_AttribOffset] = (descriptor[KConfDesc_AttribOffset] ^ KUsbDevAttr_RemoteWakeup);

 	// Change the reported max power to 330mA (2 * 0xA5)

 	descriptor[KConfDesc_MaxPowerOffset] = 0xA5;

 	r = gPort.SetOtherSpeedConfigurationDescriptor(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetOtherSpeedConfigurationDescriptor()"));

 	TBuf8<KUsbDescSize_OtherSpeedConfig> descriptor2;

 	r = gPort.GetOtherSpeedConfigurationDescriptor(descriptor2);

 	test(r == KErrNone);

 	test.Next(_L("Compare O_S_Config desc with value set"));

 	r = descriptor2.Compare(descriptor);

 	test(r == KErrNone);

 	test.End();

 	}

 static void TestInterfaceDescriptor()

 	{

 	test.Start(_L("Interface Descriptor Manipulation"));

 	// First the standard Interface descriptor

 	test.Next(_L("GetInterfaceDescriptorSize()"));

 	TInt desc_size = 0;

 	TInt r = gPort.GetInterfaceDescriptorSize(0, desc_size);

 	test(r == KErrNone);

 	test(static_cast<TUint>(desc_size) == KUsbDescSize_Interface);

 	test.Next(_L("GetInterfaceDescriptor()"));

 	TBuf8<KUsbDescSize_Interface> descriptor;

 	r = gPort.GetInterfaceDescriptor(0, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("SetInterfaceDescriptor()"));

 	// Change the interface protocol to 0x78(+)

 	TUint8 prot = 0x78;

 	if (descriptor[KIfcDesc_ProtocolOffset] == prot)

 		prot++;

 	descriptor[KIfcDesc_ProtocolOffset] = prot;

 	r = gPort.SetInterfaceDescriptor(0, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetInterfaceDescriptor()"));

 	TBuf8<KUsbDescSize_Interface> descriptor2;

 	r = gPort.GetInterfaceDescriptor(0, descriptor2);

 	test(r == KErrNone);

 	test.Next(_L("Compare interface descriptor with value set"));

 	r = descriptor2.Compare(descriptor);

 	test(r == KErrNone);

 	test.End();

 	}

 static void TestClassSpecificDescriptors()

 	{

 	test.Start(_L("Class-specific Descriptor Manipulation"));

 	// First a class-specific Interface descriptor

 	test.Next(_L("SetCSInterfaceDescriptorBlock()"));

 	// choose arbitrary new descriptor size

 	const TInt KUsbDescSize_CS_Interface = KUsbDescSize_Interface + 10;

 	TBuf8<KUsbDescSize_CS_Interface> cs_ifc_descriptor;

 	cs_ifc_descriptor.FillZ(cs_ifc_descriptor.MaxLength());

 	cs_ifc_descriptor[KUsbDesc_SizeOffset] = KUsbDescSize_CS_Interface;

 	cs_ifc_descriptor[KUsbDesc_TypeOffset] = KUsbDescType_CS_Interface;

 	TInt r = gPort.SetCSInterfaceDescriptorBlock(0, cs_ifc_descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetCSInterfaceDescriptorBlockSize()"));

 	TInt desc_size = 0;

 	r = gPort.GetCSInterfaceDescriptorBlockSize(0, desc_size);

 	test(r == KErrNone);

 	test(desc_size == KUsbDescSize_CS_Interface);

 	test.Next(_L("GetCSInterfaceDescriptorBlock()"));

 	TBuf8<KUsbDescSize_CS_Interface> descriptor;

 	r = gPort.GetCSInterfaceDescriptorBlock(0, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("Compare CS ifc descriptor with value set"));

 	r = descriptor.Compare(cs_ifc_descriptor);

 	test(r == KErrNone);

 	// Next a class-specific Endpoint descriptor

 	test.Next(_L("SetCSEndpointDescriptorBlock()"));

 	// choose arbitrary new descriptor size

 	const TInt KUsbDescSize_CS_Endpoint = KUsbDescSize_Endpoint + 5;

 	TBuf8<KUsbDescSize_CS_Endpoint> cs_ep_descriptor;

 	cs_ep_descriptor.FillZ(cs_ep_descriptor.MaxLength());

 	cs_ep_descriptor[KUsbDesc_SizeOffset] = KUsbDescSize_CS_Endpoint;

 	cs_ep_descriptor[KUsbDesc_TypeOffset] = KUsbDescType_CS_Endpoint;

 	r = gPort.SetCSEndpointDescriptorBlock(0, 2, cs_ep_descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetCSEndpointDescriptorBlockSize()"));

 	r = gPort.GetCSEndpointDescriptorBlockSize(0, 2, desc_size);

 	test(r == KErrNone);

 	test(desc_size == KUsbDescSize_CS_Endpoint);

 	test.Next(_L("GetCSEndpointDescriptorBlock()"));

 	TBuf8<KUsbDescSize_CS_Endpoint> descriptor2;

 	r = gPort.GetCSEndpointDescriptorBlock(0, 2, descriptor2);

 	test(r == KErrNone);

 	test.Next(_L("Compare CS ep descriptor with value set"));

 	r = descriptor2.Compare(cs_ep_descriptor);

 	test(r == KErrNone);

 	test.End();

 	}

 static void TestAlternateInterfaceManipulation()

 	{

 	test.Start(_L("Alternate Interface Setting Manipulation"));

 	if (!SupportsAlternateInterfaces())

 		{

 		test.Printf(_L("*** Not supported - skipping alternate interface settings tests\n"));

 		test.End();

 		return;

 		}

 	// Fetch endpoint data (again)

 	test.Next(_L("Get endpoint capabilities"));

 	TUsbDeviceCaps d_caps;

 	TInt r = gPort.DeviceCaps(d_caps);

 	test(r == KErrNone);

 	const TInt n = d_caps().iTotalEndpoints;

 	TUsbcEndpointData data[KUsbcMaxEndpoints];

 	TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));

 	r = gPort.EndpointCaps(dataptr);

 	test(r == KErrNone);

 	// Find ep's for alternate ifc setting

 	test.Next(_L("Find suitable endpoints"));

 	TInt ep_found = 0;

 	TBool foundIsoIN  = EFalse;

 	TBool foundIsoOUT = EFalse;

 	TBool foundIntIN  = EFalse;

 	TUsbcInterfaceInfoBuf ifc;

 	// NB! We cannot assume that any specific device has any given set of

 	// capabilities, so whilst we try and set an assortment of endpoint types

 	// we may not get what we want.

 	// Also, note that the endpoint[] array in the interface descriptor

 	// must be filled from ep[0]...ep[n-1].

 	for (TInt i = 0; i < n; i++)

 		{

 		const TUsbcEndpointCaps* const caps = &data[i].iCaps;

 		const TInt mps = caps->MaxPacketSize();

 		if (!foundIsoIN &&

 			(caps->iTypesAndDir & (KUsbEpTypeIsochronous | KUsbEpDirIn)) ==

 			(KUsbEpTypeIsochronous | KUsbEpDirIn))

 			{

 			// This is going to be our Iso TX (IN) endpoint

 			ifc().iEndpointData[ep_found].iType = KUsbEpTypeIsochronous;

 			ifc().iEndpointData[ep_found].iDir  = KUsbEpDirIn;

 			ifc().iEndpointData[ep_found].iSize = mps;

 			ifc().iEndpointData[ep_found].iInterval = 0x01;	// 2^(bInterval-1)ms, bInterval must be [1..16]

 			ifc().iEndpointData[ep_found].iInterval_Hs = 0x01; // same as for FS

 			test.Printf(_L("ISO  IN  size = %4d (ep %d)\n"), mps, ep_found + 1);

 			foundIsoIN = ETrue;

 			if (++ep_found == 3)

 				break;

 			}

 		else if (!foundIsoOUT &&

 				 (caps->iTypesAndDir & (KUsbEpTypeIsochronous | KUsbEpDirOut)) ==

 				 (KUsbEpTypeIsochronous | KUsbEpDirOut))

 			{

 			// This is going to be our Iso RX (OUT) endpoint

 			ifc().iEndpointData[ep_found].iType = KUsbEpTypeIsochronous;

 			ifc().iEndpointData[ep_found].iDir  = KUsbEpDirOut;

 			ifc().iEndpointData[ep_found].iSize = mps;

 			ifc().iEndpointData[ep_found].iInterval = 0x01;	// 2^(bInterval-1)ms, bInterval must be [1..16]

 			test.Printf(_L("ISO  OUT size = %4d (ep %d)\n"), mps, ep_found + 1);

 			foundIsoOUT = ETrue;

 			if (++ep_found == 3)

 				break;

 			}

 		else if (!foundIntIN &&

 				 (caps->iTypesAndDir & (KUsbEpTypeInterrupt | KUsbEpDirIn)) ==

 				 (KUsbEpTypeInterrupt | KUsbEpDirIn))

 			{

 			// This is going to be our Interrupt TX (IN) endpoint

 			ifc().iEndpointData[ep_found].iType  = KUsbEpTypeInterrupt;

 			ifc().iEndpointData[ep_found].iDir   = KUsbEpDirIn;

 			ifc().iEndpointData[ep_found].iSize  = mps;

 			ifc().iEndpointData[ep_found].iInterval = 10;	// interval = 10ms, valid range [1..255]

 			ifc().iEndpointData[ep_found].iInterval_Hs = 4;	// interval = 2^(bInterval-1)ms = 8ms

 			ifc().iEndpointData[ep_found].iExtra    = 2;	// 2 extra bytes for Audio Class EP descriptor

 			test.Printf(_L("INT  IN  size = %4d (ep %d)\n"), mps, ep_found + 1);

 			foundIntIN = ETrue;

 			INT_IN_ep = ep_found + 1;

 			if (++ep_found == 3)

 				break;

 			}

 		}

 	// Let's try to add some more Bulk endpoints up to the max # of 5.

 	for (TInt i = 0; i < n; i++)

 		{

 		TUsbcEndpointCaps& caps = data[i].iCaps;

 		const TUint mps = caps.MaxPacketSize();

 		if (caps.iTypesAndDir & KUsbEpTypeBulk)

 			{

 			const TUint dir = (caps.iTypesAndDir & KUsbEpDirIn) ? KUsbEpDirIn : KUsbEpDirOut;

 			ifc().iEndpointData[ep_found].iType = KUsbEpTypeBulk;

 			ifc().iEndpointData[ep_found].iDir = dir;

 			if (gUsingHighSpeed)

 				{

 				test.Printf(_L("Checking if correct Bulk packet size is reported in HS case\n"));

 				test(mps == KUsbEpSize512);					// sane?

 				}

 			// The PSL should in any case also offer the 'legacy' FS size:

 			test(caps.iSizes & KUsbEpSize64);

 			ifc().iEndpointData[ep_found].iSize = mps;

 			test.Printf(_L("BULK %s size = %4d (ep %d)\n"),

 						dir == KUsbEpDirIn ? _S("IN ") : _S("OUT"), mps, ep_found + 1);

 			if (++ep_found == 5)

 				break;

 			}

 		}

 	test.Printf(_L("Total: %d endpoints found for the alt. ifc setting\n"), ep_found);

 	if (ep_found < 3)

 		{

 		test.Printf(_L("(3 endpoints are at least required. Skipping test...)\n"));

 		test.End();

 		return;

 		}

 	if (!foundIsoIN && !foundIsoOUT)

 		{

 		test.Printf(_L("(No Isochronous endpoints found)\n"));

 		}

 	if (!foundIntIN)

 		{

 		test.Printf(_L("(No Interrupt endpoint found)\n"));

 		test.Printf(_L("Adjusting endpoint size for later test\n"));

 		// We want to make sure that at least one descriptor has the 2 extra bytes.

 		// It doesn't matter that this ep could be a Bulk one, or that the 2 Iso ep's might be missing -

 		// we just want to test some functionality and we're not going to use this interface in earnest.

 		ifc().iEndpointData[2].iExtra = 2;					// 2 extra bytes for Audio Class Ep descriptor

 		INT_IN_ep = 3;										// pretend it's an INT ep

 		}

 	test.Next(_L("Create alternate interface setting"));

 	_LIT16(string, "T_USBAPI Test Interface (Setting 1: Audio)");

 	ifc().iString = const_cast<TDesC16*>(&string);

 	ifc().iTotalEndpointsUsed = ep_found;

 	ifc().iClass.iClassNum	  = KUsbAudioInterfaceClassCode;

 	ifc().iClass.iSubClassNum = KUsbAudioInterfaceSubclassCode_Audiostreaming;

 	ifc().iClass.iProtocolNum = KUsbAudioInterfaceProtocolCode_Pr_Protocol_Undefined;

 	r = gPort.SetInterface(1, ifc);

 	test(r == KErrNone);

 	test.Next(_L("Set alternate setting number to 8"));

 	TBuf8<KUsbDescSize_Interface> descriptor;

 	r = gPort.GetInterfaceDescriptor(1, descriptor);

 	test(r == KErrNone);

 	descriptor[KIfcDesc_SettingOffset] = 8;

 	r = gPort.SetInterfaceDescriptor(1, descriptor);

 	test(r != KErrNone);

 	test.Next(_L("Change ifc # in def setting whith alt ifcs"));

 	r = gPort.GetInterfaceDescriptor(0, descriptor);

 	test(r == KErrNone);

 	descriptor[KIfcDesc_SettingOffset] = 8;

 	r = gPort.SetInterfaceDescriptor(0, descriptor);

 	test(r != KErrNone);

 	test.Next(_L("Change the ifc # in default setting to 8"));

 	r = gPort.ReleaseInterface(1);

 	test(r == KErrNone);

 	r = gPort.SetInterfaceDescriptor(0, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("Create new setting - this should also get #8"));

 	r = gPort.SetInterface(1, ifc);

 	test(r == KErrNone);

 	r = gPort.GetInterfaceDescriptor(1, descriptor);

 	test(r == KErrNone);

 	test(descriptor[KIfcDesc_SettingOffset] == 8);

 	test.Next(_L("Change the ifc # in default setting to 0"));

 	r = gPort.ReleaseInterface(1);

 	test(r == KErrNone);

 	r = gPort.GetInterfaceDescriptor(0, descriptor);

 	test(r == KErrNone);

 	descriptor[KIfcDesc_SettingOffset] = 0;

 	r = gPort.SetInterfaceDescriptor(0, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("Create new setting - this should also get #0"));

 	r = gPort.SetInterface(1, ifc);

 	test(r == KErrNone);

 	r = gPort.GetInterfaceDescriptor(1, descriptor);

 	test(r == KErrNone);

 	test(descriptor[KIfcDesc_SettingOffset] == 0);

 	test.End();

 	}

 static void TestEndpointDescriptor()

 	{

 	test.Start(_L("Endpoint Descriptor Manipulation"));

 	test.Next(_L("GetEndpointDescriptorSize(1)"));

 	TInt epNumber = 1;

 	TInt desc_size = 0;

 	TInt r = gPort.GetEndpointDescriptorSize(0, epNumber, desc_size);

 	test(r == KErrNone);

 	test(static_cast<TUint>(desc_size) == KUsbDescSize_Endpoint);

 	test.Next(_L("GetEndpointDescriptor(1)"));

 	TBuf8<KUsbDescSize_Endpoint> descriptor;

 	r = gPort.GetEndpointDescriptor(0, epNumber, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("SetEndpointDescriptor(1)"));

 	// Change the endpoint poll interval

 	TUint8 ival = 0x66;

 	if (descriptor[KEpDesc_IntervalOffset] == ival)

 		ival++;

 	descriptor[KEpDesc_IntervalOffset] = ival;

 	r = gPort.SetEndpointDescriptor(0, epNumber, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetEndpointDescriptor(1)"));

 	TBuf8<KUsbDescSize_Endpoint> descriptor2;

 	r = gPort.GetEndpointDescriptor(0, epNumber, descriptor2);

 	test(r == KErrNone);

 	test.Next(_L("Compare endpoint descriptor with value set"));

 	r = descriptor2.Compare(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("Check endpoint max packet size"));

 	const TUint16 ep_size = EpSize(descriptor[KEpDesc_PacketSizeOffset],

 								   descriptor[KEpDesc_PacketSizeOffset+1]);

 	test.Printf(_L(" Size: %d\n"), ep_size);

 	if (gUsingHighSpeed)

 		{

 		// HS Bulk ep can only have one possible packet size.

 		test(ep_size == 512);

 		}

 	else

 		{

 		// FS Bulk ep cannot be larger than 64 bytes.

 		test(ep_size <= 64);

 		}

 	test.End();

 	}

 static void TestExtendedEndpointDescriptor()

 	{

 	test.Start(_L("Extended Endpoint Descriptor Manipulation"));

 	if (!SupportsAlternateInterfaces())

 		{

 		test.Printf(_L("*** Not supported - skipping Extended Endpoint descriptor tests\n"));

 		test.End();

 		return;

 		}

 	// Extended Endpoint Descriptor manipulation (Audio class endpoint)

 	test.Next(_L("GetEndpointDescriptorSize()"));

 	TInt epNumber = INT_IN_ep;

 	TInt desc_size = 0;

 	TInt r = gPort.GetEndpointDescriptorSize(1, epNumber, desc_size);

 	test(r == KErrNone);

 	test(static_cast<TUint>(desc_size) == KUsbDescSize_AudioEndpoint);

 	test.Next(_L("GetEndpointDescriptor()"));

 	TBuf8<KUsbDescSize_AudioEndpoint> descriptor;

 	r = gPort.GetEndpointDescriptor(1, epNumber, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("SetEndpointDescriptor()"));

 	// Change the Audio Endpoint bSynchAddress field

 	TUint8 addr = 0x85;										// bogus address

 	if (descriptor[KEpDesc_SynchAddressOffset] == addr)

 		addr++;

 	descriptor[KEpDesc_SynchAddressOffset] = addr;

 	r = gPort.SetEndpointDescriptor(1, epNumber, descriptor);

 	test(r == KErrNone);

 	test.Next(_L("GetEndpointDescriptor()"));

 	TBuf8<KUsbDescSize_AudioEndpoint> descriptor2;

 	r = gPort.GetEndpointDescriptor(1, epNumber, descriptor2);

 	test(r == KErrNone);

 	test.Next(_L("Compare endpoint descriptor with value set"));

 	r = descriptor2.Compare(descriptor);

 	test(r == KErrNone);

 	test.Next(_L("Check endpoint max packet size"));

 	const TUint16 ep_size = EpSize(descriptor[KEpDesc_PacketSizeOffset],

 								   descriptor[KEpDesc_PacketSizeOffset+1]);

 	if (gUsingHighSpeed)

 		{

 		// HS Interrupt ep.

 		test(ep_size <= 1024);

 		}

 	else

 		{

 		// FS Interrupt ep cannot be larger than 64 bytes.

 		test(ep_size <= 64);

 		}

 	test.End();

 	}

 static void TestStandardStringDescriptors()

 	{

 	test.Start(_L("String Descriptor Manipulation"));

 	//

 	// --- LANGID code

 	//

 	test.Next(_L("GetStringDescriptorLangId()"));

 	TUint16 rd_langid_orig;

 	TInt r = gPort.GetStringDescriptorLangId(rd_langid_orig);

 	test(r == KErrNone);

 	test.Printf(_L("Original LANGID code: 0x%04X\n"), rd_langid_orig);

 	test.Next(_L("SetStringDescriptorLangId()"));

 	TUint16 wr_langid = 0x0809;								// English (UK) Language ID

 	if (wr_langid == rd_langid_orig)

 		wr_langid = 0x0444;									// Tatar Language ID

 	r = gPort.SetStringDescriptorLangId(wr_langid);

 	test(r == KErrNone);

 	test.Next(_L("GetStringDescriptorLangId()"));

 	TUint16 rd_langid;

 	r = gPort.GetStringDescriptorLangId(rd_langid);

 	test(r == KErrNone);

 	test.Printf(_L("New LANGID code: 0x%04X\n"), rd_langid);

 	test.Next(_L("Compare LANGID codes"));

 	test(rd_langid == wr_langid);

 	test.Next(_L("Restore original LANGID code"));

 	r = gPort.SetStringDescriptorLangId(rd_langid_orig);

 	test(r == KErrNone);

 	r = gPort.GetStringDescriptorLangId(rd_langid);

 	test(r == KErrNone);

 	test(rd_langid == rd_langid_orig);

 	//

 	// --- Manufacturer string

 	//

 	test.Next(_L("GetManufacturerStringDescriptor()"));

 	TBuf16<KUsbStringDescStringMaxSize / 2> rd_str_orig;

 	r = gPort.GetManufacturerStringDescriptor(rd_str_orig);

 	test(r == KErrNone || r == KErrNotFound);

 	TBool restore_string;

 	if (r == KErrNone)

 		{

 		test.Printf(_L("Original Manufacturer string: \"%lS\"\n"), &rd_str_orig);

 		restore_string = ETrue;

 		}

 	else

 		{

 		test.Printf(_L("No Manufacturer string set\n"));

 		restore_string = EFalse;

 		}

 	test.Next(_L("SetManufacturerStringDescriptor()"));

 	_LIT16(manufacturer, "Manufacturer Which Manufactures Devices");

 	TBuf16<KUsbStringDescStringMaxSize / 2> wr_str(manufacturer);

 	r = gPort.SetManufacturerStringDescriptor(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetManufacturerStringDescriptor()"));

 	TBuf16<KUsbStringDescStringMaxSize / 2> rd_str;

 	r = gPort.GetManufacturerStringDescriptor(rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New Manufacturer string: \"%lS\"\n"), &rd_str);

 	test.Next(_L("Compare Manufacturer strings"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("SetManufacturerStringDescriptor()"));

 	_LIT16(manufacturer2, "Different Manufacturer Which Manufactures Different Devices");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = manufacturer2;

 	r = gPort.SetManufacturerStringDescriptor(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetManufacturerStringDescriptor()"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetManufacturerStringDescriptor(rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New Manufacturer string: \"%lS\"\n"), &rd_str);

 	test.Next(_L("Compare Manufacturer strings"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("RemoveManufacturerStringDescriptor()"));

 	r = gPort.RemoveManufacturerStringDescriptor();

 	test(r == KErrNone);

 	r = gPort.GetManufacturerStringDescriptor(rd_str);

 	test(r == KErrNotFound);

 	if (restore_string)

 		{

 		test.Next(_L("Restore original string"));

 		r = gPort.SetManufacturerStringDescriptor(rd_str_orig);

 		test(r == KErrNone);

 		r = gPort.GetManufacturerStringDescriptor(rd_str);

 		test(r == KErrNone);

 		r = rd_str.Compare(rd_str_orig);

 		test(r == KErrNone);

 		}

 	//

 	// --- Product string

 	//

 	test.Next(_L("GetProductStringDescriptor()"));

 	rd_str_orig.FillZ(rd_str.MaxLength());

 	r = gPort.GetProductStringDescriptor(rd_str_orig);

 	test(r == KErrNone || r == KErrNotFound);

 	if (r == KErrNone)

 		{

 		test.Printf(_L("Old Product string: \"%lS\"\n"), &rd_str_orig);

 		restore_string = ETrue;

 		}

 	else

 		restore_string = EFalse;

 	test.Next(_L("SetProductStringDescriptor()"));

 	_LIT16(product, "Product That Was Produced By A Manufacturer");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = product;

 	r = gPort.SetProductStringDescriptor(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetProductStringDescriptor()"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetProductStringDescriptor(rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New Product string: \"%lS\"\n"), &rd_str);

 	test.Next(_L("Compare Product strings"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("SetProductStringDescriptor()"));

 	_LIT16(product2, "Different Product That Was Produced By A Different Manufacturer");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = product2;

 	r = gPort.SetProductStringDescriptor(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetProductStringDescriptor()"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetProductStringDescriptor(rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New Product string: \"%lS\"\n"), &rd_str);

 	test.Next(_L("Compare Product strings"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("RemoveProductStringDescriptor()"));

 	r = gPort.RemoveProductStringDescriptor();

 	test(r == KErrNone);

 	r = gPort.GetProductStringDescriptor(rd_str);

 	test(r == KErrNotFound);

 	if (restore_string)

 		{

 		test.Next(_L("Restore original string"));

 		r = gPort.SetProductStringDescriptor(rd_str_orig);

 		test(r == KErrNone);

 		r = gPort.GetProductStringDescriptor(rd_str);

 		test(r == KErrNone);

 		r = rd_str.Compare(rd_str_orig);

 		test(r == KErrNone);

 		}

 	//

 	// --- Serial Number string

 	//

 	test.Next(_L("GetSerialNumberStringDescriptor()"));

 	rd_str_orig.FillZ(rd_str.MaxLength());

 	r = gPort.GetSerialNumberStringDescriptor(rd_str_orig);

 	test(r == KErrNone || r == KErrNotFound);

 	if (r == KErrNone)

 		{

 		test.Printf(_L("Old Serial Number: \"%lS\"\n"), &rd_str_orig);

 		restore_string = ETrue;

 		}

 	else

 		restore_string = EFalse;

 	test.Next(_L("SetSerialNumberStringDescriptor()"));

 	_LIT16(serial, "000666000XYZ");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = serial;

 	r = gPort.SetSerialNumberStringDescriptor(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetSerialNumberStringDescriptor()"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetSerialNumberStringDescriptor(rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New Serial Number: \"%lS\"\n"), &rd_str);

 	test.Next(_L("Compare Serial Number strings"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("SetSerialNumberStringDescriptor()"));

 	_LIT16(serial2, "Y11611193111711111Y");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = serial2;

 	r = gPort.SetSerialNumberStringDescriptor(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetSerialNumberStringDescriptor()"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetSerialNumberStringDescriptor(rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New Serial Number: \"%lS\"\n"), &rd_str);

 	test.Next(_L("Compare Serial Number strings"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("RemoveSerialNumberStringDescriptor()"));

 	r = gPort.RemoveSerialNumberStringDescriptor();

 	test(r == KErrNone);

 	r = gPort.GetSerialNumberStringDescriptor(rd_str);

 	test(r == KErrNotFound);

 	if (restore_string)

 		{

 		test.Next(_L("Restore original string"));

 		r = gPort.SetSerialNumberStringDescriptor(rd_str_orig);

 		test(r == KErrNone);

 		r = gPort.GetSerialNumberStringDescriptor(rd_str);

 		test(r == KErrNone);

 		r = rd_str.Compare(rd_str_orig);

 		test(r == KErrNone);

 		}

 	//

 	// --- Configuration string

 	//

 	test.Next(_L("GetConfigurationStringDescriptor()"));

 	rd_str_orig.FillZ(rd_str.MaxLength());

 	r = gPort.GetConfigurationStringDescriptor(rd_str_orig);

 	test(r == KErrNone || r == KErrNotFound);

 	if (r == KErrNone)

 		{

 		test.Printf(_L("Old Configuration string: \"%lS\"\n"), &rd_str_orig);

 		restore_string = ETrue;

 		}

 	else

 		restore_string = EFalse;

 	test.Next(_L("SetConfigurationStringDescriptor()"));

 	_LIT16(config, "Relatively Simple Configuration That Is Still Useful");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = config;

 	r = gPort.SetConfigurationStringDescriptor(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetConfigurationStringDescriptor()"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetConfigurationStringDescriptor(rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New Configuration string: \"%lS\"\n"), &rd_str);

 	test.Next(_L("Compare Configuration strings"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("SetConfigurationStringDescriptor()"));

 	_LIT16(config2, "Convenient Configuration That Can Be Very Confusing");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = config2;

 	r = gPort.SetConfigurationStringDescriptor(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetConfigurationStringDescriptor()"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetConfigurationStringDescriptor(rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New Configuration string: \"%lS\"\n"), &rd_str);

 	test.Next(_L("Compare Configuration strings"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	test.Next(_L("RemoveConfigurationStringDescriptor()"));

 	r = gPort.RemoveConfigurationStringDescriptor();

 	test(r == KErrNone);

 	r = gPort.GetConfigurationStringDescriptor(rd_str);

 	test(r == KErrNotFound);

 	if (restore_string)

 		{

 		test.Next(_L("Restore original string"));

 		r = gPort.SetConfigurationStringDescriptor(rd_str_orig);

 		test(r == KErrNone);

 		r = gPort.GetConfigurationStringDescriptor(rd_str);

 		test(r == KErrNone);

 		r = rd_str.Compare(rd_str_orig);

 		test(r == KErrNone);

 		}

 	test.End();

 	}

 //---------------------------------------------

 //! @SYMTestCaseID KBASE-T_USBAPI-0041

 //! @SYMTestType UT

 //! @SYMREQ REQ5662

 //! @SYMTestCaseDesc USB Device Driver API extension to support setting of a string descriptor at a specific index

 //! @SYMTestActions Tests GetStringDescriptor(), SetStringDescriptor() and RemoveStringDescriptor() to verify

 //! the right values are retrieved, set and deleted at specific positions

 //! @SYMTestExpectedResults KErrNone in positive testing and KErrNotFound in negative one

 //! @SYMTestPriority High

 //! @SYMTestStatus Implemented

 //---------------------------------------------

 static void TestArbitraryStringDescriptors()

 	{

 	test.Start(_L("Arbitrary String Descriptor Manipulation"));

 	const TUint8 stridx1 = 0xEE;

 	const TUint8 stridx2 = 0xCC;

 	const TUint8 stridx3 = 0xDD;

 	const TUint8 stridx4 = 0xFF;

 	// First test string

 	test.Next(_L("GetStringDescriptor() 1"));

 	TBuf16<KUsbStringDescStringMaxSize / 2> rd_str;

 	TInt r = gPort.GetStringDescriptor(stridx1, rd_str);

 	test(r == KErrNotFound);

 	test.Next(_L("SetStringDescriptor() 1"));

 	_LIT16(string_one, "Arbitrary String Descriptor Test String 1");

 	TBuf16<KUsbStringDescStringMaxSize / 2> wr_str(string_one);

 	r = gPort.SetStringDescriptor(stridx1, wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetStringDescriptor() 1"));

 	r = gPort.GetStringDescriptor(stridx1, rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New test string @ idx %d: \"%lS\"\n"), stridx1, &rd_str);

 	test.Next(_L("Compare test strings 1"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	// Second test string

 	test.Next(_L("GetStringDescriptor() 2"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetStringDescriptor(stridx2, rd_str);

 	test(r == KErrNotFound);

 	test.Next(_L("SetStringDescriptor() 2"));

 	_LIT16(string_two, "Arbitrary String Descriptor Test String 2");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = string_two;

 	r = gPort.SetStringDescriptor(stridx2, wr_str);

 	test(r == KErrNone);

 	// In between we create another interface setting to see what happens

 	// to the existing string descriptor indices.

 	// (We don't have to test this on every platform -

 	// besides, those that don't support alt settings

 	// are by now very rare.)

 	if (SupportsAlternateInterfaces())

 		{

 		TUsbcInterfaceInfoBuf ifc;

 		_LIT16(string, "T_USBAPI Bogus Test Interface (Setting 2)");

 		ifc().iString = const_cast<TDesC16*>(&string);

 		ifc().iTotalEndpointsUsed = 0;

 		TInt r = gPort.SetInterface(2, ifc);

 		test(r == KErrNone);

 		}

 	test.Next(_L("GetStringDescriptor() 2"));

 	r = gPort.GetStringDescriptor(stridx2, rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New test string @ idx %d: \"%lS\"\n"), stridx2, &rd_str);

 	test.Next(_L("Compare test strings 2"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	// Third test string

 	test.Next(_L("GetStringDescriptor() 3"));

 	rd_str.FillZ(rd_str.MaxLength());

 	r = gPort.GetStringDescriptor(stridx3, rd_str);

 	test(r == KErrNotFound);

 	test.Next(_L("SetStringDescriptor() 3"));

 	_LIT16(string_three, "Arbitrary String Descriptor Test String 3");

 	wr_str.FillZ(wr_str.MaxLength());

 	wr_str = string_three;

 	r = gPort.SetStringDescriptor(stridx3, wr_str);

 	test(r == KErrNone);

 	test.Next(_L("GetStringDescriptor() 3"));

 	r = gPort.GetStringDescriptor(stridx3, rd_str);

 	test(r == KErrNone);

 	test.Printf(_L("New test string @ idx %d: \"%lS\"\n"), stridx3, &rd_str);

 	test.Next(_L("Compare test strings 3"));

 	r = rd_str.Compare(wr_str);

 	test(r == KErrNone);

 	// Remove string descriptors

 	test.Next(_L("RemoveStringDescriptor() 4"));

 	r = gPort.RemoveStringDescriptor(stridx4);

 	test(r == KErrNotFound);

 	test.Next(_L("RemoveStringDescriptor() 3"));

 	r = gPort.RemoveStringDescriptor(stridx3);

 	test(r == KErrNone);

 	r = gPort.GetStringDescriptor(stridx3, rd_str);

 	test(r == KErrNotFound);

 	test.Next(_L("RemoveStringDescriptor() 2"));

 	r = gPort.RemoveStringDescriptor(stridx2);

 	test(r == KErrNone);

 	r = gPort.GetStringDescriptor(stridx2, rd_str);

 	test(r == KErrNotFound);

 	test.Next(_L("RemoveStringDescriptor() 1"));

 	r = gPort.RemoveStringDescriptor(stridx1);

 	test(r == KErrNone);

 	r = gPort.GetStringDescriptor(stridx1, rd_str);

 	test(r == KErrNotFound);

 	test.End();

 	}

 static void TestDescriptorManipulation()

 	{

 	test.Start(_L("Test USB Descriptor Manipulation"));

 	TestDeviceDescriptor();

 	TestDeviceQualifierDescriptor();

 	TestConfigurationDescriptor();

 	TestOtherSpeedConfigurationDescriptor();

 	TestInterfaceDescriptor();

 	TestClassSpecificDescriptors();

 	TestAlternateInterfaceManipulation();

 	TestEndpointDescriptor();

 	TestExtendedEndpointDescriptor();

 	TestStandardStringDescriptors();

 	TestArbitraryStringDescriptors();

 	test.End();

 	}

 //---------------------------------------------

 //! @SYMTestCaseID KBASE-T_USBAPI-0040

 //! @SYMTestType UT

 //! @SYMTestCaseDesc Test OTG extensions

 //! @SYMTestExpectedResults All APIs behave as expected

 //! @SYMTestPriority Medium

 //! @SYMTestStatus Implemented

 //---------------------------------------------

 static void TestOtgExtensions()

 	{

 	test.Start(_L("Test Some OTG API Extensions"));

 	// Test OTG descriptor manipulation

 	test.Next(_L("Get OTG Descriptor Size"));

 	TInt size;

 	gPort.GetOtgDescriptorSize(size);

 	test(static_cast<TUint>(size) == KUsbDescSize_Otg);

 	test.Next(_L("Get OTG Descriptor"));

 	TBuf8<KUsbDescSize_Otg> otgDesc;

 	TInt r = gPort.GetOtgDescriptor(otgDesc);

 	test(r == KErrNotSupported || r == KErrNone);

 	test.Next(_L("Set OTG Descriptor"));

 	if (r == KErrNotSupported)

 		{

 		r = gPort.SetOtgDescriptor(otgDesc);

 		test(r == KErrNotSupported);

 		}

 	else

 		{

 		otgDesc[0] = KUsbDescSize_Otg;

 		otgDesc[1] = KUsbDescType_Otg;

 		// The next step is likely to reset KUsbOtgAttr_HnpSupp

 		otgDesc[2] = KUsbOtgAttr_SrpSupp;

 		r = gPort.SetOtgDescriptor(otgDesc);

 		test(r == KErrNone);

 		TBuf8<KUsbDescSize_Otg> desc;

 		r = gPort.GetOtgDescriptor(desc);

 		test(r == KErrNone);

 		test(desc.Compare(otgDesc) == 0);

 		}

 	// Test get OTG features

 	test.Next(_L("Get OTG Features"));

 	TUint8 features;

 	r = gPort.GetOtgFeatures(features);

 	if (gSupportsOtg)

 		{

 		test(r == KErrNone);

 		TBool b_HnpEnable = (features & KUsbOtgAttr_B_HnpEnable) ? ETrue : EFalse;

 		TBool a_HnpSupport = (features & KUsbOtgAttr_A_HnpSupport) ? ETrue : EFalse;

 		TBool a_AltHnpSupport = (features & KUsbOtgAttr_A_AltHnpSupport) ? ETrue : EFalse;

 		test.Printf(_L("### OTG Features:\nB_HnpEnable(%d)\nA_HnpSupport(%d)\nA_Alt_HnpSupport(%d)\n"),

 					b_HnpEnable, a_HnpSupport, a_AltHnpSupport);

 		}

 	else

 		{

 		test(r == KErrNotSupported);

 		test.Printf(_L("GetOtgFeatures() not supported\n"));

 		}

 	test.End();

 }

 static void TestEndpoint0MaxPacketSizes()

 	{

 	test.Start(_L("Test Endpoint0 MaxPacketSizes"));

 	TUint32 sizes = gPort.EndpointZeroMaxPacketSizes();

 	TInt r = KErrNone;

 	TBool good;

 	TInt mpsize = 0;

 	for (TInt i = 0; i < 32; i++)

 		{

 		TUint bit = sizes & (1 << i);

 		if (bit != 0)

 			{

 			switch (bit)

 				{

 			case KUsbEpSizeCont:

 				good = EFalse;

 				break;

 			case KUsbEpSize8:

 				mpsize = 8;

 				good = ETrue;

 				break;

 			case KUsbEpSize16:

 				mpsize = 16;

 				good = ETrue;

 				break;

 			case KUsbEpSize32:

 				mpsize = 32;

 				good = ETrue;

 				break;

 			case KUsbEpSize64:

 				mpsize = 64;

 				good = ETrue;

 				break;

 			case KUsbEpSize128:

 			case KUsbEpSize256:

 			case KUsbEpSize512:

 			case KUsbEpSize1023:

 			default:

 				good = EFalse;

 				break;

 				}

 			if (good)

 				{

 				test.Printf(_L("Ep0 supports %d bytes MaxPacketSize\n"), mpsize);

 				}

 			else

 				{

 				test.Printf(_L("Bad Ep0 size: 0x%08x, failure will occur\n"), bit);

 				r = KErrGeneral;

 				}

 			}

 		}

 	test(r == KErrNone);

     test.End();

 	}

 static void TestDeviceControl()

 	{

 	test.Start(_L("Test Device Control"));

 	// This is a quick and crude test, to make sure that we don't get a steaming heap

 	// as a result of calling the device control API's.

 	test.Next(_L("SetDeviceControl()"));

 	TInt r = gPort.SetDeviceControl();

 	test(r == KErrNone);

 	test.Next(_L("ReleaseDeviceControl()"));

 	r = gPort.ReleaseDeviceControl();

 	test(r == KErrNone);

 	test.End();

 	}

 static void TestAlternateDeviceStatusNotify()

 	{

 	test.Start(_L("Test Alternate Device Status Notification"));

 	TRequestStatus dev_status;

 	TUint deviceState = 0xffffffff;						// put in a nonsense value

 	test.Next(_L("AlternateDeviceStatusNotify()"));

 	gPort.AlternateDeviceStatusNotify(dev_status, deviceState);

 	test.Next(_L("AlternateDeviceStatusNotifyCancel()"));

 	gPort.AlternateDeviceStatusNotifyCancel();

 	User::WaitForRequest(dev_status);

 	test(dev_status == KErrCancel || dev_status == KErrNone);

 	if (deviceState & KUsbAlternateSetting)

 		{

 		TUint setting = (deviceState & ~KUsbAlternateSetting);

 		test.Printf(_L("Alternate setting change to setting %d - unexpected"), setting);

 		test(EFalse);

 		}

 	else

 		{

 		switch (deviceState)

 			{

 		case EUsbcDeviceStateUndefined:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: Undefined state\n"));

 			break;

 		case EUsbcDeviceStateAttached:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: Attached state\n"));

 			break;

 		case EUsbcDeviceStatePowered:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: Powered state\n"));

 			break;

 		case EUsbcDeviceStateDefault:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: Default state\n"));

 			break;

 		case EUsbcDeviceStateAddress:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: Address state\n"));

 			break;

 		case EUsbcDeviceStateConfigured:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: Configured state\n"));

 			break;

 		case EUsbcDeviceStateSuspended:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: Suspended state\n"));

 			break;

 		case EUsbcNoState:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: State buffering error\n"));

 			test(EFalse);

 			break;

 		default:

 			test.Printf(_L("TestAlternateDeviceStatusNotify: Unknown state\n"));

 			test(EFalse);

 			}

 		}

 	test.End();

 	}

 static void TestEndpointStatusNotify()

 	{

 	test.Start(_L("Test Endpoint Status Notification"));

 	TRequestStatus ep_status;

 	TUint epStateBitmap = 0xffffffff;						// put in a nonsense value

 	test.Next(_L("EndpointStatusNotify()"));

 	gPort.EndpointStatusNotify(ep_status, epStateBitmap);

 	test.Next(_L("EndpointStatusNotifyCancel()"));

 	gPort.EndpointStatusNotifyCancel();

 	User::WaitForRequest(ep_status);

 	test(ep_status.Int() == KErrCancel);

 	test.Next(_L("Check endpoint state bitmap returned"));

 	// Our ifc only uses 2 eps + ep0 is automatically granted:

 	const TUint usedEpBitmap = (1 << EEndpoint0 | 1 << EEndpoint1 | 1 << EEndpoint2);

 	// Must not return info about non existent Eps:

 	test((epStateBitmap & ~usedEpBitmap) == 0);

 	for (TInt i = 0; i <= 2; i++)

 		{

 		if ((epStateBitmap & (1 << i)) == EEndpointStateNotStalled)

 			{

 			test.Printf(_L("EndpointStatusNotify: Ep %d NOT STALLED\n"), i);

 			}

 		else

 			{

 			test.Printf(_L("EndpointStatusNotify: Ep %d STALLED\n"), i);

 			}

 		}

 	test.End();

 	}

 static void TestEndpointStallStatus()

 	{

 	test.Start(_L("Test Endpoint Stall Status"));

 	if (!SupportsEndpointStall())

 		{

 		test.Printf(_L("*** Not supported - skipping endpoint stall status tests\n"));

 		test.End();

 		return;

 		}

 	test.Next(_L("Endpoint stall status"));

 	TEndpointState epState = EEndpointStateUnknown;

 	QueryEndpointState(EEndpoint1);

 	QueryEndpointState(EEndpoint2);

 	test.Next(_L("Stall Ep1"));

 	gPort.HaltEndpoint(EEndpoint1);

 	epState = QueryEndpointState(EEndpoint1);

 	test(epState == EEndpointStateStalled);

 	test.Next(_L("Clear Stall Ep1"));

 	gPort.ClearHaltEndpoint(EEndpoint1);

 	epState = QueryEndpointState(EEndpoint1);

 	test(epState == EEndpointStateNotStalled);

 	test.Next(_L("Stall Ep2"));

 	gPort.HaltEndpoint(EEndpoint2);

 	epState = QueryEndpointState(EEndpoint2);

 	test(epState == EEndpointStateStalled);

 	test.Next(_L("Clear Stall Ep2"));

 	gPort.ClearHaltEndpoint(EEndpoint2);

 	epState = QueryEndpointState(EEndpoint2);

 	test(epState == EEndpointStateNotStalled);

 	test.End();

 	}

 static void CloseChannel()

 	{

 	test.Start(_L("Close Channel"));

 	test.Next(_L("Disconnect Device from Host"));

 	TInt r = gPort.DeviceDisconnectFromHost();

 	test(r != KErrGeneral);

 	if (gSupportsOtg)

 		{

 		test.Next(_L("Stop OTG stack"));

 		gOTG.StopStacks();

 		test.Next(_L("Close OTG Channel"));

 		gOTG.Close();

 		test.Next(_L("Free OTG LDD"));

 		r = User::FreeLogicalDevice(RUsbOtgDriver::Name());

 		test(r == KErrNone);

 		}

 	test.Next(_L("Close USB Channel"));

 	gPort.Close();

 	test.Next(_L("Free USB LDD"));

 	r = User::FreeLogicalDevice(KUsbDeviceName);

 	test(r == KErrNone);

 	test.End();

 	}

 static const TInt KPrologue = 0;

 static const TInt KMain     = 1;

 static const TInt KEpilogue = 2;

 static TInt RunTests(void* /*aArg*/)

 	{

 	static TInt step = KPrologue;

 	static TReal loops = 0;

 	switch (step)

 		{

 	case KPrologue:

 		test.Title();

 		// outermost test begin

 		test.Start(_L("Test of USB APIs not requiring a host connection\n"));

 		if (SupportsUsb())

 			{

 			step = KMain;

 			}

 		else

 			{

 			step = KEpilogue;

 			test.Printf(_L("*** Test platform does not support USB - skipping all tests\n"));

 			}

 		return ETrue;

 	case KMain:

 		OpenChannel();

 		SetupInterface();

 		TestDescriptorManipulation();

 		TestOtgExtensions();

 		TestEndpoint0MaxPacketSizes();

 		TestDeviceControl();

 		TestAlternateDeviceStatusNotify();

 		TestEndpointStatusNotify();

 		TestEndpointStallStatus();

 		CloseChannel();

 		loops++;

 		if (gSoak && (gKeychar != EKeyEscape))

 			{

 			step = KMain;

 			}

 		else

 			{

 			step = KEpilogue;

 			}

 		return ETrue;

 	case KEpilogue:

 		test.Printf(_L("USBAPI tests were run %.0f time(s)\n"), loops);

 		// outermost test end

 		test.End();

 		CActiveScheduler::Stop();

 		return EFalse;

 		}

 	return EFalse;

 	}

 static void RunAppL()

 	{

 	// Create the active scheduler

 	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

 	// Push active scheduler onto the cleanup stack

 	CleanupStack::PushL(scheduler);

 	// Install as the active scheduler

 	CActiveScheduler::Install(scheduler);

 	// Create console handler

 	CConsoleBase* console =

 		Console::NewL(_L("T_USBAPI - USB Client Test Program"), TSize(KConsFullScreen, KConsFullScreen));

 	CleanupStack::PushL(console);

 	// Make this one also RTest's console

 	test.SetConsole(console);

 	// Create keypress notifier active object

 	CActiveKeypressNotifier* keypress_notifier = CActiveKeypressNotifier::NewL(console);

 	test(keypress_notifier != NULL);

 	CleanupStack::PushL(keypress_notifier);

 	keypress_notifier->RequestCharacter();

 	// Create long-running test task active object

 	CIdle* active_test = CIdle::NewL(CActive::EPriorityIdle);

 	test(active_test != NULL);

 	CleanupStack::PushL(active_test);

 	active_test->Start(TCallBack(RunTests));

 	// Start active scheduler

 	CActiveScheduler::Start();

 	// Suspend thread for a short while

 	User::After(1000000);

 	// active_test, keypress_notifier, console, scheduler

 	CleanupStack::PopAndDestroy(4);

 	return;

 	}

 GLDEF_C TInt E32Main()

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();			// get clean-up stack

 	__UHEAP_MARK;

 	_LIT(KArg, "soak");

 	TBuf<64> c;

 	User::CommandLine(c);

 	if (c.CompareF(KArg) == 0)

 		gSoak = ETrue;

 	else

 		gSoak = EFalse;

 	TRAPD(r, RunAppL());

 	__ASSERT_ALWAYS(!r, User::Panic(_L("E32EX"), r));

 	__UHEAP_MARKEND;

 	delete cleanup;											// destroy clean-up stack

 	return KErrNone;

 	}