From 192937d487c65212cba04aff496c1485dbdef03d Mon Sep 17 00:00:00 2001
From: Ovidio Henriquez <odejesush@chromium.org>
Date: Tue, 28 Aug 2018 16:41:08 -0700
Subject: [PATCH] Improve Code Coverage for WebUSB

This change improves the code coverage for the sources files under
//third_party/blink/renderer/modules/webusb.

The affected files are:
* usb.cc
* usb_alternate_interface.cc
* usb_configuration.cc
* usb_device.cc
* usb_endpoint.cc
* usb_interface.cc

Bug: 854831
Change-Id: Ie67533ece27f1c944b0e9186d01a61219a30f805
Reviewed-on: https://chromium-review.googlesource.com/1183789
Commit-Queue: Ovidio Henriquez <odejesush@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#586930}
---
 ...-disabled-by-feature-policy.https.sub.html |  17 +-
 webusb/usb.https.window.js                    |   6 +-
 webusb/usbAlternateInterface.https.any.js     |  33 ++
 webusb/usbConfiguration.https.any.js          |  23 ++
 webusb/usbDevice.https.any.js                 | 345 ++++++++++++++----
 webusb/usbEndpoint.https.any.js               |  45 +++
 webusb/usbInterface.https.any.js              |  53 +++
 7 files changed, 453 insertions(+), 69 deletions(-)
 create mode 100644 webusb/usbAlternateInterface.https.any.js
 create mode 100644 webusb/usbConfiguration.https.any.js
 create mode 100644 webusb/usbEndpoint.https.any.js
 create mode 100644 webusb/usbInterface.https.any.js
diff --git a/webusb/usb-disabled-by-feature-policy.https.sub.html b/webusb/usb-disabled-by-feature-policy.https.sub.html
index 3a8a9183591605..97e66b2a373f73 100644
--- a/webusb/usb-disabled-by-feature-policy.https.sub.html
+++ b/webusb/usb-disabled-by-feature-policy.https.sub.html
@@ -1,8 +1,8 @@
 <!DOCTYPE html>
 <body>
-<script src=/resources/testharness.js></script>
-<script src=/resources/testharnessreport.js></script>
-<script src=/feature-policy/resources/featurepolicy.js></script>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/feature-policy/resources/featurepolicy.js"></script>
 <script>
 'use strict';
 const sub = 'https://{{domains[www]}}:{{ports[https][0]}}';
@@ -19,7 +19,16 @@
   }, error => {
     assert_equals(error.name, 'SecurityError');
   });
-}, header + ' disallows the top-level document.');
+}, header + ' disallows getDevices in the top-level document.');
+
+promise_test(async () => {
+  try {
+    await navigator.usb.requestDevice({ filters: [] });
+    assert_unreached('expected promise to reject with SecurityError');
+  } catch(error) {
+    assert_equals(error.name, 'SecurityError');
+  }
+}, header + ' disallows requestDevice in the top-level document.');
 
 async_test(t => {
   test_feature_availability('usb.getDevices()', t, same_origin_src,
diff --git a/webusb/usb.https.window.js b/webusb/usb.https.window.js
index ee26619cf2224a..c5409d145de165 100644
--- a/webusb/usb.https.window.js
+++ b/webusb/usb.https.window.js
@@ -60,7 +60,8 @@ usb_test(() => {
 usb_test(() => {
   const expectedFilters = [
     { vendorId: 1234, classCode: 0xFF, serialNumber: "123ABC" },
-    { vendorId: 5678, productId: 0xF00F }
+    { vendorId: 5678, productId: 0xF00F },
+    { vendorId: 9012, classCode: 0xFF, subclassCode: 0xEE, protocolCode: 0xDD },
   ];
 
   navigator.usb.test.onrequestdevice = event => {
@@ -77,7 +78,8 @@ usb_test(() => {
   return callWithTrustedClick(() => {
     return navigator.usb.requestDevice({ filters: expectedFilters })
       .then(device => {
-        assert_unreachable('requestDevice should reject because no device selected');
+        assert_unreachable(
+            'requestDevice should reject because no device selected');
       })
       .catch(error => {
         assert_equals(error.code, DOMException.NOT_FOUND_ERR);
diff --git a/webusb/usbAlternateInterface.https.any.js b/webusb/usbAlternateInterface.https.any.js
new file mode 100644
index 00000000000000..e5ef3844ae4400
--- /dev/null
+++ b/webusb/usbAlternateInterface.https.any.js
@@ -0,0 +1,33 @@
+// META: script=/webusb/resources/fake-devices.js
+// META: script=/webusb/resources/usb-helpers.js
+'use strict';
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  let usbInterface = new USBInterface(
+      configuration, configuration.interfaces[0].interfaceNumber);
+  let alternateInterface = new USBAlternateInterface(
+      usbInterface, usbInterface.alternates[1].alternateSetting);
+  assertDeviceInfoEquals(
+      alternateInterface,
+      fakeDeviceInit.configurations[1].interfaces[0].alternates[1]);
+}, 'Can construct a USBAlternateInterface.');
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  let usbInterface = new USBInterface(
+      configuration, configuration.interfaces[0].interfaceNumber);
+  try {
+    let alternateInterface = new USBAlternateInterface(
+        usbInterface, usbInterface.alternates.length);
+    assert_unreached(
+        'USBAlternateInterface should reject an invalid alternate setting');
+  } catch (error) {
+    assert_equals(error.name, 'RangeError');
+  }
+}, 'Constructing a USBAlternateInterface with an invalid alternate setting ' +
+    'throws a range error.');
diff --git a/webusb/usbConfiguration.https.any.js b/webusb/usbConfiguration.https.any.js
new file mode 100644
index 00000000000000..e7d1c7fb146dcd
--- /dev/null
+++ b/webusb/usbConfiguration.https.any.js
@@ -0,0 +1,23 @@
+// META: script=/webusb/resources/fake-devices.js
+// META: script=/webusb/resources/usb-helpers.js
+'use strict';
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  assertDeviceInfoEquals(configuration, fakeDeviceInit.configurations[1]);
+}, 'Can construct a USBConfiguration.');
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  try {
+    let configuration =
+        new USBConfiguration(device, device.configurations.length + 1);
+    assert_unreached(
+        'USBConfiguration should reject an invalid configuration value');
+  } catch (error) {
+    assert_equals(error.name, 'RangeError');
+  }
+}, 'Constructing a USBConfiguration with an invalid configuration value ' +
+    'throws a range error.');
diff --git a/webusb/usbDevice.https.any.js b/webusb/usbDevice.https.any.js
index da7df081b8b16c..046de82b1bd8be 100644
--- a/webusb/usbDevice.https.any.js
+++ b/webusb/usbDevice.https.any.js
@@ -6,6 +6,10 @@ function assertRejectsWithNotFoundError(promise) {
   return assertRejectsWithError(promise, 'NotFoundError');
 }
 
+function assertRejectsWithTypeError(promise) {
+  return assertRejectsWithError(promise, 'TypeError');
+}
+
 function assertRejectsWithNotOpenError(promise) {
   return assertRejectsWithError(
       promise, 'InvalidStateError', 'The device must be opened first.');
@@ -17,6 +21,18 @@ function assertRejectsWithNotConfiguredError(promise) {
       'The device must have a configuration selected.');
 }
 
+function assertRejectsWithDeviceStateChangeInProgressError(promise) {
+  return assertRejectsWithError(
+    promise, 'InvalidStateError',
+    'An operation that changes the device state is in progress.');
+}
+
+function assertRejectsWithInterfaceStateChangeInProgressError(promise) {
+  return assertRejectsWithError(
+    promise, 'InvalidStateError',
+    'An operation that changes interface state is in progress.');
+}
+
 usb_test(() => {
   return getFakeDevice().then(({ device, fakeDevice }) => {
     return waitForDisconnect(fakeDevice)
@@ -59,22 +75,63 @@ usb_test(() => {
   });
 }, 'open and close can be called multiple times');
 
-usb_test(() => {
-  return getFakeDevice().then(({ device }) => {
-    const message =
-        'An operation that changes the device state is in progress.';
-    return Promise.all([
-        device.open(),
-        assertRejectsWithError(device.open(), 'InvalidStateError', message),
-        assertRejectsWithError(device.close(), 'InvalidStateError', message),
-    ]).then(() => Promise.all([
-        device.close(),
-        assertRejectsWithError(device.open(), 'InvalidStateError', message),
-        assertRejectsWithError(device.close(), 'InvalidStateError', message),
-    ]));
-  });
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  await Promise.all([
+    device.open(),
+    assertRejectsWithDeviceStateChangeInProgressError(device.open()),
+    assertRejectsWithDeviceStateChangeInProgressError(device.close()),
+  ]);
+  await Promise.all([
+    device.close(),
+    assertRejectsWithDeviceStateChangeInProgressError(device.open()),
+    assertRejectsWithDeviceStateChangeInProgressError(device.close()),
+  ]);
 }, 'open and close cannot be called again while open or close are in progress');
 
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  await device.open();
+  return Promise.all([
+    device.selectConfiguration(1),
+    assertRejectsWithDeviceStateChangeInProgressError(
+        device.claimInterface(0)),
+    assertRejectsWithDeviceStateChangeInProgressError(
+        device.releaseInterface(0)),
+    assertRejectsWithDeviceStateChangeInProgressError(device.open()),
+    assertRejectsWithDeviceStateChangeInProgressError(
+        device.selectConfiguration(1)),
+    assertRejectsWithDeviceStateChangeInProgressError(device.reset()),
+    assertRejectsWithDeviceStateChangeInProgressError(
+        device.selectAlternateInterface(0, 0)),
+    assertRejectsWithDeviceStateChangeInProgressError(
+        device.controlTransferOut({
+          requestType: 'standard',
+          recipient: 'interface',
+          request: 0x42,
+          value: 0x1234,
+          index: 0x0000,
+        })),
+    assertRejectsWithDeviceStateChangeInProgressError(
+        device.controlTransferOut({
+          requestType: 'standard',
+          recipient: 'interface',
+          request: 0x42,
+          value: 0x1234,
+          index: 0x0000,
+        }, new Uint8Array([1, 2, 3]))),
+    assertRejectsWithDeviceStateChangeInProgressError(
+        device.controlTransferIn({
+          requestType: 'standard',
+          recipient: 'interface',
+          request: 0x42,
+          value: 0x1234,
+          index: 0x0000
+        }, 0)),
+    assertRejectsWithDeviceStateChangeInProgressError(device.close()),
+  ]);
+}, 'device operations reject if an device state change is in progress');
+
 usb_test(() => {
   return getFakeDevice().then(({ device, fakeDevice }) => {
     return device.open()
@@ -138,6 +195,21 @@ usb_test(() => {
   });
 }, 'device configuration can be set and queried');
 
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  assert_equals(device.configuration, null);
+  await device.open();
+  assert_equals(device.configuration, null);
+  await device.selectConfiguration(1);
+  await device.selectConfiguration(1);
+  assertDeviceInfoEquals(
+      device.configuration, fakeDeviceInit.configurations[0]);
+  await device.selectConfiguration(2);
+  assertDeviceInfoEquals(
+      device.configuration, fakeDeviceInit.configurations[1]);
+  await device.close();
+}, 'a device configuration value can be set again');
+
 usb_test(() => {
   return getFakeDevice().then(({ device }) => {
     assert_equals(device.configuration, null);
@@ -198,19 +270,82 @@ usb_test(() => {
   });
 }, 'an interface can be claimed and released');
 
-usb_test(() => {
-  return getFakeDevice().then(({ device }) => {
-    return device.open()
-      .then(() => device.selectConfiguration(1))
-      .then(() => device.claimInterface(0))
-      .then(() => {
-        assert_true(device.configuration.interfaces[0].claimed);
-        return device.close(0);
-      })
-      .then(() => {
-        assert_false(device.configuration.interfaces[0].claimed);
-      });
-  });
+usb_test(async () => {
+  let { device } = await getFakeDevice()
+  await device.open();
+  await device.selectConfiguration(1);
+  await device.claimInterface(0);
+  assert_true(device.configuration.interfaces[0].claimed);
+  await device.claimInterface(0);
+  assert_true(device.configuration.interfaces[0].claimed);
+  await device.close();
+}, 'an interface can be claimed multiple times');
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  await device.open();
+  await device.selectConfiguration(1);
+  await device.claimInterface(0);
+  assert_true(device.configuration.interfaces[0].claimed);
+  await device.releaseInterface(0);
+  assert_false(device.configuration.interfaces[0].claimed);
+  await device.releaseInterface(0);
+  assert_false(device.configuration.interfaces[0].claimed);
+  await device.close();
+}, 'an interface can be released multiple times');
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  await device.open();
+  await device.selectConfiguration(1);
+  return Promise.all([
+    device.claimInterface(0),
+    assertRejectsWithInterfaceStateChangeInProgressError(
+        device.claimInterface(0)),
+    assertRejectsWithInterfaceStateChangeInProgressError(
+        device.releaseInterface(0)),
+    assertRejectsWithInterfaceStateChangeInProgressError(device.open()),
+    assertRejectsWithInterfaceStateChangeInProgressError(
+        device.selectConfiguration(1)),
+    assertRejectsWithInterfaceStateChangeInProgressError(device.reset()),
+    assertRejectsWithInterfaceStateChangeInProgressError(
+        device.selectAlternateInterface(0, 0)),
+    assertRejectsWithInterfaceStateChangeInProgressError(
+        device.controlTransferOut({
+          requestType: 'standard',
+          recipient: 'interface',
+          request: 0x42,
+          value: 0x1234,
+          index: 0x0000,
+        })),
+    assertRejectsWithInterfaceStateChangeInProgressError(
+        device.controlTransferOut({
+          requestType: 'standard',
+          recipient: 'interface',
+          request: 0x42,
+          value: 0x1234,
+          index: 0x0000,
+        }, new Uint8Array([1, 2, 3]))),
+    assertRejectsWithInterfaceStateChangeInProgressError(
+        device.controlTransferIn({
+          requestType: 'standard',
+          recipient: 'interface',
+          request: 0x42,
+          value: 0x1234,
+          index: 0x0000
+        }, 0)),
+    assertRejectsWithInterfaceStateChangeInProgressError(device.close()),
+  ]);
+}, 'device operations reject if an interface state change is in progress');
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  await device.open();
+  await device.selectConfiguration(1);
+  await device.claimInterface(0);
+  assert_true(device.configuration.interfaces[0].claimed);
+  await device.close(0);
+  assert_false(device.configuration.interfaces[0].claimed);
 }, 'interfaces are released on close');
 
 usb_test(() => {
@@ -281,29 +416,35 @@ usb_test(() => {
   });
 }, 'selectAlternateInterface rejects when called on a disconnected device');
 
-usb_test(() => {
-  return getFakeDevice().then(({ device }) => {
-    return device.open()
-      .then(() => device.selectConfiguration(1))
-      .then(() => device.controlTransferIn({
-        requestType: 'vendor',
-        recipient: 'device',
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  let usbRequestTypes = ['standard', 'class', 'vendor'];
+  let usbRecipients = ['device', 'interface', 'endpoint', 'other'];
+  await device.open();
+  await device.selectConfiguration(1);
+  await device.claimInterface(0);
+  await device.selectAlternateInterface(0, 0);
+  for (const requestType of usbRequestTypes) {
+    for (const recipient of usbRecipients) {
+      let index = recipient === 'interface' ? 0x5600 : 0x5681;
+      let result = await device.controlTransferIn({
+        requestType: requestType,
+        recipient: recipient,
         request: 0x42,
         value: 0x1234,
-        index: 0x5678
-      }, 7))
-      .then(result => {
-        assert_true(result instanceof USBInTransferResult);
-        assert_equals(result.status, 'ok');
-        assert_equals(result.data.byteLength, 7);
-        assert_equals(result.data.getUint16(0), 0x07);
-        assert_equals(result.data.getUint8(2), 0x42);
-        assert_equals(result.data.getUint16(3), 0x1234);
-        assert_equals(result.data.getUint16(5), 0x5678);
-        return device.close();
-      });
-  });
-}, 'can issue IN control transfer');
+        index: index
+      }, 7);
+      assert_true(result instanceof USBInTransferResult);
+      assert_equals(result.status, 'ok');
+      assert_equals(result.data.byteLength, 7);
+      assert_equals(result.data.getUint16(0), 0x07);
+      assert_equals(result.data.getUint8(2), 0x42);
+      assert_equals(result.data.getUint16(3), 0x1234);
+      assert_equals(result.data.getUint16(5), index);
+    }
+  }
+  await device.close();
+}, 'can issue all types of IN control transfers');
 
 usb_test(() => {
   return getFakeDevice().then(({ device, fakeDevice }) => {
@@ -320,25 +461,39 @@ usb_test(() => {
   });
 }, 'controlTransferIn rejects when called on a disconnected device');
 
-usb_test(() => {
-  return getFakeDevice().then(({ device }) => {
-    return device.open()
-      .then(() => device.selectConfiguration(1))
-      .then(() => device.controlTransferOut({
-        requestType: 'vendor',
-        recipient: 'device',
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  let usbRequestTypes = ['standard', 'class', 'vendor'];
+  let usbRecipients = ['device', 'interface', 'endpoint', 'other'];
+  let dataArray = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+  let dataTypes = [dataArray, dataArray.buffer];
+  await device.open();
+  await device.selectConfiguration(1);
+  await device.claimInterface(0);
+  await device.selectAlternateInterface(0, 0);
+  for (const requestType of usbRequestTypes) {
+    for (const recipient of usbRecipients) {
+      let index = recipient === 'interface' ? 0x5600 : 0x5681;
+      let transferParams = {
+        requestType: requestType,
+        recipient: recipient,
         request: 0x42,
         value: 0x1234,
-        index: 0x5678
-      }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])))
-    .then(result => {
+        index: index
+      };
+      for (const data of dataTypes) {
+        let result = await device.controlTransferOut(transferParams, data);
+        assert_true(result instanceof USBOutTransferResult);
+        assert_equals(result.status, 'ok');
+        assert_equals(result.bytesWritten, 8);
+      }
+      let result = await device.controlTransferOut(transferParams);
       assert_true(result instanceof USBOutTransferResult);
       assert_equals(result.status, 'ok');
-      assert_equals(result.bytesWritten, 8);
-      return device.close();
-    });
-  });
-}, 'can issue OUT control transfer');
+    }
+  }
+  await device.close();
+}, 'can issue all types of OUT control transfers');
 
 usb_test(() => {
   return getFakeDevice().then(({ device, fakeDevice }) => {
@@ -355,6 +510,70 @@ usb_test(() => {
   });
 }, 'controlTransferOut rejects when called on a disconnected device');
 
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  await device.open();
+  await device.selectConfiguration(1);
+  await device.claimInterface(0);
+  assertRejectsWithTypeError(device.controlTransferOut({
+    requestType: 'invalid',
+    recipient: 'device',
+    request: 0x42,
+    value: 0x1234,
+    index: 0x5678
+  }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])));
+  assertRejectsWithTypeError(device.controlTransferIn({
+    requestType: 'invalid',
+    recipient: 'device',
+    request: 0x42,
+    value: 0x1234,
+    index: 0x5678
+  }, 0));
+  await device.close();
+}, 'control transfers with a invalid request type reject');
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  await device.open();
+  await device.selectConfiguration(1);
+  await device.claimInterface(0);
+  assertRejectsWithTypeError(device.controlTransferOut({
+    requestType: 'vendor',
+    recipient: 'invalid',
+    request: 0x42,
+    value: 0x1234,
+    index: 0x5678
+  }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])));
+  assertRejectsWithTypeError(device.controlTransferIn({
+    requestType: 'vendor',
+    recipient: 'invalid',
+    request: 0x42,
+    value: 0x1234,
+    index: 0x5678
+  }, 0));
+}, 'control transfers with a invalid recipient type reject');
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  await device.open();
+  await device.selectConfiguration(1);
+  await device.claimInterface(0);
+  assertRejectsWithNotFoundError(device.controlTransferOut({
+    requestType: 'vendor',
+    recipient: 'interface',
+    request: 0x42,
+    value: 0x1234,
+    index: 0x0002  // Last byte of index is interface number.
+  }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])));
+  assertRejectsWithNotFoundError(device.controlTransferIn({
+    requestType: 'vendor',
+    recipient: 'interface',
+    request: 0x42,
+    value: 0x1234,
+    index: 0x0002  // Last byte of index is interface number.
+  }, 0));
+}, 'control transfers to a non-existant interface reject');
+
 usb_test(() => {
   return getFakeDevice().then(({ device }) => {
     let interfaceRequest = {
diff --git a/webusb/usbEndpoint.https.any.js b/webusb/usbEndpoint.https.any.js
new file mode 100644
index 00000000000000..e57639c3d4b9e4
--- /dev/null
+++ b/webusb/usbEndpoint.https.any.js
@@ -0,0 +1,45 @@
+// META: script=/webusb/resources/fake-devices.js
+// META: script=/webusb/resources/usb-helpers.js
+'use strict';
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  let usbInterface = new USBInterface(
+      configuration, configuration.interfaces[0].interfaceNumber);
+  let alternateInterface = new USBAlternateInterface(
+      usbInterface, usbInterface.alternates[1].alternateSetting);
+  let inEndpoint = new USBEndpoint(
+      alternateInterface, alternateInterface.endpoints[0].endpointNumber, 'in');
+  let outEndpoint = new USBEndpoint(
+      alternateInterface,
+      alternateInterface.endpoints[1].endpointNumber,
+      'out');
+  assertDeviceInfoEquals(
+      inEndpoint,
+      fakeDeviceInit.configurations[1].interfaces[0].alternates[1]
+          .endpoints[0]);
+  assertDeviceInfoEquals(
+      outEndpoint,
+      fakeDeviceInit.configurations[1].interfaces[0].alternates[1]
+          .endpoints[1]);
+}, 'Can construct a USBEndpoint.');
+
+usb_test(async () => {
+  let { device } = await getFakeDevice();
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  let usbInterface = new USBInterface(
+      configuration, configuration.interfaces[0].interfaceNumber);
+  let alternateInterface = new USBAlternateInterface(
+      usbInterface, usbInterface.alternates[1].alternateSetting);
+  try {
+    let endpoint = new USBEndpoint(
+        alternateInterface, alternateInterface.endpoints.length, 'in');
+    assert_unreached('USBEndpoint should reject an invalid endpoint number');
+  } catch (error) {
+    assert_equals(error.name, 'RangeError');
+  }
+}, 'Constructing a USBEndpoint with an invalid endpoint number  throws a ' +
+    'range error.');
diff --git a/webusb/usbInterface.https.any.js b/webusb/usbInterface.https.any.js
new file mode 100644
index 00000000000000..7fbf660bbce014
--- /dev/null
+++ b/webusb/usbInterface.https.any.js
@@ -0,0 +1,53 @@
+// META: script=/webusb/resources/fake-devices.js
+// META: script=/webusb/resources/usb-helpers.js
+'use strict';
+
+usb_test(async () => {
+  let { device } =  await getFakeDevice();
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  let usbInterface = new USBInterface(
+      configuration, configuration.interfaces[0].interfaceNumber);
+  assertDeviceInfoEquals(
+      usbInterface, fakeDeviceInit.configurations[1].interfaces[0]);
+}, 'Can construct a USBInterface.');
+
+usb_test(async () => {
+  let { device } =  await getFakeDevice();
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  try {
+    let usbInterface = new USBInterface(
+        configuration, configuration.interfaces.length);
+    assert_unreached('USBInterface should reject an invalid interface number');
+  } catch (error) {
+    assert_equals(error.name, 'RangeError');
+  }
+}, 'Constructing a USBInterface with an invalid interface number ' +
+    'throws a range error.');
+
+usb_test(async () => {
+  let { device } =  await getFakeDevice();
+  await device.open();
+  await device.selectConfiguration(2);
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  let usbInterface = new USBInterface(
+      configuration, configuration.interfaces[0].interfaceNumber);
+  assert_equals(usbInterface.alternate, null);
+}, 'The alternate attribute of USBInterface returns null if the interface' +
+    'has not been claimed.');
+
+usb_test(async () => {
+  let { device } =  await getFakeDevice();
+  await device.open();
+  await device.selectConfiguration(2);
+  await device.claimInterface(0);
+  await device.selectAlternateInterface(0, 1);
+  let configuration = new USBConfiguration(
+      device, device.configurations[1].configurationValue);
+  let usbInterface = new USBInterface(
+      configuration, configuration.interfaces[0].interfaceNumber);
+  assert_equals(usbInterface.alternate.alternateSetting, 1);
+}, 'The alternate attribute of USBInterface returns the active alternate ' +
+    'interface.');
