summaryrefslogtreecommitdiffstats
path: root/testing/web-platform/tests/webusb/usbDevice.https.any.js
diff options
context:
space:
mode:
Diffstat (limited to 'testing/web-platform/tests/webusb/usbDevice.https.any.js')
-rw-r--r--testing/web-platform/tests/webusb/usbDevice.https.any.js1249
1 files changed, 1249 insertions, 0 deletions
diff --git a/testing/web-platform/tests/webusb/usbDevice.https.any.js b/testing/web-platform/tests/webusb/usbDevice.https.any.js
new file mode 100644
index 0000000000..b1b0c133ce
--- /dev/null
+++ b/testing/web-platform/tests/webusb/usbDevice.https.any.js
@@ -0,0 +1,1249 @@
+// META: timeout=long
+// META: script=/resources/test-only-api.js
+// META: script=/webusb/resources/fake-devices.js
+// META: script=/webusb/resources/usb-helpers.js
+'use strict';
+
+function detachBuffer(buffer) {
+ if (self.GLOBAL.isWindow())
+ window.postMessage('', '*', [buffer]);
+ else
+ self.postMessage('', [buffer]);
+}
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return waitForDisconnect(fakeDevice)
+ .then(() => promise_rejects_dom(t, 'NotFoundError', device.open()));
+ });
+}, 'open rejects when called on a disconnected device');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device, fakeDevice }) => {
+ return device.open()
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(() => {
+ assert_false(device.opened);
+ });
+ });
+}, 'disconnection closes the device');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ assert_false(device.opened);
+ return device.open().then(() => {
+ assert_true(device.opened);
+ return device.close().then(() => {
+ assert_false(device.opened);
+ });
+ });
+ });
+}, 'a device can be opened and closed');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open()
+ .then(() => device.open())
+ .then(() => device.open())
+ .then(() => device.open())
+ .then(() => device.close())
+ .then(() => device.close())
+ .then(() => device.close())
+ .then(() => device.close());
+ });
+}, 'open and close can be called multiple times');
+
+usb_test(async (t) => {
+ let { device } = await getFakeDevice();
+ await Promise.all([
+ device.open(),
+ promise_rejects_dom(t, 'InvalidStateError', device.open()),
+ promise_rejects_dom(t, 'InvalidStateError', device.close()),
+ ]);
+ await Promise.all([
+ device.close(),
+ promise_rejects_dom(t, 'InvalidStateError', device.open()),
+ promise_rejects_dom(t, 'InvalidStateError', device.close()),
+ ]);
+}, 'open and close cannot be called again while open or close are in progress');
+
+usb_test(async (t) => {
+ let { device } = await getFakeDevice();
+ await device.open();
+ return Promise.all([
+ device.selectConfiguration(1),
+ promise_rejects_dom(t, 'InvalidStateError', device.claimInterface(0)),
+ promise_rejects_dom(t, 'InvalidStateError', device.releaseInterface(0)),
+ promise_rejects_dom(t, 'InvalidStateError', device.open()),
+ promise_rejects_dom(t, 'InvalidStateError', device.selectConfiguration(1)),
+ promise_rejects_dom(t, 'InvalidStateError', device.reset()),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.selectAlternateInterface(0, 0)),
+ promise_rejects_dom(t, 'InvalidStateError', device.controlTransferOut({
+ requestType: 'standard',
+ recipient: 'interface',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x0000,
+ })),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferOut(
+ {
+ requestType: 'standard',
+ recipient: 'interface',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x0000,
+ },
+ new Uint8Array([1, 2, 3]))),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferIn(
+ {
+ requestType: 'standard',
+ recipient: 'interface',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x0000
+ },
+ 0)),
+ promise_rejects_dom(t, 'InvalidStateError', device.close()),
+ ]);
+}, 'device operations reject if an device state change is in progress');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(() => promise_rejects_dom(t, 'NotFoundError', device.close()));
+ });
+}, 'close rejects when called on a disconnected device');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.selectConfiguration(1)));
+ });
+}, 'selectConfiguration rejects when called on a disconnected device');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device}) => Promise.all([
+ promise_rejects_dom(t, 'InvalidStateError', device.selectConfiguration(1)),
+ promise_rejects_dom(t, 'InvalidStateError', device.claimInterface(0)),
+ promise_rejects_dom(t, 'InvalidStateError', device.releaseInterface(0)),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.selectAlternateInterface(0, 1)),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferIn(
+ {
+ requestType: 'vendor',
+ recipient: 'device',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ },
+ 7)),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferOut(
+ {
+ requestType: 'vendor',
+ recipient: 'device',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ },
+ new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))),
+ promise_rejects_dom(t, 'InvalidStateError', device.clearHalt('in', 1)),
+ promise_rejects_dom(t, 'InvalidStateError', device.transferIn(1, 8)),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.transferOut(1, new ArrayBuffer(8))),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.isochronousTransferIn(1, [8])),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.isochronousTransferOut(1, new ArrayBuffer(8), [8])),
+ promise_rejects_dom(t, 'InvalidStateError', device.reset())
+ ]));
+}, 'methods requiring it reject when the device is not open');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ assert_equals(device.configuration, null);
+ return device.open()
+ .then(() => {
+ assert_equals(device.configuration, null);
+ return device.selectConfiguration(1);
+ })
+ .then(() => {
+ assertDeviceInfoEquals(
+ device.configuration, fakeDeviceInit.configurations[0]);
+ })
+ .then(() => device.close());
+ });
+}, '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((t) => {
+ return getFakeDevice().then(({ device }) => {
+ assert_equals(device.configuration, null);
+ return device.open()
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.selectConfiguration(10)))
+ .then(() => device.close());
+ });
+}, 'selectConfiguration rejects on invalid configurations');
+
+usb_test((t) => {
+ return getFakeDevice().then(({ device }) => {
+ assert_equals(device.configuration, null);
+ return device.open()
+ .then(() => Promise.all([
+ promise_rejects_dom(t, 'InvalidStateError', device.claimInterface(0)),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.releaseInterface(0)),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.selectAlternateInterface(0, 1)),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.clearHalt('in', 1)),
+ promise_rejects_dom(t, 'InvalidStateError', device.transferIn(1, 8)),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.transferOut(1, new ArrayBuffer(8))),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.isochronousTransferIn(1, [8])),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.isochronousTransferOut(1, new ArrayBuffer(8), [8])),
+ ]))
+ .then(() => device.close());
+ });
+}, 'methods requiring it reject when the device is unconfigured');
+
+usb_test(async () => {
+ let { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(1);
+ assert_false(device.configuration.interfaces[0].claimed);
+ assert_false(device.configuration.interfaces[1].claimed);
+
+ await device.claimInterface(0);
+ assert_true(device.configuration.interfaces[0].claimed);
+ assert_false(device.configuration.interfaces[1].claimed);
+
+ await device.claimInterface(1);
+ assert_true(device.configuration.interfaces[0].claimed);
+ assert_true(device.configuration.interfaces[1].claimed);
+
+ await device.releaseInterface(0);
+ assert_false(device.configuration.interfaces[0].claimed);
+ assert_true(device.configuration.interfaces[1].claimed);
+
+ await device.releaseInterface(1);
+ assert_false(device.configuration.interfaces[0].claimed);
+ assert_false(device.configuration.interfaces[1].claimed);
+
+ await device.close();
+}, 'interfaces can be claimed and released');
+
+usb_test(async () => {
+ let { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(1);
+ assert_false(device.configuration.interfaces[0].claimed);
+ assert_false(device.configuration.interfaces[1].claimed);
+
+ await Promise.all([device.claimInterface(0),
+ device.claimInterface(1)]);
+ assert_true(device.configuration.interfaces[0].claimed);
+ assert_true(device.configuration.interfaces[1].claimed);
+
+ await Promise.all([device.releaseInterface(0),
+ device.releaseInterface(1)]);
+ assert_false(device.configuration.interfaces[0].claimed);
+ assert_false(device.configuration.interfaces[1].claimed);
+
+ await device.close();
+}, 'interfaces can be claimed and released in parallel');
+
+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 (t) => {
+ let { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(1);
+ return Promise.all([
+ device.claimInterface(0),
+ promise_rejects_dom(t, 'InvalidStateError', device.claimInterface(0)),
+ promise_rejects_dom(t, 'InvalidStateError', device.releaseInterface(0)),
+ promise_rejects_dom(t, 'InvalidStateError', device.open()),
+ promise_rejects_dom(t, 'InvalidStateError', device.selectConfiguration(1)),
+ promise_rejects_dom(t, 'InvalidStateError', device.reset()),
+ promise_rejects_dom(
+ t, 'InvalidStateError', device.selectAlternateInterface(0, 0)),
+ promise_rejects_dom(t, 'InvalidStateError', device.controlTransferOut({
+ requestType: 'standard',
+ recipient: 'interface',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x0000,
+ })),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferOut(
+ {
+ requestType: 'standard',
+ recipient: 'interface',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x0000,
+ },
+ new Uint8Array([1, 2, 3]))),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferIn(
+ {
+ requestType: 'standard',
+ recipient: 'interface',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x0000
+ },
+ 0)),
+ promise_rejects_dom(t, 'InvalidStateError', 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((t) => {
+ return getFakeDevice().then(({device}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => Promise.all([
+ promise_rejects_dom(t, 'NotFoundError', device.claimInterface(2)),
+ promise_rejects_dom(t, 'NotFoundError', device.releaseInterface(2)),
+ ]))
+ .then(() => device.close());
+ });
+}, 'a non-existent interface cannot be claimed or released');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.claimInterface(0)));
+ });
+}, 'claimInterface rejects when called on a disconnected device');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(0))
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.releaseInterface(0)));
+ });
+}, 'releaseInterface rejects when called on a disconnected device');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(2))
+ .then(() => device.claimInterface(0))
+ .then(() => device.selectAlternateInterface(0, 1))
+ .then(() => device.close());
+ });
+}, 'can select an alternate interface');
+
+usb_test(
+ async () => {
+ const {device} = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(3);
+ await device.claimInterface(2);
+ await device.selectAlternateInterface(2, 0);
+ await device.close();
+ },
+ 'can select an alternate interface on a setting with non-sequential ' +
+ 'interface number');
+
+usb_test(
+ async () => {
+ const {device} = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(3);
+ await device.claimInterface(0);
+ await device.selectAlternateInterface(0, 2);
+ await device.close();
+ },
+ 'can select an alternate interface on a setting with non-sequential ' +
+ 'alternative setting value');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(2))
+ .then(() => device.claimInterface(0))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.selectAlternateInterface(0, 2)))
+ .then(() => device.close());
+ });
+}, 'cannot select a non-existent alternate interface');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(2))
+ .then(() => device.claimInterface(0))
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.selectAlternateInterface(0, 1)));
+ });
+}, 'selectAlternateInterface rejects when called on a disconnected 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: 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(async () => {
+ let { device } = await getFakeDevice();
+ let usbRequestTypes = ['standard', 'class', 'vendor'];
+ let usbRecipients = ['device', 'other'];
+ await device.open();
+ await Promise.all(usbRequestTypes.flatMap(requestType => {
+ return usbRecipients.map(async recipient => {
+ let result = await device.controlTransferIn({
+ requestType: requestType,
+ recipient: recipient,
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ }, 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), 0x5678);
+ });
+ }));
+ await device.close();
+}, 'device-scope IN control transfers don\'t require configuration');
+
+usb_test(async (t) => {
+ let { device } = await getFakeDevice();
+ let usbRequestTypes = ['standard', 'class', 'vendor'];
+ let usbRecipients = ['interface', 'endpoint'];
+ await device.open();
+ await Promise.all(usbRequestTypes.flatMap(requestType => {
+ return usbRecipients.map(recipient => {
+ let index = recipient === 'interface' ? 0x5600 : 0x5681;
+ return promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferIn(
+ {
+ requestType: requestType,
+ recipient: recipient,
+ request: 0x42,
+ value: 0x1234,
+ index: index
+ },
+ 7));
+ });
+ }));
+ await device.close();
+}, 'interface-scope IN control transfers require configuration');
+
+usb_test(async (t) => {
+ let { device } = await getFakeDevice();
+ let usbRequestTypes = ['standard', 'class', 'vendor'];
+ let usbRecipients = ['interface', 'endpoint'];
+ await device.open();
+ await device.selectConfiguration(1);
+ await Promise.all(usbRequestTypes.flatMap(requestType => {
+ return [
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferIn(
+ {
+ requestType: requestType,
+ recipient: 'interface',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5600
+ },
+ 7)),
+ promise_rejects_dom(
+ t, 'NotFoundError',
+ device.controlTransferIn(
+ {
+ requestType: requestType,
+ recipient: 'endpoint',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5681
+ },
+ 7))
+ ];
+ }));
+ await device.close();
+}, 'interface-scope IN control transfers require claiming the interface');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError',
+ device.controlTransferIn(
+ {
+ requestType: 'vendor',
+ recipient: 'device',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ },
+ 7)));
+ });
+}, 'controlTransferIn rejects when called on a disconnected 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: 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');
+ }
+ }
+ await device.close();
+}, 'can issue all types of OUT control transfers');
+
+usb_test(async () => {
+ let { device } = await getFakeDevice();
+ let usbRequestTypes = ['standard', 'class', 'vendor'];
+ let usbRecipients = ['device', 'other'];
+ let dataArray = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+ let dataTypes = [dataArray, dataArray.buffer];
+ await device.open();
+ await Promise.all(usbRequestTypes.flatMap(requestType => {
+ return usbRecipients.flatMap(recipient => {
+ let transferParams = {
+ requestType: requestType,
+ recipient: recipient,
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ };
+ return dataTypes.map(async data => {
+ let result = await device.controlTransferOut(transferParams, data);
+ assert_true(result instanceof USBOutTransferResult);
+ assert_equals(result.status, 'ok');
+ assert_equals(result.bytesWritten, 8);
+ }).push((async () => {
+ let result = await device.controlTransferOut(transferParams);
+ assert_true(result instanceof USBOutTransferResult);
+ assert_equals(result.status, 'ok');
+ })());
+ });
+ }));
+ await device.close();
+}, 'device-scope OUT control transfers don\'t require configuration');
+
+usb_test(async (t) => {
+ let { device } = await getFakeDevice();
+ let usbRequestTypes = ['standard', 'class', 'vendor'];
+ let usbRecipients = ['interface', 'endpoint'];
+ let dataArray = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+ let dataTypes = [dataArray, dataArray.buffer];
+ await device.open();
+ await Promise.all(usbRequestTypes.flatMap(requestType => {
+ return usbRecipients.flatMap(recipient => {
+ let index = recipient === 'interface' ? 0x5600 : 0x5681;
+ let transferParams = {
+ requestType: requestType,
+ recipient: recipient,
+ request: 0x42,
+ value: 0x1234,
+ index: index
+ };
+ return dataTypes
+ .map(data => {
+ return promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferOut(transferParams, data));
+ })
+ .push(promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferOut(transferParams)));
+ });
+ }));
+ await device.close();
+}, 'interface-scope OUT control transfers require configuration');
+
+usb_test(async (t) => {
+ let { device } = await getFakeDevice();
+ let usbRequestTypes = ['standard', 'class', 'vendor'];
+ let usbRecipients = ['interface', 'endpoint'];
+ 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 Promise.all(usbRequestTypes.flatMap(requestType => {
+ return usbRecipients.flatMap(recipient => {
+ let index = recipient === 'interface' ? 0x5600 : 0x5681;
+ let error =
+ recipient === 'interface' ? 'InvalidStateError' : 'NotFoundError';
+ let transferParams = {
+ requestType: requestType,
+ recipient: recipient,
+ request: 0x42,
+ value: 0x1234,
+ index: index
+ };
+ return dataTypes
+ .map(data => {
+ return promise_rejects_dom(
+ t, error, device.controlTransferOut(transferParams, data));
+ })
+ .push(promise_rejects_dom(
+ t, error, device.controlTransferOut(transferParams)));
+ });
+ }));
+ await device.close();
+}, 'interface-scope OUT control transfers an interface claim');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError',
+ device.controlTransferOut(
+ {
+ requestType: 'vendor',
+ recipient: 'device',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ },
+ new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))));
+ });
+}, 'controlTransferOut rejects when called on a disconnected device');
+
+usb_test(async (t) => {
+ let { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(1);
+ await device.claimInterface(0);
+ await Promise.all([
+ promise_rejects_js(
+ t, TypeError,
+ device.controlTransferOut(
+ {
+ requestType: 'invalid',
+ recipient: 'device',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ },
+ new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))),
+ promise_rejects_js(
+ t, TypeError,
+ 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 (t) => {
+ let { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(1);
+ await device.claimInterface(0);
+ await Promise.all([
+ promise_rejects_js(
+ t, TypeError,
+ device.controlTransferOut(
+ {
+ requestType: 'vendor',
+ recipient: 'invalid',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ },
+ new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))),
+ promise_rejects_js(
+ t, TypeError,
+ device.controlTransferIn(
+ {
+ requestType: 'vendor',
+ recipient: 'invalid',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5678
+ },
+ 0)),
+ ]);
+}, 'control transfers with a invalid recipient type reject');
+
+usb_test(async (t) => {
+ let { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(1);
+ await device.claimInterface(0);
+ await Promise.all([
+ promise_rejects_dom(
+ t, 'NotFoundError',
+ 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]))),
+ promise_rejects_dom(
+ t, 'NotFoundError',
+ 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((t) => {
+ return getFakeDevice().then(({ device }) => {
+ let interfaceRequest = {
+ requestType: 'vendor',
+ recipient: 'interface',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5600 // Last byte of index is interface number.
+ };
+ let endpointRequest = {
+ requestType: 'vendor',
+ recipient: 'endpoint',
+ request: 0x42,
+ value: 0x1234,
+ index: 0x5681 // Last byte of index is endpoint address.
+ };
+ let data = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => Promise.all([
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferIn(interfaceRequest, 7)),
+ promise_rejects_dom(
+ t, 'NotFoundError', device.controlTransferIn(endpointRequest, 7)),
+ promise_rejects_dom(
+ t, 'InvalidStateError',
+ device.controlTransferOut(interfaceRequest, data)),
+ promise_rejects_dom(
+ t, 'NotFoundError',
+ device.controlTransferOut(endpointRequest, data)),
+ ]))
+ .then(() => device.claimInterface(0))
+ .then(() => Promise.all([
+ device.controlTransferIn(interfaceRequest, 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), 0x5600);
+ }),
+ device.controlTransferIn(endpointRequest, 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), 0x5681);
+ }),
+ device.controlTransferOut(interfaceRequest, data),
+ device.controlTransferOut(endpointRequest, data),
+ ]))
+ .then(() => device.close());
+ });
+}, 'requests to interfaces and endpoint require an interface claim');
+
+usb_test(async () => {
+ const { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(1);
+ await device.claimInterface(0);
+
+ const transfer_params = {
+ requestType: 'vendor',
+ recipient: 'device',
+ request: 0,
+ value: 0,
+ index: 0
+ };
+
+ try {
+ const array_buffer = new ArrayBuffer(64 * 8);
+ const result =
+ await device.controlTransferOut(transfer_params, array_buffer);
+ assert_equals(result.status, 'ok');
+
+ detachBuffer(array_buffer);
+ await device.controlTransferOut(transfer_params, array_buffer);
+ assert_unreached();
+ } catch (e) {
+ assert_equals(e.code, DOMException.INVALID_STATE_ERR);
+ }
+
+ try {
+ const typed_array = new Uint8Array(64 * 8);
+ const result =
+ await device.controlTransferOut(transfer_params, typed_array);
+ assert_equals(result.status, 'ok');
+
+ detachBuffer(typed_array.buffer);
+ await device.controlTransferOut(transfer_params, typed_array);
+ assert_unreached();
+ } catch (e) {
+ assert_equals(e.code, DOMException.INVALID_STATE_ERR);
+ }
+}, 'controlTransferOut rejects if called with a detached buffer');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(0))
+ .then(() => device.clearHalt('in', 1))
+ .then(() => device.close());
+ });
+}, 'can clear a halt condition');
+
+usb_test((t) => {
+ return getFakeDevice(t).then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(0))
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.clearHalt('in', 1)));
+ });
+}, 'clearHalt rejects when called on a disconnected device');
+
+usb_test((t) => {
+ return getFakeDevice().then(({ device }) => {
+ let data = new DataView(new ArrayBuffer(1024));
+ for (let i = 0; i < 1024; ++i)
+ data.setUint8(i, i & 0xff);
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(0))
+ .then(() => Promise.all([
+ promise_rejects_dom(
+ t, 'NotFoundError', device.transferIn(2, 8)), // Unclaimed
+ promise_rejects_dom(
+ t, 'NotFoundError', device.transferIn(3, 8)), // Non-existent
+ promise_rejects_dom(t, 'IndexSizeError', device.transferIn(16, 8)),
+ promise_rejects_dom(
+ t, 'NotFoundError', device.transferOut(2, data)), // Unclaimed
+ promise_rejects_dom(
+ t, 'NotFoundError', device.transferOut(3, data)), // Non-existent
+ promise_rejects_dom(
+ t, 'IndexSizeError', device.transferOut(16, data)),
+ ]));
+ });
+}, 'transfers to unavailable endpoints are rejected');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(0))
+ .then(() => device.transferIn(1, 8))
+ .then(result => {
+ assert_true(result instanceof USBInTransferResult);
+ assert_equals(result.status, 'ok');
+ assert_equals(result.data.byteLength, 8);
+ for (let i = 0; i < 8; ++i)
+ assert_equals(result.data.getUint8(i), i, 'mismatch at byte ' + i);
+ return device.close();
+ });
+ });
+}, 'can issue IN interrupt transfer');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(1))
+ .then(() => device.transferIn(2, 1024))
+ .then(result => {
+ assert_true(result instanceof USBInTransferResult);
+ assert_equals(result.status, 'ok');
+ assert_equals(result.data.byteLength, 1024);
+ for (let i = 0; i < 1024; ++i)
+ assert_equals(result.data.getUint8(i), i & 0xff,
+ 'mismatch at byte ' + i);
+ return device.close();
+ });
+ });
+}, 'can issue IN bulk transfer');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(1))
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.transferIn(2, 1024)));
+ });
+}, 'transferIn rejects if called on a disconnected device');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(1))
+ .then(() => {
+ let data = new DataView(new ArrayBuffer(1024));
+ for (let i = 0; i < 1024; ++i)
+ data.setUint8(i, i & 0xff);
+ return device.transferOut(2, data);
+ })
+ .then(result => {
+ assert_true(result instanceof USBOutTransferResult);
+ assert_equals(result.status, 'ok');
+ assert_equals(result.bytesWritten, 1024);
+ return device.close();
+ });
+ });
+}, 'can issue OUT bulk transfer');
+
+usb_test((t) => {
+ return getFakeDevice().then(({ device, fakeDevice }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(1))
+ .then(() => device.claimInterface(1))
+ .then(() => {
+ let data = new DataView(new ArrayBuffer(1024));
+ for (let i = 0; i < 1024; ++i)
+ data.setUint8(i, i & 0xff);
+ return waitForDisconnect(fakeDevice)
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError', device.transferOut(2, data)));
+ });
+ });
+}, 'transferOut rejects if called on a disconnected device');
+
+usb_test(async () => {
+ const { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(1);
+ await device.claimInterface(1);
+
+
+ try {
+ const array_buffer = new ArrayBuffer(64 * 8);
+ const result = await device.transferOut(2, array_buffer);
+ assert_equals(result.status, 'ok');
+
+ detachBuffer(array_buffer);
+ await device.transferOut(2, array_buffer);
+ assert_unreached();
+ } catch (e) {
+ assert_equals(e.code, DOMException.INVALID_STATE_ERR);
+ }
+
+ try {
+ const typed_array = new Uint8Array(64 * 8);
+ const result = await device.transferOut(2, typed_array);
+ assert_equals(result.status, 'ok');
+
+ detachBuffer(typed_array.buffer);
+ await device.transferOut(2, typed_array);
+ assert_unreached();
+ } catch (e) {
+ assert_equals(e.code, DOMException.INVALID_STATE_ERR);
+ }
+}, 'transferOut rejects if called with a detached buffer');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(2))
+ .then(() => device.claimInterface(0))
+ .then(() => device.selectAlternateInterface(0, 1))
+ .then(() => device.isochronousTransferIn(
+ 1, [64, 64, 64, 64, 64, 64, 64, 64]))
+ .then(result => {
+ assert_true(result instanceof USBIsochronousInTransferResult);
+ assert_equals(result.data.byteLength, 64 * 8, 'buffer size');
+ assert_equals(result.packets.length, 8, 'number of packets');
+ let byteOffset = 0;
+ for (let i = 0; i < result.packets.length; ++i) {
+ assert_true(
+ result.packets[i] instanceof USBIsochronousInTransferPacket);
+ assert_equals(result.packets[i].status, 'ok');
+ assert_equals(result.packets[i].data.byteLength, 64);
+ assert_equals(result.packets[i].data.buffer, result.data.buffer);
+ assert_equals(result.packets[i].data.byteOffset, byteOffset);
+ for (let j = 0; j < 64; ++j)
+ assert_equals(result.packets[i].data.getUint8(j), j & 0xff,
+ 'mismatch at byte ' + j + ' of packet ' + i);
+ byteOffset += result.packets[i].data.byteLength;
+ }
+ return device.close();
+ });
+ });
+}, 'can issue IN isochronous transfer');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => device.selectConfiguration(2))
+ .then(() => device.claimInterface(0))
+ .then(() => device.selectAlternateInterface(0, 1))
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError',
+ device.isochronousTransferIn(
+ 1, [64, 64, 64, 64, 64, 64, 64, 64])));
+ });
+}, 'isochronousTransferIn rejects when called on a disconnected device');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(2))
+ .then(() => device.claimInterface(0))
+ .then(() => device.selectAlternateInterface(0, 1))
+ .then(() => {
+ let data = new DataView(new ArrayBuffer(64 * 8));
+ for (let i = 0; i < 8; ++i) {
+ for (let j = 0; j < 64; ++j)
+ data.setUint8(i * j, j & 0xff);
+ }
+ return device.isochronousTransferOut(
+ 1, data, [64, 64, 64, 64, 64, 64, 64, 64]);
+ })
+ .then(result => {
+ assert_true(result instanceof USBIsochronousOutTransferResult);
+ assert_equals(result.packets.length, 8, 'number of packets');
+ let byteOffset = 0;
+ for (let i = 0; i < result.packets.length; ++i) {
+ assert_true(
+ result.packets[i] instanceof USBIsochronousOutTransferPacket);
+ assert_equals(result.packets[i].status, 'ok');
+ assert_equals(result.packets[i].bytesWritten, 64);
+ }
+ return device.close();
+ });
+ });
+}, 'can issue OUT isochronous transfer');
+
+usb_test((t) => {
+ return getFakeDevice().then(({ device, fakeDevice }) => {
+ return device.open()
+ .then(() => device.selectConfiguration(2))
+ .then(() => device.claimInterface(0))
+ .then(() => device.selectAlternateInterface(0, 1))
+ .then(() => {
+ let data = new DataView(new ArrayBuffer(64 * 8));
+ for (let i = 0; i < 8; ++i) {
+ for (let j = 0; j < 64; ++j)
+ data.setUint8(i * j, j & 0xff);
+ }
+ return waitForDisconnect(fakeDevice)
+ .then(
+ () => promise_rejects_dom(
+ t, 'NotFoundError',
+ device.isochronousTransferOut(
+ 1, data, [64, 64, 64, 64, 64, 64, 64, 64])));
+ });
+ });
+}, 'isochronousTransferOut rejects when called on a disconnected device');
+
+usb_test(async () => {
+ const { device } = await getFakeDevice();
+ await device.open();
+ await device.selectConfiguration(2);
+ await device.claimInterface(0);
+ await device.selectAlternateInterface(0, 1);
+
+
+ try {
+ const array_buffer = new ArrayBuffer(64 * 8);
+ const result = await device.isochronousTransferOut(
+ 1, array_buffer, [64, 64, 64, 64, 64, 64, 64, 64]);
+ for (let i = 0; i < result.packets.length; ++i)
+ assert_equals(result.packets[i].status, 'ok');
+
+ detachBuffer(array_buffer);
+ await device.isochronousTransferOut(
+ 1, array_buffer, [64, 64, 64, 64, 64, 64, 64, 64]);
+ assert_unreached();
+ } catch (e) {
+ assert_equals(e.code, DOMException.INVALID_STATE_ERR);
+ }
+
+ try {
+ const typed_array = new Uint8Array(64 * 8);
+ const result = await device.isochronousTransferOut(
+ 1, typed_array, [64, 64, 64, 64, 64, 64, 64, 64]);
+ for (let i = 0; i < result.packets.length; ++i)
+ assert_equals(result.packets[i].status, 'ok');
+
+ detachBuffer(typed_array.buffer);
+ await device.isochronousTransferOut(
+ 1, typed_array, [64, 64, 64, 64, 64, 64, 64, 64]);
+ assert_unreached();
+ } catch (e) {
+ assert_equals(e.code, DOMException.INVALID_STATE_ERR);
+ }
+}, 'isochronousTransferOut rejects when called with a detached buffer');
+
+usb_test(() => {
+ return getFakeDevice().then(({ device }) => {
+ return device.open().then(() => device.reset()).then(() => device.close());
+ });
+}, 'can reset the device');
+
+usb_test((t) => {
+ return getFakeDevice().then(({device, fakeDevice}) => {
+ return device.open()
+ .then(() => waitForDisconnect(fakeDevice))
+ .then(() => promise_rejects_dom(t, 'NotFoundError', device.reset()));
+ });
+}, 'resetDevice rejects when called on a disconnected device');