public void testGetStatusNonStatic() {
/* The method being tested is:
* public static short getStatus(byte recipient, short target)
* throws usbException, IllegalArgumentException
*/
StandardRequest standardRequest = new StandardRequest(usbDevice);
short configurationNumber;
byte recipientType;
short featureSelection;
short target;
short wIndex;
short status;
short statusExpected;
byte requestType;
boolean usbExceptionThrown = false;
/**
* ********************************************************************** First, getStatus for a
* new configuration **********************************************************************
*/
configurationNumber = 1;
status = 0;
// no target needed when recipient is a device
target = 0;
// set recipientType to Device
recipientType = UsbConst.REQUESTTYPE_RECIPIENT_DEVICE;
requestType = UsbConst.REQUESTTYPE_DIRECTION_IN;
statusExpected = 0;
// @P2D16
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
status = standardRequest.getStatus(recipientType, target);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
/*status is unknown at this point, so don't check the value yet*/
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
/* Verify proper listener event received */
assertNotNull("DeviceDataEvent should not be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
verifyGetStatusIrp(target, requestType);
/**
* ********************************************************************** Now, do a setFeature
* for the device and check getStatus
* **********************************************************************
*/
featureSelection = UsbConst.FEATURE_SELECTOR_DEVICE_REMOTE_WAKEUP;
statusExpected = 2;
try {
standardRequest.setFeature(recipientType, featureSelection, target);
try {
/*Wait for setConfiguration Data event before continuing */
Thread.sleep(250);
} catch (InterruptedException e) {
fail("Sleep was interrupted.");
}
} catch (UsbException uE) {
fail("Got exception setting Feature. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
status = standardRequest.getStatus(recipientType, target);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
assertEquals(
"Status is not as expected. Expected value = "
+ statusExpected
+ ", Actual value = "
+ status,
statusExpected,
status);
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
/* Verify proper listener event received */
assertNotNull("DeviceDataEvent should not be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
verifyGetStatusIrp(target, requestType);
/**
* ********************************************************************** Now, do a clearFeature
* for the device and check getStatus
* **********************************************************************
*/
featureSelection = UsbConst.FEATURE_SELECTOR_DEVICE_REMOTE_WAKEUP;
statusExpected = 0;
try {
standardRequest.clearFeature(recipientType, featureSelection, target);
try {
/*Wait for setConfiguration Data event before continuing */
Thread.sleep(250);
} catch (InterruptedException e) {
fail("Sleep was interrupted.");
}
} catch (UsbException uE) {
fail("Got exception clearing Feature. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
status = standardRequest.getStatus(recipientType, target);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
assertEquals(
"Status is not as expected. Expected value = "
+ statusExpected
+ ", Actual value = "
+ status,
statusExpected,
status);
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
/* Verify proper listener event received */
assertNotNull("DeviceDataEvent should not be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
verifyGetStatusIrp(target, requestType);
/**
* ********************************************************************** GetStatus for a device
* with an illegal argument
* **********************************************************************
*/
recipientType = 3;
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
status = standardRequest.getStatus(recipientType, target);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
usbExceptionThrown = true;
} finally {
assertTrue(
"UsbException should have been thrown for using an illegal recipient type: "
+ UsbUtil.toHexString(recipientType),
usbExceptionThrown);
}
try {
Thread.sleep(250);
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
/* Verify proper listener event received */
/* Don't get data or error event with illegal argument exception*/
assertNull("DeviceDataEvent should be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
/**
* ********************************************************************** Now getStatus for an
* interface ***********************************************************************
*/
configurationNumber = 1;
// no target needed when recipient is a device
target = 0;
// set recipientType to Interface
recipientType = UsbConst.REQUESTTYPE_RECIPIENT_INTERFACE;
requestType = UsbConst.REQUESTTYPE_DIRECTION_IN + UsbConst.REQUESTTYPE_RECIPIENT_INTERFACE;
statusExpected = 0;
// @P2D16
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
try {
usbDevice.getActiveUsbConfiguration().getUsbInterface((byte) target).claim();
} catch (UsbClaimException uCE) {
fail("Config " + configurationNumber + " Interface " + target + " is already claimed!");
} catch (UsbNotActiveException uNAE) {
fail("Config " + configurationNumber + " is not active!");
} catch (UsbException uE) {
fail("Config " + configurationNumber + " could not be claimed!");
} catch (UsbDisconnectedException uDE) // @P1C
{ // @P1A
fail("A connected device should't throw the UsbDisconnectedException!"); // @P1A
} // @P1A
status = standardRequest.getStatus(recipientType, target);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
// status should be 0 since interface status cannot be changed
status = 0;
assertEquals(
"Status is not as expected. Expected value = "
+ statusExpected
+ ", Actual value = "
+ status,
statusExpected,
status);
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
// Verify proper listener event received
assertNotNull("DeviceDataEvent should not be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
verifyGetStatusIrp(target, requestType);
/**
* ********************************************************************** Now getStatus for an
* endpoint ***********************************************************************
*/
short endpoint;
configurationNumber = 1;
status = 0;
// no target needed when recipient is a device
target = 0;
// set recipientType to Interface
recipientType = UsbConst.REQUESTTYPE_RECIPIENT_ENDPOINT;
requestType = UsbConst.REQUESTTYPE_DIRECTION_IN + UsbConst.REQUESTTYPE_RECIPIENT_ENDPOINT;
statusExpected = 1;
endpoint = 0x82;
// @P2D16
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
status = standardRequest.getStatus(recipientType, endpoint);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
/*status is unknown at this point, so don't check the value yet */
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
/* Verify proper listener event received */
assertNotNull("DeviceDataEvent should not be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
verifyGetStatusIrp(endpoint, requestType);
/**
* ********************************************************************** getStatus after
* setting feature for the endpoint
* ***********************************************************************
*/
featureSelection = UsbConst.FEATURE_SELECTOR_ENDPOINT_HALT;
statusExpected = 1;
try {
standardRequest.setFeature(recipientType, featureSelection, endpoint);
try {
/*Wait for setConfiguration Data event before continuing */
Thread.sleep(250);
} catch (InterruptedException e) {
fail("Sleep was interrupted.");
}
} catch (UsbException uE) {
fail("Got exception setting Feature. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
status = standardRequest.getStatus(recipientType, endpoint);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
assertEquals(
"Status is not as expected. Expected value = "
+ statusExpected
+ ", Actual value = "
+ status,
statusExpected,
status);
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
/* Verify proper listener event received */
assertNotNull("DeviceDataEvent should not be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
verifyGetStatusIrp(endpoint, requestType);
/**
* ********************************************************************** Now, do a clearFeature
* for the endpoint and check getStatus
* **********************************************************************
*/
featureSelection = UsbConst.FEATURE_SELECTOR_ENDPOINT_HALT;
statusExpected = 0;
try {
standardRequest.clearFeature(recipientType, featureSelection, endpoint);
try {
/*Wait for setConfiguration Data event before continuing */
Thread.sleep(250);
} catch (InterruptedException e) {
fail("Sleep was interrupted.");
}
} catch (UsbException uE) {
fail("Got exception clearing Feature. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
status = standardRequest.getStatus(recipientType, endpoint);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
assertEquals(
"Status is not as expected. Expected value = "
+ statusExpected
+ ", Actual value = "
+ status,
statusExpected,
status);
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
fail("Got illegal argument exception. Exception message" + iE.getMessage());
}
/* Verify proper listener event received */
assertNotNull("DeviceDataEvent should not be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
verifyGetStatusIrp(endpoint, requestType);
/**
* ********************************************************************** GetStatus for an
* endpoint with an illegal argument
* **********************************************************************
*/
// set recipientType to an illegal value
recipientType = 3;
LastUsbDeviceDataEvent = null;
LastUsbDeviceErrorEvent = null;
try {
status = standardRequest.getStatus(recipientType, endpoint);
try {
/*
* Wait for device event before leaving setFeature routine
*/
for (int i = 0; i < 100; i++) {
if ((LastUsbDeviceDataEvent != null) | (LastUsbDeviceErrorEvent != null)) {
break;
}
Thread.sleep(20); // wait 20 ms before checking for event
}
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
} catch (UsbException uE) {
fail("Got exception getting the device status. Exception message: " + uE.getMessage());
} catch (IllegalArgumentException iE) {
usbExceptionThrown = true;
} finally {
assertTrue(
"UsbException should have been thrown for using an illegal recipient type: "
+ UsbUtil.toHexString(recipientType),
usbExceptionThrown);
}
try {
Thread.sleep(250);
} catch (InterruptedException e) {
fail("Sleep was interrupted");
}
try {
usbDevice.getActiveUsbConfiguration().getUsbInterface((byte) target).release();
} catch (UsbClaimException uCE) {
fail("Config " + configurationNumber + " Interface " + target + " is not claimed!");
} catch (UsbException uE) {
fail("Config " + configurationNumber + " could not be released!");
} catch (UsbDisconnectedException uDE) // @P1C
{ // @P1A
fail("A connected device should't throw the UsbDisconnectedException!"); // @P1A
} // @P1A
/* Verify proper listener event received */
assertNull("DeviceDataEvent should be null.", LastUsbDeviceDataEvent);
assertNull("DeviceErrorEvent should be null.", LastUsbDeviceErrorEvent);
}
protected void RoundTripIOTestShortPacket(
byte testType,
int syncOrAsync,
int numIrps,
int endpointmaxPacketSize,
boolean[] acceptShortPacket,
boolean[] verifyAcceptShortPacket,
int[] OUTLength,
int[] OUTOffset,
int[] OUTExpectedLength,
Exception[] OUTexpectedException,
int[] INLength,
int[] INOffset,
int[] INExpectedLength,
Exception[] INexpectedException,
byte[] transformType) {
// Note that this code is based on IOTests.RounTripTest which handles IRP, IRPList, and Byte
// array. Since only IRPs
// are being sent in this test, some of the complexity has been removed; however, although the
// numIrps is always
// one for this test, the code has not been changed to get rid of the arrays.
// ensure all values set up
Assert.assertEquals(numIrps, transformType.length);
Assert.assertEquals(numIrps, OUTLength.length);
Assert.assertEquals(numIrps, OUTOffset.length);
Assert.assertEquals(numIrps, acceptShortPacket.length);
Assert.assertEquals(numIrps, verifyAcceptShortPacket.length);
Assert.assertEquals(numIrps, OUTExpectedLength.length);
Assert.assertEquals(numIrps, OUTexpectedException.length);
Assert.assertEquals(numIrps, INLength.length);
Assert.assertEquals(numIrps, INOffset.length);
Assert.assertEquals(numIrps, INExpectedLength.length);
Assert.assertEquals(numIrps, INexpectedException.length);
Assert.assertNotNull("usbDevice is null, but should not be null.", usbDevice);
Assert.assertEquals("For short packet test, number of IRPs should be 1.", 1, numIrps);
/*
* set up Pipes and add listeners
*/
UsbPipe inPipe = null;
UsbPipe outPipe = null;
// we need two int values back from method call so we'll put them in the array
int[] pipeListIndexes = new int[2];
int inPipeArrayIndex = 0;
int outPipeArrayIndex = 1;
IOMethods.findINandOUTPipesForTest(
usbPipeListGlobal,
endpointmaxPacketSize,
pipeListIndexes,
inPipeArrayIndex,
outPipeArrayIndex);
inPipe = (UsbPipe) usbPipeListGlobal.get(pipeListIndexes[inPipeArrayIndex]);
outPipe = (UsbPipe) usbPipeListGlobal.get(pipeListIndexes[outPipeArrayIndex]);
IOMethods.verifyThePipes(inPipe, outPipe, endpointmaxPacketSize);
inPipe.addUsbPipeListener(inPipeListener);
outPipe.addUsbPipeListener(outPipeListener);
IOMethods.openPipe(inPipe);
IOMethods.openPipe(outPipe);
// define buffers to be used in IRPs or sent as byte[]
byte[] aggregateOUTbuffer = null;
byte[] aggregateINbuffer = null;
// for byte array and single IRP, the OUT and IN buffers are the length specified by the tests
aggregateOUTbuffer = new byte[OUTLength[0]];
aggregateINbuffer = new byte[INLength[0]];
printDebug(
"RoundTripTestShortPacket -- IRP "
+ transmitListStrings[syncOrAsync]
+ " "
+ endpointTypeStrings[endpointType]);
/*
* Create the OUT and IN IRPs or byte arrrays
*/
List transmitBuffers = new ArrayList();
List listOfOUTIrps = new ArrayList();
List listOfINIrps = new ArrayList();
for (int k = 0; k < numIrps; k++) {
// create transmit buffer for OUT and IN IRPs
TransmitBuffer currentTransmitBuffer = new TransmitBuffer(transformType[k], OUTLength[k]);
transmitBuffers.add(currentTransmitBuffer);
// create OUT IRP
UsbIrp currentOUTIrp = outPipe.createUsbIrp();
listOfOUTIrps.add(currentOUTIrp);
// set data in OUT IRP
currentOUTIrp.setData(aggregateOUTbuffer, OUTOffset[k], OUTLength[k]);
currentOUTIrp.setAcceptShortPacket(acceptShortPacket[k]);
// OUT IRP is ready to go!
if (endpointType == UsbConst.ENDPOINT_TYPE_ISOCHRONOUS) {
/*
* For isochronous transfers, all IN Irps will have an offset of zero and
* the same buffer length.
*/
// get the longest required buffer length for all of the IRPs. All of the IRPs in the list
// have the same length buffer.
int standardISOINBufferLength = INLength[0];
for (int l = 1; l < numIrps; l++) {
if (INLength[l] > standardISOINBufferLength) {
standardISOINBufferLength = INLength[l];
}
}
// now that the largest has been found, set the length for each in IRP to the new length
for (int l = 0; l < numIrps; l++) {
INLength[l] = standardISOINBufferLength;
}
int standardISOINBufferOffset = 0;
// int numCopies = 1;//there will be numCopies * numIrps in the list of ISO In Irps
int totalNumCopies = 40; // there will be numCopies * numIrps in the list of ISO In Irps
for (int indexOfCurrentCopy = 0;
indexOfCurrentCopy < totalNumCopies;
indexOfCurrentCopy++) {
// create IN IRP
UsbIrp currentINIrp = inPipe.createUsbIrp();
listOfINIrps.add(currentINIrp);
byte[] currentINbuffer = new byte[standardISOINBufferLength];
currentINIrp.setData(
currentINbuffer, standardISOINBufferOffset, standardISOINBufferLength);
currentINIrp.setAcceptShortPacket(acceptShortPacket[k]);
}
} else {
// create IN IRP
UsbIrp currentINIrp = inPipe.createUsbIrp();
listOfINIrps.add(currentINIrp);
/*
* set data in IN IRP -- note that no data is copied to IN byte[] before setting data in IRP.
* byte[] will be filled by IN operation.
*/
currentINIrp.setData(aggregateINbuffer, INOffset[k], INLength[k]);
currentINIrp.setAcceptShortPacket(acceptShortPacket[k]);
}
}
// copy individual transmitbuffers into single OUT buffer
for (int k = 0; k < numIrps; k++) {
TransmitBuffer currentTransmitBuffer = (TransmitBuffer) transmitBuffers.get(k);
System.arraycopy(
currentTransmitBuffer.getOutBuffer(), 0, aggregateOUTbuffer, OUTOffset[k], OUTLength[k]);
}
// ensure all events are clear before sending IRPs
inPipeEvents.clear();
outPipeEvents.clear();
// send both the OUT and IN IRPs
sendOUTandIN(testType, transmitList[syncOrAsync], inPipe, outPipe, listOfINIrps, listOfOUTIrps);
printDebug("return from sendoutandin");
if (endpointType == UsbConst.ENDPOINT_TYPE_ISOCHRONOUS) {
clearOutTheINEventAndIrpListForISO(inPipeEvents, listOfINIrps);
}
// verify IRP data against expected values
for (int k = 0; k < numIrps; k++) {
UsbIrp submittedOUTIRP = (UsbIrp) listOfOUTIrps.get(k);
// verify OUT IRP after successful transmit
VerifyIrpMethods.verifyUsbIrpAfterEvent(
submittedOUTIRP,
(EventObject) outPipeEvents.get(k),
((TransmitBuffer) transmitBuffers.get(k)).getOutBuffer(),
OUTExpectedLength[k],
OUTexpectedException[k],
acceptShortPacket[k],
verifyAcceptShortPacket[k],
OUTOffset[k],
OUTLength[k]);
UsbIrp submittedINIRP = (UsbIrp) listOfINIrps.get(k);
byte[] expectedINBuffer = ((TransmitBuffer) transmitBuffers.get(k)).getInBuffer();
// if exception is expected, do not verify the In buffer
if (INexpectedException[k] != null) {
expectedINBuffer = null;
// if we got a USB exception as expected, then clear the endpoint
if (submittedINIRP.isUsbException()) {
try {
StandardRequest.clearFeature(
usbDevice,
UsbConst.REQUESTTYPE_RECIPIENT_ENDPOINT,
UsbConst.FEATURE_SELECTOR_ENDPOINT_HALT,
inPipe.getUsbEndpoint().getUsbEndpointDescriptor().bEndpointAddress());
printDebug("clear feature");
} catch (Exception e) {
Assert.fail("Exception clearing halt on enpoint after short packet exception.");
}
} else {
printDebug("not clear feature");
}
}
// verify IN IRP after successful submit
VerifyIrpMethods.verifyUsbIrpAfterEvent(
submittedINIRP,
(EventObject) inPipeEvents.get(k),
expectedINBuffer,
INExpectedLength[k],
INexpectedException[k],
acceptShortPacket[k],
verifyAcceptShortPacket[k],
INOffset[k],
INLength[k]);
}
IOMethods.closePipe(inPipe);
IOMethods.closePipe(outPipe);
inPipe.removeUsbPipeListener(inPipeListener);
outPipe.removeUsbPipeListener(outPipeListener);
};