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); }
private void sendOUTandIN( byte testType, boolean SyncOrAsync, UsbPipe inPipe, UsbPipe outPipe, List listOfINIrps, List listOfOUTIrps) { try { if (endpointType == UsbConst.ENDPOINT_TYPE_ISOCHRONOUS) { // For isochronous, a list of IN IRPs must be async submitted as the IN for // the byte[], IRP, and IRP List tests. Only the OUT, will be submitted // as a byte[], IRP, IRPList and in both synchronous and asynchronous modes. try { printDebug("About to async Submit IN IRP List for ISOCHRONOUS"); inPipe.asyncSubmit(listOfINIrps); printDebug("Return from async Submit IN IRP List for ISOCHRONOUS"); } catch (Exception uE) { System.out.println("Exception on async submit. Submission failed." + uE.getMessage()); Assert.fail("Exception on async submit. Submission failed." + uE.getMessage()); } } if (SyncOrAsync == SYNC_SUBMIT) { printDebug("About to sync Submit OUT IRP"); // for single IRP, send the first IRP in the IRP list outPipe.syncSubmit((UsbIrp) listOfOUTIrps.get(0)); printDebug("Return from sync Submit OUT IRP"); } else { printDebug("About to async Submit OUT IRP"); // for single IRP, send the first IRP in the IRP list outPipe.asyncSubmit((UsbIrp) listOfOUTIrps.get(0)); printDebug("Return from async Submit OUT IRP"); // wait for IRP to be complete; wait a max of 5000 ms ((UsbIrp) listOfOUTIrps.get(0)).waitUntilComplete(5000); } // all IRPs should be complete when sync submit returns for (int i = 0; i < (listOfOUTIrps.size()); i++) { Assert.assertTrue( "isComplete() not true for IRP after syncSubmit returned", ((UsbIrp) listOfOUTIrps.get(i)).isComplete()); Assert.assertFalse( "isUsbException() is true for IRP after syncSubmit returned", ((UsbIrp) listOfOUTIrps.get(i)).isUsbException()); } // isochronous IN IRP List was already submitted (see above) if (endpointType != UsbConst.ENDPOINT_TYPE_ISOCHRONOUS) { if (SyncOrAsync == SYNC_SUBMIT) { printDebug("About to sync Submit IN IRP"); // for single IRP, send the first IRP in the IRP list inPipe.syncSubmit((UsbIrp) listOfINIrps.get(0)); printDebug("Return from sync Submit IN IRP"); } else { printDebug("About to async Submit IN IRP"); // for single IRP, send the first IRP in the IRP list inPipe.asyncSubmit((UsbIrp) listOfINIrps.get(0)); printDebug("Return from async Submit IN IRP"); // wait for IRP to be complete; wait a max of 5000 ms ((UsbIrp) listOfINIrps.get(0)).waitUntilComplete(5000); printDebug("Finished waiting on async in irp--timeout"); ((UsbIrp) listOfINIrps.get(0)).waitUntilComplete(); printDebug("Finished waiting on async in irp"); } } // all IRPs should be complete when sync submit returns for (int i = 0; i < (listOfINIrps.size()); i++) { Assert.assertTrue( "isComplete() not true for IRP after syncSubmit returned", ((UsbIrp) listOfINIrps.get(i)).isComplete()); // Assert.assertFalse("isUsbException() is true for IRP after syncSubmit returned", // ((UsbIrp)listOfINIrps.get(i)).isUsbException()); } } catch (UsbException uE) { // exceptions are expected in this test } catch (UsbDisconnectedException uDE) // @P1A { // @P1A Assert.fail("A connected device should't throw the UsbDisconnectedException!"); // @P1A } // @P1A try { /* * After all IRPs are complete, wait for all device events. * Wait for device event before leaving submit routine. * 400 * 5 ms = 2000 ms = 2 seconds max wait for the last event * before error. * This should be an adequate wait because we don't get here until * all of the submits are complete */ // first wait for all OUT events for (int i = 0; i < 400; i++) { if (outPipeEvents.size() == listOfOUTIrps.size()) { // System.out.println("Data event took less than " + ((i+1) * 20 ) +" milliseconds"); break; } Thread.sleep(5); // wait 5 ms before checkin for event } // now wait for all IN events for (int i = 0; i < 400; i++) { if (inPipeEvents.size() == listOfINIrps.size()) { // System.out.println("Data event took less than " + ((i+1) * 20 ) +" milliseconds"); break; } Thread.sleep(5); // wait 5 ms before checkin for event } } catch (InterruptedException e) { Assert.fail("Sleep was interrupted"); } finally { Assert.assertEquals( "Did not receive all expected IN pipe events after sleep.", listOfINIrps.size(), inPipeEvents.size()); Assert.assertEquals( "Did not receive all expected OUT pipe event after sleep.", listOfOUTIrps.size(), outPipeEvents.size()); } };