Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(57)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/WebKit/LayoutTests/usb/usbDevice.html

Issue 1784733002: Track USB device configuration state in Blink. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@blink_open_state
Patch Set: Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/WebKit/LayoutTests/usb/resources/usb-helpers.js ('k') | third_party/WebKit/LayoutTests/webexposed/global-interface-listing-expected.txt » ('j') | third_party/WebKit/Source/modules/webusb/USBDevice.cpp » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 <!DOCTYPE html> 1 <!DOCTYPE html>
2 <script src="../resources/testharness.js"></script> 2 <script src="../resources/testharness.js"></script>
3 <script src="../resources/testharnessreport.js"></script> 3 <script src="../resources/testharnessreport.js"></script>
4 <script src="../resources/mojo-helpers.js"></script> 4 <script src="../resources/mojo-helpers.js"></script>
5 <script src="resources/fake-devices.js"></script> 5 <script src="resources/fake-devices.js"></script>
6 <script src="resources/usb-helpers.js"></script> 6 <script src="resources/usb-helpers.js"></script>
7 <script> 7 <script>
8 'use strict'; 8 'use strict';
9 9
10 function assertRejectsWithError(promise, name, message) { 10 function assertRejectsWithError(promise, name, message) {
11 return promise.then(() => { 11 return promise.then(() => {
12 assert_unreached('expected promise to reject with ' + name); 12 assert_unreached('expected promise to reject with ' + name);
13 }, error => { 13 }, error => {
14 assert_equals(error.name, name); 14 assert_equals(error.name, name);
15 if (message !== undefined) 15 if (message !== undefined)
16 assert_equals(error.message, message); 16 assert_equals(error.message, message);
17 }); 17 });
18 } 18 }
19 19
20 function assertRejectsWithNotFoundError(promise) { 20 function assertRejectsWithNotFoundError(promise) {
21 return assertRejectsWithError(promise, 'NotFoundError'); 21 return assertRejectsWithError(promise, 'NotFoundError');
22 } 22 }
23 23
24 function assertRejectsWithNotOpenError(promise) { 24 function assertRejectsWithNotOpenError(promise) {
25 return assertRejectsWithError( 25 return assertRejectsWithError(
26 promise, 'InvalidStateError', 'The device must be open()ed first.') 26 promise, 'InvalidStateError', 'The device must be opened first.')
27 }
28
29 function assertRejectsWithNotConfiguredError(promise) {
30 return assertRejectsWithError(
31 promise, 'InvalidStateError',
32 'The device must have a configuration selected.');
27 } 33 }
28 34
29 usb_test(usb => { 35 usb_test(usb => {
30 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 36 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
31 return navigator.usb.getDevices().then(devices => { 37 return navigator.usb.getDevices().then(devices => {
32 assert_equals(1, devices.length); 38 assert_equals(1, devices.length);
33 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 39 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
34 return assertRejectsWithNotFoundError(devices[0].open()); 40 return assertRejectsWithNotFoundError(devices[0].open());
35 }); 41 });
36 }, 'open rejects when called on a disconnected device'); 42 }, 'open rejects when called on a disconnected device');
(...skipping 27 matching lines...) Expand all
64 .then(() => device.close()) 70 .then(() => device.close())
65 .then(() => device.close()); 71 .then(() => device.close());
66 }); 72 });
67 }, 'open and close can be called multiple times'); 73 }, 'open and close can be called multiple times');
68 74
69 usb_test(usb => { 75 usb_test(usb => {
70 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 76 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
71 return navigator.usb.getDevices().then(devices => { 77 return navigator.usb.getDevices().then(devices => {
72 assert_equals(1, devices.length); 78 assert_equals(1, devices.length);
73 let device = devices[0]; 79 let device = devices[0];
80 const message =
81 'An operation that changes the device state is in progress.';
74 return Promise.all([ 82 return Promise.all([
75 device.open(), 83 device.open(),
76 assertRejectsWithError(device.open(), 'InvalidStateError', 84 assertRejectsWithError(device.open(), 'InvalidStateError', message),
77 'An open() or close() task is in progress.'), 85 assertRejectsWithError(device.close(), 'InvalidStateError', message),
78 assertRejectsWithError(device.close(), 'InvalidStateError',
79 'An open() or close() task is in progress.'),
80 ]).then(() => Promise.all([ 86 ]).then(() => Promise.all([
81 device.close(), 87 device.close(),
82 assertRejectsWithError(device.open(), 'InvalidStateError', 88 assertRejectsWithError(device.open(), 'InvalidStateError', message),
83 'An open() or close() task is in progress.'), 89 assertRejectsWithError(device.close(), 'InvalidStateError', message),
84 assertRejectsWithError(device.close(), 'InvalidStateError',
85 'An open() or close() task is in progress.'),
86 ])); 90 ]));
87 }); 91 });
88 }, 'open and close cannot be called again while open or close are in progress'); 92 }, 'open and close cannot be called again while open or close are in progress');
89 93
90 usb_test(usb => { 94 usb_test(usb => {
91 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 95 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
92 return navigator.usb.getDevices().then(devices => { 96 return navigator.usb.getDevices().then(devices => {
93 assert_equals(1, devices.length); 97 assert_equals(1, devices.length);
94 let device = devices[0]; 98 let device = devices[0];
95 return device.open().then(() => { 99 return device.open().then(() => {
96 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 100 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
97 return assertRejectsWithNotFoundError(device.close()); 101 return assertRejectsWithNotFoundError(device.close());
98 }); 102 });
99 }); 103 });
100 }, 'close rejects when called on a disconnected device'); 104 }, 'close rejects when called on a disconnected device');
101 105
102 usb_test(usb => { 106 usb_test(usb => {
103 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 107 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
104 return navigator.usb.getDevices().then(devices => { 108 return navigator.usb.getDevices().then(devices => {
105 assert_equals(1, devices.length); 109 assert_equals(1, devices.length);
106 var device = devices[0]; 110 var device = devices[0];
107 return device.open() 111 return device.open()
108 .then(() => { 112 .then(() => {
109 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 113 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
110 return assertRejectsWithNotFoundError(device.setConfiguration(1)); 114 return assertRejectsWithNotFoundError(device.selectConfiguration(1));
111 }); 115 });
112 }); 116 });
113 }, 'setConfiguration rejects when called on a disconnected device'); 117 }, 'selectConfiguration rejects when called on a disconnected device');
114 118
115 usb_test(usb => { 119 usb_test(usb => {
116 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 120 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
117 return navigator.usb.getDevices().then(devices => { 121 return navigator.usb.getDevices().then(devices => {
118 assert_equals(1, devices.length); 122 assert_equals(1, devices.length);
119 var device = devices[0]; 123 var device = devices[0];
120 return Promise.all([ 124 return Promise.all([
121 assertRejectsWithNotOpenError(device.setConfiguration(1)), 125 assertRejectsWithNotOpenError(device.selectConfiguration(1)),
122 assertRejectsWithNotOpenError(device.claimInterface(0)), 126 assertRejectsWithNotOpenError(device.claimInterface(0)),
123 assertRejectsWithNotOpenError(device.releaseInterface(0)), 127 assertRejectsWithNotOpenError(device.releaseInterface(0)),
124 assertRejectsWithNotOpenError(device.setInterface(0, 1)), 128 assertRejectsWithNotOpenError(device.setInterface(0, 1)),
125 assertRejectsWithNotOpenError(device.controlTransferIn({ 129 assertRejectsWithNotOpenError(device.controlTransferIn({
126 requestType: 'vendor', 130 requestType: 'vendor',
127 recipient: 'device', 131 recipient: 'device',
128 request: 0x42, 132 request: 0x42,
129 value: 0x1234, 133 value: 0x1234,
130 index: 0x5678 134 index: 0x5678
131 }, 7)), 135 }, 7)),
(...skipping 14 matching lines...) Expand all
146 assertRejectsWithNotOpenError(device.reset()) 150 assertRejectsWithNotOpenError(device.reset())
147 ]); 151 ]);
148 }); 152 });
149 }, 'methods requiring it reject when the device is not open'); 153 }, 'methods requiring it reject when the device is not open');
150 154
151 usb_test(usb => { 155 usb_test(usb => {
152 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 156 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
153 return navigator.usb.getDevices().then(devices => { 157 return navigator.usb.getDevices().then(devices => {
154 assert_equals(1, devices.length); 158 assert_equals(1, devices.length);
155 let device = devices[0]; 159 let device = devices[0];
160 assert_equals(device.configuration, null);
156 return device.open() 161 return device.open()
157 .then(() => device.setConfiguration(1)) 162 .then(() => {
158 .then(() => device.getConfiguration()) 163 assert_equals(device.configuration, null);
159 .then(config => { 164 return device.selectConfiguration(1);
160 usb.assertConfigurationInfoEquals( 165 })
161 config, usb.fakeDevices[0].configurations[0]); 166 .then(() => {
167 usb.assertConfigurationInfoEquals(
168 device.configuration, usb.fakeDevices[0].configurations[0]);
162 }) 169 })
163 .then(() => device.close()); 170 .then(() => device.close());
164 }); 171 });
165 }, 'device configuration can be set and queried'); 172 }, 'device configuration can be set and queried');
166 173
167 usb_test(usb => { 174 usb_test(usb => {
168 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 175 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
169 return navigator.usb.getDevices().then(devices => { 176 return navigator.usb.getDevices().then(devices => {
170 assert_equals(1, devices.length); 177 assert_equals(1, devices.length);
171 var device = devices[0]; 178 let device = devices[0];
172 return device.open() 179 assert_equals(device.configuration, null);
173 .then(() => device.setConfiguration(1)) 180 return device.open().then(() => Promise.all([
174 .then(() => device.getConfiguration()) 181 assertRejectsWithNotConfiguredError(device.claimInterface(0)),
175 .then(config => { 182 assertRejectsWithNotConfiguredError(device.releaseInterface(0)),
176 usb.assertConfigurationInfoEquals( 183 assertRejectsWithNotConfiguredError(device.setInterface(0, 1)),
177 config, usb.fakeDevices[0].configurations[0]); 184 assertRejectsWithNotConfiguredError(device.controlTransferIn({
178 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 185 requestType: 'vendor',
179 return assertRejectsWithNotFoundError(device.getConfiguration()); 186 recipient: 'device',
180 }); 187 request: 0x42,
188 value: 0x1234,
189 index: 0x5678
190 }, 7)),
191 assertRejectsWithNotConfiguredError(device.controlTransferOut({
192 requestType: 'vendor',
193 recipient: 'device',
194 request: 0x42,
195 value: 0x1234,
196 index: 0x5678
197 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))),
198 assertRejectsWithNotConfiguredError(device.clearHalt(1)),
199 assertRejectsWithNotConfiguredError(device.transferIn(1, 8)),
200 assertRejectsWithNotConfiguredError(
201 device.transferOut(1, new ArrayBuffer(8))),
202 assertRejectsWithNotConfiguredError(
203 device.isochronousTransferIn(1, [8])),
204 assertRejectsWithNotConfiguredError(
205 device.isochronousTransferOut(1, new ArrayBuffer(8), [8])),
206 ])).then(() => device.close());
181 }); 207 });
182 }, 'getConfiguration rejects when called on a disconnected device'); 208 }, 'methods requiring it reject when the device is unconfigured');
183 209
184 usb_test(usb => { 210 usb_test(usb => {
185 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 211 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
186 return navigator.usb.getDevices().then(devices => {
187 assert_equals(devices.length, 1);
188 let device = devices[0];
189 return device.open()
190 .then(() =>
191 assertRejectsWithError(device.getConfiguration(), 'NotFoundError'))
192 .then(() => device.close());
193 });
194 }, 'querying an unset configuration raises NotFoundError');
195
196 usb_test(usb => {
197 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
198 return navigator.usb.getDevices().then(devices => { 212 return navigator.usb.getDevices().then(devices => {
199 assert_equals(1, devices.length); 213 assert_equals(1, devices.length);
200 let device = devices[0]; 214 let device = devices[0];
201 return device.open() 215 return device.open()
202 .then(() => device.setConfiguration(1)) 216 .then(() => device.selectConfiguration(1))
203 .then(() => device.claimInterface(0)) 217 .then(() => device.claimInterface(0))
204 .then(() => device.releaseInterface(0)) 218 .then(() => device.releaseInterface(0))
205 .then(() => device.close()); 219 .then(() => device.close());
206 }); 220 });
207 }, 'an interface can be claimed and released'); 221 }, 'an interface can be claimed and released');
208 222
209 usb_test(usb => { 223 usb_test(usb => {
210 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 224 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
211 return navigator.usb.getDevices().then(devices => { 225 return navigator.usb.getDevices().then(devices => {
212 assert_equals(1, devices.length); 226 assert_equals(1, devices.length);
213 let device = devices[0];
214 return device.open()
215 .then(() =>
216 // TODO(reillyg): This should be INVALID_STATE_ERR.
217 assertRejectsWithError(device.claimInterface(0), 'NetworkError'))
218 .then(() => device.close());
219 });
220 }, 'claiming an interface fails without an active configuration');
221
222 usb_test(usb => {
223 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
224 return navigator.usb.getDevices().then(devices => {
225 assert_equals(1, devices.length);
226 var device = devices[0]; 227 var device = devices[0];
227 return device.open() 228 return device.open()
228 .then(() => device.setConfiguration(1)) 229 .then(() => device.selectConfiguration(1))
229 .then(() => { 230 .then(() => {
230 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 231 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
231 return assertRejectsWithNotFoundError(device.claimInterface(0)); 232 return assertRejectsWithNotFoundError(device.claimInterface(0));
232 }); 233 });
233 }); 234 });
234 }, 'claimInterface rejects when called on a disconnected device'); 235 }, 'claimInterface rejects when called on a disconnected device');
235 236
236 usb_test(usb => { 237 usb_test(usb => {
237 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 238 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
238 return navigator.usb.getDevices().then(devices => { 239 return navigator.usb.getDevices().then(devices => {
239 assert_equals(1, devices.length); 240 assert_equals(1, devices.length);
240 var device = devices[0]; 241 var device = devices[0];
241 return device.open() 242 return device.open()
242 .then(() => device.setConfiguration(1)) 243 .then(() => device.selectConfiguration(1))
243 .then(() => device.claimInterface(0)) 244 .then(() => device.claimInterface(0))
244 .then(() => { 245 .then(() => {
245 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 246 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
246 return assertRejectsWithNotFoundError(device.releaseInterface(0)); 247 return assertRejectsWithNotFoundError(device.releaseInterface(0));
247 }); 248 });
248 }); 249 });
249 }, 'releaseInterface rejects when called on a disconnected device'); 250 }, 'releaseInterface rejects when called on a disconnected device');
250 251
251 usb_test(usb => { 252 usb_test(usb => {
252 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 253 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
253 return navigator.usb.getDevices().then(devices => { 254 return navigator.usb.getDevices().then(devices => {
254 assert_equals(1, devices.length); 255 assert_equals(1, devices.length);
255 let device = devices[0]; 256 let device = devices[0];
256 return device.open() 257 return device.open()
257 .then(() => device.setConfiguration(2)) 258 .then(() => device.selectConfiguration(2))
258 .then(() => device.claimInterface(0)) 259 .then(() => device.claimInterface(0))
259 .then(() => device.setInterface(0, 1)) 260 .then(() => device.setInterface(0, 1))
260 .then(() => device.close()); 261 .then(() => device.close());
261 }); 262 });
262 }, 'can select an alternate interface'); 263 }, 'can select an alternate interface');
263 264
264 usb_test(usb => { 265 usb_test(usb => {
265 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 266 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
266 return navigator.usb.getDevices().then(devices => { 267 return navigator.usb.getDevices().then(devices => {
267 assert_equals(1, devices.length); 268 assert_equals(1, devices.length);
268 var device = devices[0]; 269 var device = devices[0];
269 return device.open() 270 return device.open()
270 .then(() => device.setConfiguration(2)) 271 .then(() => device.selectConfiguration(2))
271 .then(() => device.claimInterface(0)) 272 .then(() => device.claimInterface(0))
272 .then(() => { 273 .then(() => {
273 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 274 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
274 return assertRejectsWithNotFoundError(device.setInterface(0, 1)); 275 return assertRejectsWithNotFoundError(device.setInterface(0, 1));
275 }); 276 });
276 }); 277 });
277 }, 'setInterface rejects when called on a disconnected device'); 278 }, 'setInterface rejects when called on a disconnected device');
278 279
279 usb_test(usb => { 280 usb_test(usb => {
280 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 281 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
281 return navigator.usb.getDevices().then(devices => { 282 return navigator.usb.getDevices().then(devices => {
282 assert_equals(1, devices.length); 283 assert_equals(1, devices.length);
283 let device = devices[0]; 284 let device = devices[0];
284 return device.open() 285 return device.open()
286 .then(() => device.selectConfiguration(1))
285 .then(() => device.controlTransferIn({ 287 .then(() => device.controlTransferIn({
286 requestType: 'vendor', 288 requestType: 'vendor',
287 recipient: 'device', 289 recipient: 'device',
288 request: 0x42, 290 request: 0x42,
289 value: 0x1234, 291 value: 0x1234,
290 index: 0x5678 292 index: 0x5678
291 }, 7)) 293 }, 7))
292 .then(result => { 294 .then(result => {
293 assert_true(result instanceof USBInTransferResult); 295 assert_true(result instanceof USBInTransferResult);
294 assert_equals(result.status, 'ok'); 296 assert_equals(result.status, 'ok');
295 assert_equals(result.data.byteLength, 7); 297 assert_equals(result.data.byteLength, 7);
296 assert_equals(result.data.getUint16(0), 0x07); 298 assert_equals(result.data.getUint16(0), 0x07);
297 assert_equals(result.data.getUint8(2), 0x42); 299 assert_equals(result.data.getUint8(2), 0x42);
298 assert_equals(result.data.getUint16(3), 0x1234); 300 assert_equals(result.data.getUint16(3), 0x1234);
299 assert_equals(result.data.getUint16(5), 0x5678); 301 assert_equals(result.data.getUint16(5), 0x5678);
300 return device.close(); 302 return device.close();
301 }); 303 });
302 }); 304 });
303 }, 'can issue IN control transfer'); 305 }, 'can issue IN control transfer');
304 306
305 usb_test(usb => { 307 usb_test(usb => {
306 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 308 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
307 return navigator.usb.getDevices().then(devices => { 309 return navigator.usb.getDevices().then(devices => {
308 assert_equals(1, devices.length); 310 assert_equals(1, devices.length);
309 let device = devices[0]; 311 let device = devices[0];
310 return device.open() 312 return device.open()
313 .then(() => device.selectConfiguration(1))
311 .then(() => { 314 .then(() => {
312 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 315 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
313 return assertRejectsWithNotFoundError(device.controlTransferIn({ 316 return assertRejectsWithNotFoundError(device.controlTransferIn({
314 requestType: 'vendor', 317 requestType: 'vendor',
315 recipient: 'device', 318 recipient: 'device',
316 request: 0x42, 319 request: 0x42,
317 value: 0x1234, 320 value: 0x1234,
318 index: 0x5678 321 index: 0x5678
319 }, 7)); 322 }, 7));
320 }); 323 });
321 }); 324 });
322 }, 'controlTransferIn rejects when called on a disconnected device'); 325 }, 'controlTransferIn rejects when called on a disconnected device');
323 326
324 usb_test(usb => { 327 usb_test(usb => {
325 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 328 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
326 return navigator.usb.getDevices().then(devices => { 329 return navigator.usb.getDevices().then(devices => {
327 assert_equals(1, devices.length); 330 assert_equals(1, devices.length);
328 let device = devices[0]; 331 let device = devices[0];
329 return device.open() 332 return device.open()
333 .then(() => device.selectConfiguration(1))
330 .then(() => device.controlTransferOut({ 334 .then(() => device.controlTransferOut({
331 requestType: 'vendor', 335 requestType: 'vendor',
332 recipient: 'device', 336 recipient: 'device',
333 request: 0x42, 337 request: 0x42,
334 value: 0x1234, 338 value: 0x1234,
335 index: 0x5678 339 index: 0x5678
336 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))) 340 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])))
337 .then(result => { 341 .then(result => {
338 assert_true(result instanceof USBOutTransferResult); 342 assert_true(result instanceof USBOutTransferResult);
339 assert_equals(result.status, 'ok'); 343 assert_equals(result.status, 'ok');
340 assert_equals(result.bytesWritten, 8); 344 assert_equals(result.bytesWritten, 8);
341 return device.close(); 345 return device.close();
342 }) 346 })
343 }); 347 });
344 }, 'can issue OUT control transfer'); 348 }, 'can issue OUT control transfer');
345 349
346 usb_test(usb => { 350 usb_test(usb => {
347 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 351 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
348 return navigator.usb.getDevices().then(devices => { 352 return navigator.usb.getDevices().then(devices => {
349 assert_equals(1, devices.length); 353 assert_equals(1, devices.length);
350 let device = devices[0]; 354 let device = devices[0];
351 return device.open() 355 return device.open()
356 .then(() => device.selectConfiguration(1))
352 .then(() => { 357 .then(() => {
353 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 358 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
354 return assertRejectsWithNotFoundError(device.controlTransferOut({ 359 return assertRejectsWithNotFoundError(device.controlTransferOut({
355 requestType: 'vendor', 360 requestType: 'vendor',
356 recipient: 'device', 361 recipient: 'device',
357 request: 0x42, 362 request: 0x42,
358 value: 0x1234, 363 value: 0x1234,
359 index: 0x5678 364 index: 0x5678
360 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))); 365 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])));
361 }); 366 });
362 }); 367 });
363 }, 'controlTransferOut rejects when called on a disconnected device'); 368 }, 'controlTransferOut rejects when called on a disconnected device');
364 369
365 usb_test(usb => { 370 usb_test(usb => {
366 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 371 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
367 return navigator.usb.getDevices().then(devices => { 372 return navigator.usb.getDevices().then(devices => {
368 assert_equals(devices.length, 1); 373 assert_equals(devices.length, 1);
369 let device = devices[0]; 374 let device = devices[0];
370 return device.open() 375 return device.open()
371 .then(() => device.setConfiguration(1)) 376 .then(() => device.selectConfiguration(1))
372 .then(() => device.claimInterface(0)) 377 .then(() => device.claimInterface(0))
373 .then(() => device.clearHalt(1)) 378 .then(() => device.clearHalt(1))
374 .then(() => device.close()); 379 .then(() => device.close());
375 }); 380 });
376 }, 'can clear a halt condition'); 381 }, 'can clear a halt condition');
377 382
378 usb_test(usb => { 383 usb_test(usb => {
379 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 384 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
380 return navigator.usb.getDevices().then(devices => { 385 return navigator.usb.getDevices().then(devices => {
381 assert_equals(devices.length, 1); 386 assert_equals(devices.length, 1);
382 let device = devices[0]; 387 let device = devices[0];
383 return device.open() 388 return device.open()
384 .then(() => device.setConfiguration(1)) 389 .then(() => device.selectConfiguration(1))
385 .then(() => device.claimInterface(0)) 390 .then(() => device.claimInterface(0))
386 .then(() => { 391 .then(() => {
387 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 392 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
388 return assertRejectsWithNotFoundError(device.clearHalt(1)); 393 return assertRejectsWithNotFoundError(device.clearHalt(1));
389 }); 394 });
390 }); 395 });
391 }, 'clearHalt rejects when called on a disconnected device'); 396 }, 'clearHalt rejects when called on a disconnected device');
392 397
393 usb_test(usb => { 398 usb_test(usb => {
394 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 399 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
395 return navigator.usb.getDevices().then(devices => { 400 return navigator.usb.getDevices().then(devices => {
396 assert_equals(devices.length, 1); 401 assert_equals(devices.length, 1);
397 let device = devices[0]; 402 let device = devices[0];
398 return device.open() 403 return device.open()
399 .then(() => device.setConfiguration(1)) 404 .then(() => device.selectConfiguration(1))
400 .then(() => device.claimInterface(0)) 405 .then(() => device.claimInterface(0))
401 .then(() => device.transferIn(1, 8)) 406 .then(() => device.transferIn(1, 8))
402 .then(result => { 407 .then(result => {
403 assert_true(result instanceof USBInTransferResult); 408 assert_true(result instanceof USBInTransferResult);
404 assert_equals(result.status, 'ok'); 409 assert_equals(result.status, 'ok');
405 assert_equals(result.data.byteLength, 8); 410 assert_equals(result.data.byteLength, 8);
406 for (let i = 0; i < 8; ++i) 411 for (let i = 0; i < 8; ++i)
407 assert_equals(result.data.getUint8(i), i, 'mismatch at byte ' + i); 412 assert_equals(result.data.getUint8(i), i, 'mismatch at byte ' + i);
408 return device.close(); 413 return device.close();
409 }); 414 });
410 }); 415 });
411 }, 'can issue IN interrupt transfer'); 416 }, 'can issue IN interrupt transfer');
412 417
413 usb_test(usb => { 418 usb_test(usb => {
414 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 419 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
415 return navigator.usb.getDevices().then(devices => { 420 return navigator.usb.getDevices().then(devices => {
416 assert_equals(devices.length, 1); 421 assert_equals(devices.length, 1);
417 let device = devices[0]; 422 let device = devices[0];
418 return device.open() 423 return device.open()
419 .then(() => device.setConfiguration(1)) 424 .then(() => device.selectConfiguration(1))
420 .then(() => device.claimInterface(1)) 425 .then(() => device.claimInterface(1))
421 .then(() => device.transferIn(2, 1024)) 426 .then(() => device.transferIn(2, 1024))
422 .then(result => { 427 .then(result => {
423 assert_true(result instanceof USBInTransferResult); 428 assert_true(result instanceof USBInTransferResult);
424 assert_equals(result.status, 'ok'); 429 assert_equals(result.status, 'ok');
425 assert_equals(result.data.byteLength, 1024); 430 assert_equals(result.data.byteLength, 1024);
426 for (let i = 0; i < 1024; ++i) 431 for (let i = 0; i < 1024; ++i)
427 assert_equals(result.data.getUint8(i), i & 0xff, 432 assert_equals(result.data.getUint8(i), i & 0xff,
428 'mismatch at byte ' + i); 433 'mismatch at byte ' + i);
429 return device.close(); 434 return device.close();
430 }); 435 });
431 }); 436 });
432 }, 'can issue IN bulk transfer'); 437 }, 'can issue IN bulk transfer');
433 438
434 usb_test(usb => { 439 usb_test(usb => {
435 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 440 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
436 return navigator.usb.getDevices().then(devices => { 441 return navigator.usb.getDevices().then(devices => {
437 assert_equals(devices.length, 1); 442 assert_equals(devices.length, 1);
438 let device = devices[0]; 443 let device = devices[0];
439 return device.open() 444 return device.open()
440 .then(() => device.setConfiguration(1)) 445 .then(() => device.selectConfiguration(1))
441 .then(() => device.claimInterface(1)) 446 .then(() => device.claimInterface(1))
442 .then(() => { 447 .then(() => {
443 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 448 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
444 return assertRejectsWithNotFoundError(device.transferIn(2, 1024)); 449 return assertRejectsWithNotFoundError(device.transferIn(2, 1024));
445 }); 450 });
446 }); 451 });
447 }, 'transferIn rejects if called on a disconnected device'); 452 }, 'transferIn rejects if called on a disconnected device');
448 453
449 usb_test(usb => { 454 usb_test(usb => {
450 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 455 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
451 return navigator.usb.getDevices().then(devices => { 456 return navigator.usb.getDevices().then(devices => {
452 assert_equals(devices.length, 1); 457 assert_equals(devices.length, 1);
453 let device = devices[0]; 458 let device = devices[0];
454 return device.open() 459 return device.open()
455 .then(() => device.setConfiguration(1)) 460 .then(() => device.selectConfiguration(1))
456 .then(() => device.claimInterface(1)) 461 .then(() => device.claimInterface(1))
457 .then(() => { 462 .then(() => {
458 let data = new DataView(new ArrayBuffer(1024)); 463 let data = new DataView(new ArrayBuffer(1024));
459 for (let i = 0; i < 1024; ++i) 464 for (let i = 0; i < 1024; ++i)
460 data.setUint8(i, i & 0xff); 465 data.setUint8(i, i & 0xff);
461 return device.transferOut(2, data); 466 return device.transferOut(2, data);
462 }) 467 })
463 .then(result => { 468 .then(result => {
464 assert_true(result instanceof USBOutTransferResult); 469 assert_true(result instanceof USBOutTransferResult);
465 assert_equals(result.status, 'ok'); 470 assert_equals(result.status, 'ok');
466 assert_equals(result.bytesWritten, 1024); 471 assert_equals(result.bytesWritten, 1024);
467 return device.close(); 472 return device.close();
468 }); 473 });
469 }); 474 });
470 }, 'can issue OUT bulk transfer'); 475 }, 'can issue OUT bulk transfer');
471 476
472 usb_test(usb => { 477 usb_test(usb => {
473 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 478 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
474 return navigator.usb.getDevices().then(devices => { 479 return navigator.usb.getDevices().then(devices => {
475 assert_equals(devices.length, 1); 480 assert_equals(devices.length, 1);
476 let device = devices[0]; 481 let device = devices[0];
477 return device.open() 482 return device.open()
478 .then(() => device.setConfiguration(1)) 483 .then(() => device.selectConfiguration(1))
479 .then(() => device.claimInterface(1)) 484 .then(() => device.claimInterface(1))
480 .then(() => { 485 .then(() => {
481 let data = new DataView(new ArrayBuffer(1024)); 486 let data = new DataView(new ArrayBuffer(1024));
482 for (let i = 0; i < 1024; ++i) 487 for (let i = 0; i < 1024; ++i)
483 data.setUint8(i, i & 0xff); 488 data.setUint8(i, i & 0xff);
484 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 489 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
485 return assertRejectsWithNotFoundError(device.transferOut(2, data)); 490 return assertRejectsWithNotFoundError(device.transferOut(2, data));
486 }); 491 });
487 }); 492 });
488 }, 'transferOut rejects if called on a disconnected device'); 493 }, 'transferOut rejects if called on a disconnected device');
489 494
490 usb_test(usb => { 495 usb_test(usb => {
491 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 496 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
492 return navigator.usb.getDevices().then(devices => { 497 return navigator.usb.getDevices().then(devices => {
493 assert_equals(devices.length, 1); 498 assert_equals(devices.length, 1);
494 let device = devices[0]; 499 let device = devices[0];
495 return device.open() 500 return device.open()
496 .then(() => device.setConfiguration(2)) 501 .then(() => device.selectConfiguration(2))
497 .then(() => device.claimInterface(0)) 502 .then(() => device.claimInterface(0))
498 .then(() => device.setInterface(0, 1)) 503 .then(() => device.setInterface(0, 1))
499 .then(() => device.isochronousTransferIn( 504 .then(() => device.isochronousTransferIn(
500 1, [64, 64, 64, 64, 64, 64, 64, 64])) 505 1, [64, 64, 64, 64, 64, 64, 64, 64]))
501 .then(result => { 506 .then(result => {
502 assert_true(result instanceof USBIsochronousInTransferResult); 507 assert_true(result instanceof USBIsochronousInTransferResult);
503 assert_equals(result.data.byteLength, 64 * 8, 'buffer size'); 508 assert_equals(result.data.byteLength, 64 * 8, 'buffer size');
504 assert_equals(result.packets.length, 8, 'number of packets'); 509 assert_equals(result.packets.length, 8, 'number of packets');
505 let byteOffset = 0; 510 let byteOffset = 0;
506 for (let i = 0; i < result.packets.length; ++i) { 511 for (let i = 0; i < result.packets.length; ++i) {
(...skipping 12 matching lines...) Expand all
519 }); 524 });
520 }); 525 });
521 }, 'can issue IN isochronous transfer'); 526 }, 'can issue IN isochronous transfer');
522 527
523 usb_test(usb => { 528 usb_test(usb => {
524 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 529 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
525 return navigator.usb.getDevices().then(devices => { 530 return navigator.usb.getDevices().then(devices => {
526 assert_equals(devices.length, 1); 531 assert_equals(devices.length, 1);
527 let device = devices[0]; 532 let device = devices[0];
528 return device.open() 533 return device.open()
529 .then(() => device.setConfiguration(2)) 534 .then(() => device.selectConfiguration(2))
530 .then(() => device.claimInterface(0)) 535 .then(() => device.claimInterface(0))
531 .then(() => device.setInterface(0, 1)) 536 .then(() => device.setInterface(0, 1))
532 .then(() => { 537 .then(() => {
533 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 538 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
534 return assertRejectsWithNotFoundError(device.isochronousTransferIn( 539 return assertRejectsWithNotFoundError(device.isochronousTransferIn(
535 1, [64, 64, 64, 64, 64, 64, 64, 64])); 540 1, [64, 64, 64, 64, 64, 64, 64, 64]));
536 }); 541 });
537 }); 542 });
538 }, 'isochronousTransferIn rejects when called on a disconnected device'); 543 }, 'isochronousTransferIn rejects when called on a disconnected device');
539 544
540 usb_test(usb => { 545 usb_test(usb => {
541 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 546 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
542 return navigator.usb.getDevices().then(devices => { 547 return navigator.usb.getDevices().then(devices => {
543 assert_equals(devices.length, 1); 548 assert_equals(devices.length, 1);
544 let device = devices[0]; 549 let device = devices[0];
545 return device.open() 550 return device.open()
546 .then(() => device.setConfiguration(2)) 551 .then(() => device.selectConfiguration(2))
547 .then(() => device.claimInterface(0)) 552 .then(() => device.claimInterface(0))
548 .then(() => device.setInterface(0, 1)) 553 .then(() => device.setInterface(0, 1))
549 .then(() => { 554 .then(() => {
550 let data = new DataView(new ArrayBuffer(64 * 8)); 555 let data = new DataView(new ArrayBuffer(64 * 8));
551 for (let i = 0; i < 8; ++i) { 556 for (let i = 0; i < 8; ++i) {
552 for (let j = 0; j < 64; ++j) 557 for (let j = 0; j < 64; ++j)
553 data.setUint8(i * j, j & 0xff); 558 data.setUint8(i * j, j & 0xff);
554 } 559 }
555 return device.isochronousTransferOut( 560 return device.isochronousTransferOut(
556 1, data, [64, 64, 64, 64, 64, 64, 64, 64]); 561 1, data, [64, 64, 64, 64, 64, 64, 64, 64]);
(...skipping 12 matching lines...) Expand all
569 }); 574 });
570 }); 575 });
571 }, 'can issue OUT isochronous transfer'); 576 }, 'can issue OUT isochronous transfer');
572 577
573 usb_test(usb => { 578 usb_test(usb => {
574 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 579 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
575 return navigator.usb.getDevices().then(devices => { 580 return navigator.usb.getDevices().then(devices => {
576 assert_equals(devices.length, 1); 581 assert_equals(devices.length, 1);
577 let device = devices[0]; 582 let device = devices[0];
578 return device.open() 583 return device.open()
579 .then(() => device.setConfiguration(2)) 584 .then(() => device.selectConfiguration(2))
580 .then(() => device.claimInterface(0)) 585 .then(() => device.claimInterface(0))
581 .then(() => device.setInterface(0, 1)) 586 .then(() => device.setInterface(0, 1))
582 .then(() => { 587 .then(() => {
583 let data = new DataView(new ArrayBuffer(64 * 8)); 588 let data = new DataView(new ArrayBuffer(64 * 8));
584 for (let i = 0; i < 8; ++i) { 589 for (let i = 0; i < 8; ++i) {
585 for (let j = 0; j < 64; ++j) 590 for (let j = 0; j < 64; ++j)
586 data.setUint8(i * j, j & 0xff); 591 data.setUint8(i * j, j & 0xff);
587 } 592 }
588 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 593 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
589 return assertRejectsWithNotFoundError(device.isochronousTransferOut( 594 return assertRejectsWithNotFoundError(device.isochronousTransferOut(
(...skipping 16 matching lines...) Expand all
606 return navigator.usb.getDevices().then(devices => { 611 return navigator.usb.getDevices().then(devices => {
607 assert_equals(1, devices.length); 612 assert_equals(1, devices.length);
608 let device = devices[0]; 613 let device = devices[0];
609 return device.open().then(() => { 614 return device.open().then(() => {
610 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 615 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
611 return assertRejectsWithNotFoundError(device.reset()); 616 return assertRejectsWithNotFoundError(device.reset());
612 }); 617 });
613 }); 618 });
614 }, 'resetDevice rejects when called on a disconnected device'); 619 }, 'resetDevice rejects when called on a disconnected device');
615 </script> 620 </script>
OLDNEW
« no previous file with comments | « third_party/WebKit/LayoutTests/usb/resources/usb-helpers.js ('k') | third_party/WebKit/LayoutTests/webexposed/global-interface-listing-expected.txt » ('j') | third_party/WebKit/Source/modules/webusb/USBDevice.cpp » ('J')

Powered by Google App Engine
This is Rietveld 408576698