| OLD | NEW |
|---|
| (Empty) | |
| 1 <!DOCTYPE html> |
| 2 <script src="../resources/testharness.js"></script> |
| 3 <script src="../resources/testharnessreport.js"></script> |
| 4 <script src="../resources/mojo-helpers.js"></script> |
| 5 <script src="resources/fake-devices.js"></script> |
| 6 <script src="resources/usb-helpers.js"></script> |
| 7 <script> |
| 8 'use strict'; |
| 9 |
| 10 usb_test(usb => { |
| 11 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 12 return navigator.usb.getDevices().then(devices => { |
| 13 assert_equals(1, devices.length); |
| 14 let device = devices[0]; |
| 15 return device.open().then(() => device.close()); |
| 16 }); |
| 17 }, 'a device can be opened and closed'); |
| 18 |
| 19 usb_test(usb => { |
| 20 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 21 return navigator.usb.getDevices().then(devices => { |
| 22 assert_equals(1, devices.length); |
| 23 let device = devices[0]; |
| 24 return device.open() |
| 25 .then(() => device.setConfiguration(1)) |
| 26 .then(() => device.getConfiguration()) |
| 27 .then(config => { |
| 28 usb.assertConfigurationInfoEquals( |
| 29 config, usb.fakeDevices[0].configurations[0]); |
| 30 }) |
| 31 .then(() => device.close()); |
| 32 }); |
| 33 }, 'device configuration can be set and queried'); |
| 34 |
| 35 usb_test(usb => { |
| 36 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 37 return navigator.usb.getDevices().then(devices => { |
| 38 assert_equals(devices.length, 1); |
| 39 let device = devices[0]; |
| 40 return device.open() |
| 41 .then(() => device.getConfiguration() |
| 42 .then(() => { |
| 43 assert_unreached('getConfiguration should reject'); |
| 44 }) |
| 45 .catch(error => { |
| 46 assert_equals(error.code, DOMException.NOT_FOUND_ERR); |
| 47 return Promise.resolve(); |
| 48 })) |
| 49 .then(() => device.close()); |
| 50 }); |
| 51 }, 'querying an unset configuration raises NotFoundError'); |
| 52 |
| 53 usb_test(usb => { |
| 54 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 55 return navigator.usb.getDevices().then(devices => { |
| 56 assert_equals(1, devices.length); |
| 57 let device = devices[0]; |
| 58 return device.open() |
| 59 .then(() => device.setConfiguration(1)) |
| 60 .then(() => device.claimInterface(0)) |
| 61 .then(() => device.releaseInterface(0)) |
| 62 .then(() => device.close()); |
| 63 }); |
| 64 }, 'an interface can be claimed and released'); |
| 65 |
| 66 usb_test(usb => { |
| 67 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 68 return navigator.usb.getDevices().then(devices => { |
| 69 assert_equals(1, devices.length); |
| 70 let device = devices[0]; |
| 71 return device.open() |
| 72 .then(() => device.claimInterface(0) |
| 73 .then(() => { |
| 74 assert_unreached('claimInterface should reject'); |
| 75 }) |
| 76 .catch(error => { |
| 77 // TODO(reillyg): This should be INVALID_STATE_ERR. |
| 78 assert_equals(error.code, DOMException.NETWORK_ERR); |
| 79 return Promise.resolve(); |
| 80 })) |
| 81 .then(() => device.close()); |
| 82 }); |
| 83 }, 'claiming an interface fails without an active configuration'); |
| 84 |
| 85 usb_test(usb => { |
| 86 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 87 return navigator.usb.getDevices().then(devices => { |
| 88 assert_equals(1, devices.length); |
| 89 let device = devices[0]; |
| 90 return device.open() |
| 91 .then(() => device.setConfiguration(2)) |
| 92 .then(() => device.claimInterface(0)) |
| 93 .then(() => device.setInterface(0, 1)) |
| 94 .then(() => device.close()); |
| 95 }); |
| 96 }, 'can select an alternate interface'); |
| 97 |
| 98 usb_test(usb => { |
| 99 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 100 return navigator.usb.getDevices().then(devices => { |
| 101 assert_equals(1, devices.length); |
| 102 let device = devices[0]; |
| 103 return device.open() |
| 104 .then(() => device.controlTransferIn({ |
| 105 requestType: 'vendor', |
| 106 recipient: 'device', |
| 107 request: 0x42, |
| 108 value: 0x1234, |
| 109 index: 0x5678 |
| 110 }, 7)) |
| 111 .then(result => { |
| 112 assert_true(result instanceof USBInTransferResult); |
| 113 assert_equals(result.status, 'ok'); |
| 114 assert_equals(result.data.byteLength, 7); |
| 115 assert_equals(result.data.getUint16(0), 0x07); |
| 116 assert_equals(result.data.getUint8(2), 0x42); |
| 117 assert_equals(result.data.getUint16(3), 0x1234); |
| 118 assert_equals(result.data.getUint16(5), 0x5678); |
| 119 return device.close(); |
| 120 }); |
| 121 }); |
| 122 }, 'can issue IN control transfer'); |
| 123 |
| 124 usb_test(usb => { |
| 125 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 126 return navigator.usb.getDevices().then(devices => { |
| 127 assert_equals(1, devices.length); |
| 128 let device = devices[0]; |
| 129 return device.open() |
| 130 .then(() => device.controlTransferOut({ |
| 131 requestType: 'vendor', |
| 132 recipient: 'device', |
| 133 request: 0x42, |
| 134 value: 0x1234, |
| 135 index: 0x5678 |
| 136 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))) |
| 137 .then(result => { |
| 138 assert_true(result instanceof USBOutTransferResult); |
| 139 assert_equals(result.status, 'ok'); |
| 140 assert_equals(result.bytesWritten, 8); |
| 141 return device.close(); |
| 142 }) |
| 143 }); |
| 144 }, 'can issue OUT control transfer'); |
| 145 |
| 146 usb_test(usb => { |
| 147 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 148 return navigator.usb.getDevices().then(devices => { |
| 149 assert_equals(devices.length, 1); |
| 150 let device = devices[0]; |
| 151 return device.open() |
| 152 .then(() => device.setConfiguration(1)) |
| 153 .then(() => device.claimInterface(0)) |
| 154 .then(() => device.clearHalt(1)) |
| 155 .then(() => device.close()); |
| 156 }); |
| 157 }, 'can clear a halt condition'); |
| 158 |
| 159 usb_test(usb => { |
| 160 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 161 return navigator.usb.getDevices().then(devices => { |
| 162 assert_equals(devices.length, 1); |
| 163 let device = devices[0]; |
| 164 return device.open() |
| 165 .then(() => device.setConfiguration(1)) |
| 166 .then(() => device.claimInterface(0)) |
| 167 .then(() => device.transferIn(1, 8)) |
| 168 .then(result => { |
| 169 assert_true(result instanceof USBInTransferResult); |
| 170 assert_equals(result.status, 'ok'); |
| 171 assert_equals(result.data.byteLength, 8); |
| 172 for (let i = 0; i < 8; ++i) |
| 173 assert_equals(result.data.getUint8(i), i, 'mismatch at byte ' + i); |
| 174 return device.close(); |
| 175 }); |
| 176 }); |
| 177 }, 'can issue IN interrupt transfer'); |
| 178 |
| 179 usb_test(usb => { |
| 180 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 181 return navigator.usb.getDevices().then(devices => { |
| 182 assert_equals(devices.length, 1); |
| 183 let device = devices[0]; |
| 184 return device.open() |
| 185 .then(() => device.setConfiguration(1)) |
| 186 .then(() => device.claimInterface(1)) |
| 187 .then(() => device.transferIn(2, 1024)) |
| 188 .then(result => { |
| 189 assert_true(result instanceof USBInTransferResult); |
| 190 assert_equals(result.status, 'ok'); |
| 191 assert_equals(result.data.byteLength, 1024); |
| 192 for (let i = 0; i < 1024; ++i) |
| 193 assert_equals(result.data.getUint8(i), i & 0xff, |
| 194 'mismatch at byte ' + i); |
| 195 return device.close(); |
| 196 }); |
| 197 }); |
| 198 }, 'can issue IN bulk transfer'); |
| 199 |
| 200 usb_test(usb => { |
| 201 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 202 return navigator.usb.getDevices().then(devices => { |
| 203 assert_equals(devices.length, 1); |
| 204 let device = devices[0]; |
| 205 return device.open() |
| 206 .then(() => device.setConfiguration(1)) |
| 207 .then(() => device.claimInterface(1)) |
| 208 .then(() => { |
| 209 let data = new DataView(new ArrayBuffer(1024)); |
| 210 for (let i = 0; i < 1024; ++i) |
| 211 data.setUint8(i, i & 0xff); |
| 212 return device.transferOut(2, data); |
| 213 }) |
| 214 .then(result => { |
| 215 assert_true(result instanceof USBOutTransferResult); |
| 216 assert_equals(result.status, 'ok'); |
| 217 assert_equals(result.bytesWritten, 1024); |
| 218 return device.close(); |
| 219 }); |
| 220 }); |
| 221 }, 'can issue OUT bulk transfer'); |
| 222 |
| 223 usb_test(usb => { |
| 224 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 225 return navigator.usb.getDevices().then(devices => { |
| 226 assert_equals(devices.length, 1); |
| 227 let device = devices[0]; |
| 228 return device.open() |
| 229 .then(() => device.setConfiguration(2)) |
| 230 .then(() => device.claimInterface(0)) |
| 231 .then(() => device.setInterface(0, 1)) |
| 232 .then(() => device.isochronousTransferIn( |
| 233 1, [64, 64, 64, 64, 64, 64, 64, 64])) |
| 234 .then(result => { |
| 235 assert_true(result instanceof USBIsochronousInTransferResult); |
| 236 assert_equals(result.data.byteLength, 64 * 8, 'buffer size'); |
| 237 assert_equals(result.packets.length, 8, 'number of packets'); |
| 238 let byteOffset = 0; |
| 239 for (let i = 0; i < result.packets.length; ++i) { |
| 240 assert_true( |
| 241 result.packets[i] instanceof USBIsochronousInTransferPacket); |
| 242 assert_equals(result.packets[i].status, 'ok'); |
| 243 assert_equals(result.packets[i].data.byteLength, 64); |
| 244 assert_equals(result.packets[i].data.buffer, result.data.buffer); |
| 245 assert_equals(result.packets[i].data.byteOffset, byteOffset); |
| 246 for (let j = 0; j < 64; ++j) |
| 247 assert_equals(result.packets[i].data.getUint8(j), j & 0xff, |
| 248 'mismatch at byte ' + j + ' of packet ' + i); |
| 249 byteOffset += result.packets[i].data.byteLength; |
| 250 } |
| 251 return device.close(); |
| 252 }); |
| 253 }); |
| 254 }, 'can issue IN isochronous transfer'); |
| 255 |
| 256 usb_test(usb => { |
| 257 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 258 return navigator.usb.getDevices().then(devices => { |
| 259 assert_equals(devices.length, 1); |
| 260 let device = devices[0]; |
| 261 return device.open() |
| 262 .then(() => device.setConfiguration(2)) |
| 263 .then(() => device.claimInterface(0)) |
| 264 .then(() => device.setInterface(0, 1)) |
| 265 .then(() => { |
| 266 let data = new DataView(new ArrayBuffer(64 * 8)); |
| 267 for (let i = 0; i < 8; ++i) { |
| 268 for (let j = 0; j < 64; ++j) |
| 269 data.setUint8(i * j, j & 0xff); |
| 270 } |
| 271 return device.isochronousTransferOut( |
| 272 1, data, [64, 64, 64, 64, 64, 64, 64, 64]); |
| 273 }) |
| 274 .then(result => { |
| 275 assert_true(result instanceof USBIsochronousOutTransferResult); |
| 276 assert_equals(result.packets.length, 8, 'number of packets'); |
| 277 let byteOffset = 0; |
| 278 for (let i = 0; i < result.packets.length; ++i) { |
| 279 assert_true( |
| 280 result.packets[i] instanceof USBIsochronousOutTransferPacket); |
| 281 assert_equals(result.packets[i].status, 'ok'); |
| 282 assert_equals(result.packets[i].bytesWritten, 64); |
| 283 } |
| 284 return device.close(); |
| 285 }); |
| 286 }); |
| 287 }, 'can issue OUT isochronous transfer'); |
| 288 |
| 289 usb_test(usb => { |
| 290 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); |
| 291 return navigator.usb.getDevices().then(devices => { |
| 292 assert_equals(1, devices.length); |
| 293 let device = devices[0]; |
| 294 return device.open().then(() => device.reset()).then(() => device.close()); |
| 295 }); |
| 296 }, 'can reset the device'); |
| 297 </script> |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1730403006:
Basic layout tests for WebUSB. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master