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

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: Rebased. 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') | no next file with comments »
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];
179 assert_equals(device.configuration, null);
172 return device.open() 180 return device.open()
173 .then(() => device.setConfiguration(1)) 181 .then(() => assertRejectsWithError(
174 .then(() => device.getConfiguration()) 182 device.selectConfiguration(3), 'NotFoundError',
175 .then(config => { 183 'The configuration value provided is not supported by the device.'))
176 usb.assertConfigurationInfoEquals(
177 config, usb.fakeDevices[0].configurations[0]);
178 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
179 return assertRejectsWithNotFoundError(device.getConfiguration());
180 });
181 });
182 }, 'getConfiguration rejects when called on a disconnected device');
183
184 usb_test(usb => {
185 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()); 184 .then(() => device.close());
193 }); 185 });
194 }, 'querying an unset configuration raises NotFoundError'); 186 }, 'selectConfiguration rejects on invalid configurations');
187
195 188
196 usb_test(usb => { 189 usb_test(usb => {
197 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 190 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
198 return navigator.usb.getDevices().then(devices => { 191 return navigator.usb.getDevices().then(devices => {
199 assert_equals(1, devices.length); 192 assert_equals(1, devices.length);
200 let device = devices[0]; 193 let device = devices[0];
201 return device.open() 194 assert_equals(device.configuration, null);
202 .then(() => device.setConfiguration(1)) 195 return device.open().then(() => Promise.all([
203 .then(() => device.claimInterface(0)) 196 assertRejectsWithNotConfiguredError(device.claimInterface(0)),
204 .then(() => device.releaseInterface(0)) 197 assertRejectsWithNotConfiguredError(device.releaseInterface(0)),
205 .then(() => device.close()); 198 assertRejectsWithNotConfiguredError(device.setInterface(0, 1)),
199 assertRejectsWithNotConfiguredError(device.controlTransferIn({
200 requestType: 'vendor',
201 recipient: 'device',
202 request: 0x42,
203 value: 0x1234,
204 index: 0x5678
205 }, 7)),
206 assertRejectsWithNotConfiguredError(device.controlTransferOut({
207 requestType: 'vendor',
208 recipient: 'device',
209 request: 0x42,
210 value: 0x1234,
211 index: 0x5678
212 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))),
213 assertRejectsWithNotConfiguredError(device.clearHalt(1)),
214 assertRejectsWithNotConfiguredError(device.transferIn(1, 8)),
215 assertRejectsWithNotConfiguredError(
216 device.transferOut(1, new ArrayBuffer(8))),
217 assertRejectsWithNotConfiguredError(
218 device.isochronousTransferIn(1, [8])),
219 assertRejectsWithNotConfiguredError(
220 device.isochronousTransferOut(1, new ArrayBuffer(8), [8])),
221 ])).then(() => device.close());
206 }); 222 });
207 }, 'an interface can be claimed and released'); 223 }, 'methods requiring it reject when the device is unconfigured');
208 224
209 usb_test(usb => { 225 usb_test(usb => {
210 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 226 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
211 return navigator.usb.getDevices().then(devices => { 227 return navigator.usb.getDevices().then(devices => {
212 assert_equals(1, devices.length); 228 assert_equals(1, devices.length);
213 let device = devices[0]; 229 let device = devices[0];
214 return device.open() 230 return device.open()
215 .then(() => 231 .then(() => device.selectConfiguration(1))
216 // TODO(reillyg): This should be INVALID_STATE_ERR. 232 .then(() => device.claimInterface(0))
217 assertRejectsWithError(device.claimInterface(0), 'NetworkError')) 233 .then(() => device.releaseInterface(0))
218 .then(() => device.close()); 234 .then(() => device.close());
219 }); 235 });
220 }, 'claiming an interface fails without an active configuration'); 236 }, 'an interface can be claimed and released');
221 237
222 usb_test(usb => { 238 usb_test(usb => {
223 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 239 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
224 return navigator.usb.getDevices().then(devices => { 240 return navigator.usb.getDevices().then(devices => {
225 assert_equals(1, devices.length); 241 assert_equals(1, devices.length);
226 var device = devices[0]; 242 var device = devices[0];
227 return device.open() 243 return device.open()
228 .then(() => device.setConfiguration(1)) 244 .then(() => device.selectConfiguration(1))
229 .then(() => { 245 .then(() => {
230 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 246 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
231 return assertRejectsWithNotFoundError(device.claimInterface(0)); 247 return assertRejectsWithNotFoundError(device.claimInterface(0));
232 }); 248 });
233 }); 249 });
234 }, 'claimInterface rejects when called on a disconnected device'); 250 }, 'claimInterface rejects when called on a disconnected device');
235 251
236 usb_test(usb => { 252 usb_test(usb => {
237 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 253 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
238 return navigator.usb.getDevices().then(devices => { 254 return navigator.usb.getDevices().then(devices => {
239 assert_equals(1, devices.length); 255 assert_equals(1, devices.length);
240 var device = devices[0]; 256 var device = devices[0];
241 return device.open() 257 return device.open()
242 .then(() => device.setConfiguration(1)) 258 .then(() => device.selectConfiguration(1))
243 .then(() => device.claimInterface(0)) 259 .then(() => device.claimInterface(0))
244 .then(() => { 260 .then(() => {
245 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 261 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
246 return assertRejectsWithNotFoundError(device.releaseInterface(0)); 262 return assertRejectsWithNotFoundError(device.releaseInterface(0));
247 }); 263 });
248 }); 264 });
249 }, 'releaseInterface rejects when called on a disconnected device'); 265 }, 'releaseInterface rejects when called on a disconnected device');
250 266
251 usb_test(usb => { 267 usb_test(usb => {
252 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 268 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
253 return navigator.usb.getDevices().then(devices => { 269 return navigator.usb.getDevices().then(devices => {
254 assert_equals(1, devices.length); 270 assert_equals(1, devices.length);
255 let device = devices[0]; 271 let device = devices[0];
256 return device.open() 272 return device.open()
257 .then(() => device.setConfiguration(2)) 273 .then(() => device.selectConfiguration(2))
258 .then(() => device.claimInterface(0)) 274 .then(() => device.claimInterface(0))
259 .then(() => device.setInterface(0, 1)) 275 .then(() => device.setInterface(0, 1))
260 .then(() => device.close()); 276 .then(() => device.close());
261 }); 277 });
262 }, 'can select an alternate interface'); 278 }, 'can select an alternate interface');
263 279
264 usb_test(usb => { 280 usb_test(usb => {
265 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 281 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
266 return navigator.usb.getDevices().then(devices => { 282 return navigator.usb.getDevices().then(devices => {
267 assert_equals(1, devices.length); 283 assert_equals(1, devices.length);
268 var device = devices[0]; 284 var device = devices[0];
269 return device.open() 285 return device.open()
270 .then(() => device.setConfiguration(2)) 286 .then(() => device.selectConfiguration(2))
271 .then(() => device.claimInterface(0)) 287 .then(() => device.claimInterface(0))
272 .then(() => { 288 .then(() => {
273 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 289 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
274 return assertRejectsWithNotFoundError(device.setInterface(0, 1)); 290 return assertRejectsWithNotFoundError(device.setInterface(0, 1));
275 }); 291 });
276 }); 292 });
277 }, 'setInterface rejects when called on a disconnected device'); 293 }, 'setInterface rejects when called on a disconnected device');
278 294
279 usb_test(usb => { 295 usb_test(usb => {
280 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 296 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
281 return navigator.usb.getDevices().then(devices => { 297 return navigator.usb.getDevices().then(devices => {
282 assert_equals(1, devices.length); 298 assert_equals(1, devices.length);
283 let device = devices[0]; 299 let device = devices[0];
284 return device.open() 300 return device.open()
301 .then(() => device.selectConfiguration(1))
285 .then(() => device.controlTransferIn({ 302 .then(() => device.controlTransferIn({
286 requestType: 'vendor', 303 requestType: 'vendor',
287 recipient: 'device', 304 recipient: 'device',
288 request: 0x42, 305 request: 0x42,
289 value: 0x1234, 306 value: 0x1234,
290 index: 0x5678 307 index: 0x5678
291 }, 7)) 308 }, 7))
292 .then(result => { 309 .then(result => {
293 assert_true(result instanceof USBInTransferResult); 310 assert_true(result instanceof USBInTransferResult);
294 assert_equals(result.status, 'ok'); 311 assert_equals(result.status, 'ok');
295 assert_equals(result.data.byteLength, 7); 312 assert_equals(result.data.byteLength, 7);
296 assert_equals(result.data.getUint16(0), 0x07); 313 assert_equals(result.data.getUint16(0), 0x07);
297 assert_equals(result.data.getUint8(2), 0x42); 314 assert_equals(result.data.getUint8(2), 0x42);
298 assert_equals(result.data.getUint16(3), 0x1234); 315 assert_equals(result.data.getUint16(3), 0x1234);
299 assert_equals(result.data.getUint16(5), 0x5678); 316 assert_equals(result.data.getUint16(5), 0x5678);
300 return device.close(); 317 return device.close();
301 }); 318 });
302 }); 319 });
303 }, 'can issue IN control transfer'); 320 }, 'can issue IN control transfer');
304 321
305 usb_test(usb => { 322 usb_test(usb => {
306 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 323 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
307 return navigator.usb.getDevices().then(devices => { 324 return navigator.usb.getDevices().then(devices => {
308 assert_equals(1, devices.length); 325 assert_equals(1, devices.length);
309 let device = devices[0]; 326 let device = devices[0];
310 return device.open() 327 return device.open()
328 .then(() => device.selectConfiguration(1))
311 .then(() => { 329 .then(() => {
312 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 330 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
313 return assertRejectsWithNotFoundError(device.controlTransferIn({ 331 return assertRejectsWithNotFoundError(device.controlTransferIn({
314 requestType: 'vendor', 332 requestType: 'vendor',
315 recipient: 'device', 333 recipient: 'device',
316 request: 0x42, 334 request: 0x42,
317 value: 0x1234, 335 value: 0x1234,
318 index: 0x5678 336 index: 0x5678
319 }, 7)); 337 }, 7));
320 }); 338 });
321 }); 339 });
322 }, 'controlTransferIn rejects when called on a disconnected device'); 340 }, 'controlTransferIn rejects when called on a disconnected device');
323 341
324 usb_test(usb => { 342 usb_test(usb => {
325 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 343 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
326 return navigator.usb.getDevices().then(devices => { 344 return navigator.usb.getDevices().then(devices => {
327 assert_equals(1, devices.length); 345 assert_equals(1, devices.length);
328 let device = devices[0]; 346 let device = devices[0];
329 return device.open() 347 return device.open()
348 .then(() => device.selectConfiguration(1))
330 .then(() => device.controlTransferOut({ 349 .then(() => device.controlTransferOut({
331 requestType: 'vendor', 350 requestType: 'vendor',
332 recipient: 'device', 351 recipient: 'device',
333 request: 0x42, 352 request: 0x42,
334 value: 0x1234, 353 value: 0x1234,
335 index: 0x5678 354 index: 0x5678
336 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))) 355 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])))
337 .then(result => { 356 .then(result => {
338 assert_true(result instanceof USBOutTransferResult); 357 assert_true(result instanceof USBOutTransferResult);
339 assert_equals(result.status, 'ok'); 358 assert_equals(result.status, 'ok');
340 assert_equals(result.bytesWritten, 8); 359 assert_equals(result.bytesWritten, 8);
341 return device.close(); 360 return device.close();
342 }) 361 })
343 }); 362 });
344 }, 'can issue OUT control transfer'); 363 }, 'can issue OUT control transfer');
345 364
346 usb_test(usb => { 365 usb_test(usb => {
347 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 366 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
348 return navigator.usb.getDevices().then(devices => { 367 return navigator.usb.getDevices().then(devices => {
349 assert_equals(1, devices.length); 368 assert_equals(1, devices.length);
350 let device = devices[0]; 369 let device = devices[0];
351 return device.open() 370 return device.open()
371 .then(() => device.selectConfiguration(1))
352 .then(() => { 372 .then(() => {
353 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 373 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
354 return assertRejectsWithNotFoundError(device.controlTransferOut({ 374 return assertRejectsWithNotFoundError(device.controlTransferOut({
355 requestType: 'vendor', 375 requestType: 'vendor',
356 recipient: 'device', 376 recipient: 'device',
357 request: 0x42, 377 request: 0x42,
358 value: 0x1234, 378 value: 0x1234,
359 index: 0x5678 379 index: 0x5678
360 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))); 380 }, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])));
361 }); 381 });
362 }); 382 });
363 }, 'controlTransferOut rejects when called on a disconnected device'); 383 }, 'controlTransferOut rejects when called on a disconnected device');
364 384
365 usb_test(usb => { 385 usb_test(usb => {
366 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 386 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
367 return navigator.usb.getDevices().then(devices => { 387 return navigator.usb.getDevices().then(devices => {
368 assert_equals(devices.length, 1); 388 assert_equals(devices.length, 1);
369 let device = devices[0]; 389 let device = devices[0];
370 return device.open() 390 return device.open()
371 .then(() => device.setConfiguration(1)) 391 .then(() => device.selectConfiguration(1))
372 .then(() => device.claimInterface(0)) 392 .then(() => device.claimInterface(0))
373 .then(() => device.clearHalt(1)) 393 .then(() => device.clearHalt(1))
374 .then(() => device.close()); 394 .then(() => device.close());
375 }); 395 });
376 }, 'can clear a halt condition'); 396 }, 'can clear a halt condition');
377 397
378 usb_test(usb => { 398 usb_test(usb => {
379 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 399 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
380 return navigator.usb.getDevices().then(devices => { 400 return navigator.usb.getDevices().then(devices => {
381 assert_equals(devices.length, 1); 401 assert_equals(devices.length, 1);
382 let device = devices[0]; 402 let device = devices[0];
383 return device.open() 403 return device.open()
384 .then(() => device.setConfiguration(1)) 404 .then(() => device.selectConfiguration(1))
385 .then(() => device.claimInterface(0)) 405 .then(() => device.claimInterface(0))
386 .then(() => { 406 .then(() => {
387 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 407 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
388 return assertRejectsWithNotFoundError(device.clearHalt(1)); 408 return assertRejectsWithNotFoundError(device.clearHalt(1));
389 }); 409 });
390 }); 410 });
391 }, 'clearHalt rejects when called on a disconnected device'); 411 }, 'clearHalt rejects when called on a disconnected device');
392 412
393 usb_test(usb => { 413 usb_test(usb => {
394 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 414 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
395 return navigator.usb.getDevices().then(devices => { 415 return navigator.usb.getDevices().then(devices => {
396 assert_equals(devices.length, 1); 416 assert_equals(devices.length, 1);
397 let device = devices[0]; 417 let device = devices[0];
398 return device.open() 418 return device.open()
399 .then(() => device.setConfiguration(1)) 419 .then(() => device.selectConfiguration(1))
400 .then(() => device.claimInterface(0)) 420 .then(() => device.claimInterface(0))
401 .then(() => device.transferIn(1, 8)) 421 .then(() => device.transferIn(1, 8))
402 .then(result => { 422 .then(result => {
403 assert_true(result instanceof USBInTransferResult); 423 assert_true(result instanceof USBInTransferResult);
404 assert_equals(result.status, 'ok'); 424 assert_equals(result.status, 'ok');
405 assert_equals(result.data.byteLength, 8); 425 assert_equals(result.data.byteLength, 8);
406 for (let i = 0; i < 8; ++i) 426 for (let i = 0; i < 8; ++i)
407 assert_equals(result.data.getUint8(i), i, 'mismatch at byte ' + i); 427 assert_equals(result.data.getUint8(i), i, 'mismatch at byte ' + i);
408 return device.close(); 428 return device.close();
409 }); 429 });
410 }); 430 });
411 }, 'can issue IN interrupt transfer'); 431 }, 'can issue IN interrupt transfer');
412 432
413 usb_test(usb => { 433 usb_test(usb => {
414 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 434 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
415 return navigator.usb.getDevices().then(devices => { 435 return navigator.usb.getDevices().then(devices => {
416 assert_equals(devices.length, 1); 436 assert_equals(devices.length, 1);
417 let device = devices[0]; 437 let device = devices[0];
418 return device.open() 438 return device.open()
419 .then(() => device.setConfiguration(1)) 439 .then(() => device.selectConfiguration(1))
420 .then(() => device.claimInterface(1)) 440 .then(() => device.claimInterface(1))
421 .then(() => device.transferIn(2, 1024)) 441 .then(() => device.transferIn(2, 1024))
422 .then(result => { 442 .then(result => {
423 assert_true(result instanceof USBInTransferResult); 443 assert_true(result instanceof USBInTransferResult);
424 assert_equals(result.status, 'ok'); 444 assert_equals(result.status, 'ok');
425 assert_equals(result.data.byteLength, 1024); 445 assert_equals(result.data.byteLength, 1024);
426 for (let i = 0; i < 1024; ++i) 446 for (let i = 0; i < 1024; ++i)
427 assert_equals(result.data.getUint8(i), i & 0xff, 447 assert_equals(result.data.getUint8(i), i & 0xff,
428 'mismatch at byte ' + i); 448 'mismatch at byte ' + i);
429 return device.close(); 449 return device.close();
430 }); 450 });
431 }); 451 });
432 }, 'can issue IN bulk transfer'); 452 }, 'can issue IN bulk transfer');
433 453
434 usb_test(usb => { 454 usb_test(usb => {
435 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 455 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
436 return navigator.usb.getDevices().then(devices => { 456 return navigator.usb.getDevices().then(devices => {
437 assert_equals(devices.length, 1); 457 assert_equals(devices.length, 1);
438 let device = devices[0]; 458 let device = devices[0];
439 return device.open() 459 return device.open()
440 .then(() => device.setConfiguration(1)) 460 .then(() => device.selectConfiguration(1))
441 .then(() => device.claimInterface(1)) 461 .then(() => device.claimInterface(1))
442 .then(() => { 462 .then(() => {
443 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 463 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
444 return assertRejectsWithNotFoundError(device.transferIn(2, 1024)); 464 return assertRejectsWithNotFoundError(device.transferIn(2, 1024));
445 }); 465 });
446 }); 466 });
447 }, 'transferIn rejects if called on a disconnected device'); 467 }, 'transferIn rejects if called on a disconnected device');
448 468
449 usb_test(usb => { 469 usb_test(usb => {
450 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 470 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
451 return navigator.usb.getDevices().then(devices => { 471 return navigator.usb.getDevices().then(devices => {
452 assert_equals(devices.length, 1); 472 assert_equals(devices.length, 1);
453 let device = devices[0]; 473 let device = devices[0];
454 return device.open() 474 return device.open()
455 .then(() => device.setConfiguration(1)) 475 .then(() => device.selectConfiguration(1))
456 .then(() => device.claimInterface(1)) 476 .then(() => device.claimInterface(1))
457 .then(() => { 477 .then(() => {
458 let data = new DataView(new ArrayBuffer(1024)); 478 let data = new DataView(new ArrayBuffer(1024));
459 for (let i = 0; i < 1024; ++i) 479 for (let i = 0; i < 1024; ++i)
460 data.setUint8(i, i & 0xff); 480 data.setUint8(i, i & 0xff);
461 return device.transferOut(2, data); 481 return device.transferOut(2, data);
462 }) 482 })
463 .then(result => { 483 .then(result => {
464 assert_true(result instanceof USBOutTransferResult); 484 assert_true(result instanceof USBOutTransferResult);
465 assert_equals(result.status, 'ok'); 485 assert_equals(result.status, 'ok');
466 assert_equals(result.bytesWritten, 1024); 486 assert_equals(result.bytesWritten, 1024);
467 return device.close(); 487 return device.close();
468 }); 488 });
469 }); 489 });
470 }, 'can issue OUT bulk transfer'); 490 }, 'can issue OUT bulk transfer');
471 491
472 usb_test(usb => { 492 usb_test(usb => {
473 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 493 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
474 return navigator.usb.getDevices().then(devices => { 494 return navigator.usb.getDevices().then(devices => {
475 assert_equals(devices.length, 1); 495 assert_equals(devices.length, 1);
476 let device = devices[0]; 496 let device = devices[0];
477 return device.open() 497 return device.open()
478 .then(() => device.setConfiguration(1)) 498 .then(() => device.selectConfiguration(1))
479 .then(() => device.claimInterface(1)) 499 .then(() => device.claimInterface(1))
480 .then(() => { 500 .then(() => {
481 let data = new DataView(new ArrayBuffer(1024)); 501 let data = new DataView(new ArrayBuffer(1024));
482 for (let i = 0; i < 1024; ++i) 502 for (let i = 0; i < 1024; ++i)
483 data.setUint8(i, i & 0xff); 503 data.setUint8(i, i & 0xff);
484 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 504 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
485 return assertRejectsWithNotFoundError(device.transferOut(2, data)); 505 return assertRejectsWithNotFoundError(device.transferOut(2, data));
486 }); 506 });
487 }); 507 });
488 }, 'transferOut rejects if called on a disconnected device'); 508 }, 'transferOut rejects if called on a disconnected device');
489 509
490 usb_test(usb => { 510 usb_test(usb => {
491 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 511 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
492 return navigator.usb.getDevices().then(devices => { 512 return navigator.usb.getDevices().then(devices => {
493 assert_equals(devices.length, 1); 513 assert_equals(devices.length, 1);
494 let device = devices[0]; 514 let device = devices[0];
495 return device.open() 515 return device.open()
496 .then(() => device.setConfiguration(2)) 516 .then(() => device.selectConfiguration(2))
497 .then(() => device.claimInterface(0)) 517 .then(() => device.claimInterface(0))
498 .then(() => device.setInterface(0, 1)) 518 .then(() => device.setInterface(0, 1))
499 .then(() => device.isochronousTransferIn( 519 .then(() => device.isochronousTransferIn(
500 1, [64, 64, 64, 64, 64, 64, 64, 64])) 520 1, [64, 64, 64, 64, 64, 64, 64, 64]))
501 .then(result => { 521 .then(result => {
502 assert_true(result instanceof USBIsochronousInTransferResult); 522 assert_true(result instanceof USBIsochronousInTransferResult);
503 assert_equals(result.data.byteLength, 64 * 8, 'buffer size'); 523 assert_equals(result.data.byteLength, 64 * 8, 'buffer size');
504 assert_equals(result.packets.length, 8, 'number of packets'); 524 assert_equals(result.packets.length, 8, 'number of packets');
505 let byteOffset = 0; 525 let byteOffset = 0;
506 for (let i = 0; i < result.packets.length; ++i) { 526 for (let i = 0; i < result.packets.length; ++i) {
(...skipping 12 matching lines...) Expand all
519 }); 539 });
520 }); 540 });
521 }, 'can issue IN isochronous transfer'); 541 }, 'can issue IN isochronous transfer');
522 542
523 usb_test(usb => { 543 usb_test(usb => {
524 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 544 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
525 return navigator.usb.getDevices().then(devices => { 545 return navigator.usb.getDevices().then(devices => {
526 assert_equals(devices.length, 1); 546 assert_equals(devices.length, 1);
527 let device = devices[0]; 547 let device = devices[0];
528 return device.open() 548 return device.open()
529 .then(() => device.setConfiguration(2)) 549 .then(() => device.selectConfiguration(2))
530 .then(() => device.claimInterface(0)) 550 .then(() => device.claimInterface(0))
531 .then(() => device.setInterface(0, 1)) 551 .then(() => device.setInterface(0, 1))
532 .then(() => { 552 .then(() => {
533 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 553 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
534 return assertRejectsWithNotFoundError(device.isochronousTransferIn( 554 return assertRejectsWithNotFoundError(device.isochronousTransferIn(
535 1, [64, 64, 64, 64, 64, 64, 64, 64])); 555 1, [64, 64, 64, 64, 64, 64, 64, 64]));
536 }); 556 });
537 }); 557 });
538 }, 'isochronousTransferIn rejects when called on a disconnected device'); 558 }, 'isochronousTransferIn rejects when called on a disconnected device');
539 559
540 usb_test(usb => { 560 usb_test(usb => {
541 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 561 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
542 return navigator.usb.getDevices().then(devices => { 562 return navigator.usb.getDevices().then(devices => {
543 assert_equals(devices.length, 1); 563 assert_equals(devices.length, 1);
544 let device = devices[0]; 564 let device = devices[0];
545 return device.open() 565 return device.open()
546 .then(() => device.setConfiguration(2)) 566 .then(() => device.selectConfiguration(2))
547 .then(() => device.claimInterface(0)) 567 .then(() => device.claimInterface(0))
548 .then(() => device.setInterface(0, 1)) 568 .then(() => device.setInterface(0, 1))
549 .then(() => { 569 .then(() => {
550 let data = new DataView(new ArrayBuffer(64 * 8)); 570 let data = new DataView(new ArrayBuffer(64 * 8));
551 for (let i = 0; i < 8; ++i) { 571 for (let i = 0; i < 8; ++i) {
552 for (let j = 0; j < 64; ++j) 572 for (let j = 0; j < 64; ++j)
553 data.setUint8(i * j, j & 0xff); 573 data.setUint8(i * j, j & 0xff);
554 } 574 }
555 return device.isochronousTransferOut( 575 return device.isochronousTransferOut(
556 1, data, [64, 64, 64, 64, 64, 64, 64, 64]); 576 1, data, [64, 64, 64, 64, 64, 64, 64, 64]);
(...skipping 12 matching lines...) Expand all
569 }); 589 });
570 }); 590 });
571 }, 'can issue OUT isochronous transfer'); 591 }, 'can issue OUT isochronous transfer');
572 592
573 usb_test(usb => { 593 usb_test(usb => {
574 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]); 594 usb.mockDeviceManager.addMockDevice(usb.fakeDevices[0]);
575 return navigator.usb.getDevices().then(devices => { 595 return navigator.usb.getDevices().then(devices => {
576 assert_equals(devices.length, 1); 596 assert_equals(devices.length, 1);
577 let device = devices[0]; 597 let device = devices[0];
578 return device.open() 598 return device.open()
579 .then(() => device.setConfiguration(2)) 599 .then(() => device.selectConfiguration(2))
580 .then(() => device.claimInterface(0)) 600 .then(() => device.claimInterface(0))
581 .then(() => device.setInterface(0, 1)) 601 .then(() => device.setInterface(0, 1))
582 .then(() => { 602 .then(() => {
583 let data = new DataView(new ArrayBuffer(64 * 8)); 603 let data = new DataView(new ArrayBuffer(64 * 8));
584 for (let i = 0; i < 8; ++i) { 604 for (let i = 0; i < 8; ++i) {
585 for (let j = 0; j < 64; ++j) 605 for (let j = 0; j < 64; ++j)
586 data.setUint8(i * j, j & 0xff); 606 data.setUint8(i * j, j & 0xff);
587 } 607 }
588 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 608 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
589 return assertRejectsWithNotFoundError(device.isochronousTransferOut( 609 return assertRejectsWithNotFoundError(device.isochronousTransferOut(
(...skipping 16 matching lines...) Expand all
606 return navigator.usb.getDevices().then(devices => { 626 return navigator.usb.getDevices().then(devices => {
607 assert_equals(1, devices.length); 627 assert_equals(1, devices.length);
608 let device = devices[0]; 628 let device = devices[0];
609 return device.open().then(() => { 629 return device.open().then(() => {
610 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]); 630 usb.mockDeviceManager.removeMockDevice(usb.fakeDevices[0]);
611 return assertRejectsWithNotFoundError(device.reset()); 631 return assertRejectsWithNotFoundError(device.reset());
612 }); 632 });
613 }); 633 });
614 }, 'resetDevice rejects when called on a disconnected device'); 634 }, 'resetDevice rejects when called on a disconnected device');
615 </script> 635 </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') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698