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

Side by Side Diff: third_party/WebKit/LayoutTests/http/tests/streams/resources/rs-test-templates.js

Issue 1404523005: Implement author-constructible ReadableStream using V8 extras (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Minor test tweaks Created 5 years 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
OLDNEW
(Empty)
1 'use strict';
2
3 // These tests can be run against any readable stream produced by the web platfo rm that meets the given descriptions.
4 // For readable stream tests, the factory should return the stream. For reader t ests, the factory should return a
5 // { stream, reader } object. (You can use this to vary the time at which you ac quire a reader.)
6
7 self.templatedRSEmpty = (label, factory) => {
8 test(() => {}, 'Running templatedRSEmpty with ' + label);
9
10 test(() => {
11
12 const rs = factory();
13
14 assert_equals(typeof rs.locked, 'boolean', 'has a boolean locked getter');
15 assert_equals(typeof rs.cancel, 'function', 'has a cancel method');
16 assert_equals(typeof rs.getReader, 'function', 'has a getReader method');
17 assert_equals(typeof rs.tee, 'function', 'has a tee method');
18
19 }, 'instances have the correct methods and properties');
20 };
21
22 self.templatedRSClosed = (label, factory) => {
23 test(() => {}, 'Running templatedRSClosed with ' + label);
24
25 promise_test(() => {
26
27 const rs = factory();
28 const cancelPromise1 = rs.cancel();
29 const cancelPromise2 = rs.cancel();
30
31 assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should ret urn distinct promises');
32
33 return Promise.all([
34 cancelPromise1.then(v => assert_equals(v, undefined, 'first cancel() call should fulfill with undefined')),
35 cancelPromise2.then(v => assert_equals(v, undefined, 'second cancel() call should fulfill with undefined'))
36 ]);
37
38 }, 'cancel() should return a distinct fulfilled promise each time');
39
40 test(() => {
41
42 const rs = factory();
43 assert_false(rs.locked, 'locked getter should return false');
44
45 }, 'locked should be false');
46
47 test(() => {
48
49 const rs = factory();
50 rs.getReader(); // getReader() should not throw.
51
52 }, 'getReader() should be OK');
53
54 test(() => {
55
56 const rs = factory();
57
58 const reader = rs.getReader();
59 reader.releaseLock();
60
61 const reader2 = rs.getReader(); // Getting a second reader should not throw.
62 reader2.releaseLock();
63
64 rs.getReader(); // Getting a third reader should not throw.
65
66 }, 'should be able to acquire multiple readers if they are released in success ion');
67
68 test(() => {
69
70 const rs = factory();
71
72 rs.getReader();
73
74 assert_throws(new TypeError(), () => rs.getReader(), 'getting a second reade r should throw');
75 assert_throws(new TypeError(), () => rs.getReader(), 'getting a third reader should throw');
76
77 }, 'should not be able to acquire a second reader if we don\'t release the fir st one');
78 };
79
80 self.templatedRSErrored = (label, factory, error) => {
81 test(() => {}, 'Running templatedRSErrored with ' + label);
82
83 promise_test(t => {
84
85 const rs = factory();
86 const reader = rs.getReader();
87
88 return Promise.all([
89 promise_rejects(t, error, reader.closed),
90 promise_rejects(t, error, reader.read())
91 ]);
92
93 }, 'getReader() should return a reader that acts errored');
94
95 promise_test(t => {
96
97 const rs = factory();
98 const reader = rs.getReader();
99
100 return Promise.all([
101 promise_rejects(t, error, reader.read()),
102 promise_rejects(t, error, reader.read()),
103 promise_rejects(t, error, reader.closed)
104 ]);
105
106 }, 'read() twice should give the error each time');
107
108 test(() => {
109 const rs = factory();
110
111 assert_false(rs.locked, 'locked getter should return false');
112 }, 'locked should be false');
113 };
114
115 self.templatedRSErroredSyncOnly = (label, factory, error) => {
116 test(() => {}, 'Running templatedRSErroredSyncOnly with ' + label);
117
118 promise_test(t => {
119
120 const rs = factory();
121 rs.getReader().releaseLock();
122 const reader = rs.getReader(); // Calling getReader() twice does not throw ( the stream is not locked).
123
124 return promise_rejects(t, error, reader.closed);
125
126 }, 'should be able to obtain a second reader, with the correct closed promise' );
127
128 test(() => {
129
130 const rs = factory();
131 rs.getReader();
132
133 assert_throws(new TypeError(), () => rs.getReader(), 'getting a second reade r should throw a TypeError');
134 assert_throws(new TypeError(), () => rs.getReader(), 'getting a third reader should throw a TypeError');
135
136 }, 'should not be able to obtain additional readers if we don\'t release the f irst lock');
137
138 promise_test(t => {
139
140 const rs = factory();
141 const cancelPromise1 = rs.cancel();
142 const cancelPromise2 = rs.cancel();
143
144 assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should ret urn distinct promises');
145
146 return Promise.all([
147 promise_rejects(t, error, cancelPromise1),
148 promise_rejects(t, error, cancelPromise2)
149 ]);
150
151 }, 'cancel() should return a distinct rejected promise each time');
152
153 promise_test(t => {
154
155 const rs = factory();
156 const reader = rs.getReader();
157 const cancelPromise1 = reader.cancel();
158 const cancelPromise2 = reader.cancel();
159
160 assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should ret urn distinct promises');
161
162 return Promise.all([
163 promise_rejects(t, error, cancelPromise1),
164 promise_rejects(t, error, cancelPromise2)
165 ]);
166
167 }, 'reader cancel() should return a distinct rejected promise each time');
168 };
169
170 self.templatedRSEmptyReader = (label, factory) => {
171 test(() => {}, 'Running templatedRSEmptyReader with ' + label);
172
173 test(() => {
174
175 const reader = factory().reader;
176
177 assert_true('closed' in reader, 'has a closed property');
178 assert_equals(typeof reader.closed.then, 'function', 'closed property is the nable');
179
180 assert_equals(typeof reader.cancel, 'function', 'has a cancel method');
181 assert_equals(typeof reader.read, 'function', 'has a read method');
182 assert_equals(typeof reader.releaseLock, 'function', 'has a releaseLock meth od');
183
184 }, 'instances have the correct methods and properties');
185
186 test(() => {
187
188 const stream = factory().stream;
189
190 assert_true(stream.locked, 'locked getter should return true');
191
192 }, 'locked should be true');
193
194 promise_test(t => {
195
196 const reader = factory().reader;
197
198 reader.read().then(
199 t.unreached_func('read() should not fulfill'),
200 t.unreached_func('read() should not reject')
201 );
202
203 return delay(500);
204
205 }, 'read() should never settle');
206
207 promise_test(t => {
208
209 const reader = factory().reader;
210
211 reader.read().then(
212 t.unreached_func('read() should not fulfill'),
213 t.unreached_func('read() should not reject')
214 );
215
216 reader.read().then(
217 t.unreached_func('read() should not fulfill'),
218 t.unreached_func('read() should not reject')
219 );
220
221 return delay(500);
222
223 }, 'two read()s should both never settle');
224
225 test(() => {
226
227 const reader = factory().reader;
228 assert_not_equals(reader.read(), reader.read(), 'the promises returned shoul d be distinct');
229
230 }, 'read() should return distinct promises each time');
231
232 test(() => {
233
234 const stream = factory().stream;
235 assert_throws(new TypeError(), () => stream.getReader(), 'stream.getReader() should throw a TypeError');
236
237 }, 'getReader() again on the stream should fail');
238
239 promise_test(t => {
240
241 const streamAndReader = factory();
242 const stream = streamAndReader.stream;
243 const reader = streamAndReader.reader;
244
245 reader.read().then(
246 t.unreached_func('first read() should not fulfill'),
247 t.unreached_func('first read() should not reject')
248 );
249
250 reader.read().then(
251 t.unreached_func('second read() should not fulfill'),
252 t.unreached_func('second read() should not reject')
253 );
254
255 reader.closed.then(
256 t.unreached_func('closed should not fulfill'),
257 t.unreached_func('closed should not reject')
258 );
259
260 assert_throws(new TypeError(), () => reader.releaseLock(), 'releaseLock shou ld throw a TypeError');
261
262 assert_true(stream.locked, 'the stream should still be locked');
263
264 return delay(500);
265
266 }, 'releasing the lock with pending read requests should throw but the read re quests should stay pending');
267
268 promise_test(t => {
269
270 const reader = factory().reader;
271 reader.releaseLock();
272
273 return Promise.all([
274 promise_rejects(t, new TypeError(), reader.read()),
275 promise_rejects(t, new TypeError(), reader.read())
276 ]);
277
278 }, 'releasing the lock should cause further read() calls to reject with a Type Error');
279
280 promise_test(t => {
281
282 const reader = factory().reader;
283
284 const closedBefore = reader.closed;
285 reader.releaseLock();
286 const closedAfter = reader.closed;
287
288 assert_equals(closedBefore, closedAfter, 'the closed promise should not chan ge identity');
289
290 return promise_rejects(t, new TypeError(), closedBefore);
291
292 }, 'releasing the lock should cause closed calls to reject with a TypeError');
293
294 test(() => {
295
296 const streamAndReader = factory();
297 const stream = streamAndReader.stream;
298 const reader = streamAndReader.reader;
299
300 reader.releaseLock();
301 assert_false(stream.locked, 'locked getter should return false');
302
303 }, 'releasing the lock should cause locked to become false');
304
305 promise_test(() => {
306
307 const reader = factory().reader;
308 reader.cancel();
309
310 return reader.read().then(r => {
311 assert_object_equals(r, { value: undefined, done: true }, 'read()ing from the reader should give a done result');
312 });
313
314 }, 'canceling via the reader should cause the reader to act closed');
315
316 promise_test(t => {
317
318 const stream = factory().stream;
319 return promise_rejects(t, new TypeError(), stream.cancel());
320
321 }, 'canceling via the stream should fail');
322 };
323
324 self.templatedRSClosedReader = (label, factory) => {
325 test(() => {}, 'Running templatedRSClosedReader with ' + label);
326
327 promise_test(() => {
328
329 const reader = factory().reader;
330
331 return reader.read().then(v => {
332 assert_object_equals(v, { value: undefined, done: true }, 'read() should f ulfill correctly');
333 });
334
335 }, 'read() should fulfill with { value: undefined, done: true }');
336
337 promise_test(() => {
338
339 const reader = factory().reader;
340
341 return Promise.all([
342 reader.read().then(v => {
343 assert_object_equals(v, { value: undefined, done: true }, 'read() should fulfill correctly');
344 }),
345 reader.read().then(v => {
346 assert_object_equals(v, { value: undefined, done: true }, 'read() should fulfill correctly');
347 })
348 ]);
349
350 }, 'read() multiple times should fulfill with { value: undefined, done: true } ');
351
352 promise_test(() => {
353
354 const reader = factory().reader;
355
356 return reader.read().then(() => reader.read()).then(v => {
357 assert_object_equals(v, { value: undefined, done: true }, 'read() should f ulfill correctly');
358 });
359
360 }, 'read() should work when used within another read() fulfill callback');
361
362 promise_test(() => {
363
364 const reader = factory().reader;
365
366 return reader.closed.then(v => assert_equals(v, undefined, 'reader closed sh ould fulfill with undefined'));
367
368 }, 'closed should fulfill with undefined');
369
370 promise_test(t => {
371
372 const reader = factory().reader;
373
374 const closedBefore = reader.closed;
375 reader.releaseLock();
376 const closedAfter = reader.closed;
377
378 assert_not_equals(closedBefore, closedAfter, 'the closed promise should chan ge identity');
379
380 return Promise.all([
381 closedBefore.then(v => assert_equals(v, undefined, 'reader.closed acquired before release should fulfill')),
382 promise_rejects(t, new TypeError(), closedAfter)
383 ]);
384
385 }, 'releasing the lock should cause closed to reject and change identity');
386
387 promise_test(() => {
388
389 const reader = factory().reader;
390 const cancelPromise1 = reader.cancel();
391 const cancelPromise2 = reader.cancel();
392 const closedReaderPromise = reader.closed;
393
394 assert_not_equals(cancelPromise1, cancelPromise2, 'cancel() calls should ret urn distinct promises');
395 assert_not_equals(cancelPromise1, closedReaderPromise, 'cancel() promise 1 s hould be distinct from reader.closed');
396 assert_not_equals(cancelPromise2, closedReaderPromise, 'cancel() promise 2 s hould be distinct from reader.closed');
397
398 return Promise.all([
399 cancelPromise1.then(v => assert_equals(v, undefined, 'first cancel() shoul d fulfill with undefined')),
400 cancelPromise2.then(v => assert_equals(v, undefined, 'second cancel() shou ld fulfill with undefined'))
401 ]);
402
403 }, 'cancel() should return a distinct fulfilled promise each time');
404 };
405
406 self.templatedRSErroredReader = (label, factory, error) => {
407 test(() => {}, 'Running templatedRSErroredReader with ' + label);
408
409 promise_test(t => {
410
411 const reader = factory().reader;
412 return promise_rejects(t, error, reader.closed);
413
414 }, 'closed should reject with the error');
415
416 promise_test(t => {
417
418 const reader = factory().reader;
419 const closedBefore = reader.closed;
420
421 return promise_rejects(t, error, closedBefore).then(() => {
422 reader.releaseLock();
423
424 const closedAfter = reader.closed;
425 assert_not_equals(closedBefore, closedAfter, 'the closed promise should ch ange identity');
426
427 return promise_rejects(t, new TypeError(), closedAfter);
428 });
429
430 }, 'releasing the lock should cause closed to reject and change identity');
431
432 promise_test(t => {
433
434 const reader = factory().reader;
435 return promise_rejects(t, error, reader.read());
436
437 }, 'read() should reject with the error');
438 };
439
440 self.templatedRSTwoChunksOpenReader = (label, factory, chunks) => {
441 test(() => {}, 'Running templatedRSTwoChunksOpenReader with ' + label);
442
443 promise_test(() => {
444
445 const reader = factory().reader;
446
447 return Promise.all([
448 reader.read().then(r => {
449 assert_object_equals(r, { value: chunks[0], done: false }, 'first result should be correct');
450 }),
451 reader.read().then(r => {
452 assert_object_equals(r, { value: chunks[1], done: false }, 'second resul t should be correct');
453 })
454 ]);
455
456 }, 'calling read() twice without waiting will eventually give both chunks (seq uential)');
457
458 promise_test(() => {
459
460 const reader = factory().reader;
461
462 return reader.read().then(r => {
463 assert_object_equals(r, { value: chunks[0], done: false }, 'first result s hould be correct');
464
465 return reader.read().then(r2 => {
466 assert_object_equals(r2, { value: chunks[1], done: false }, 'second resu lt should be correct');
467 });
468 });
469
470 }, 'calling read() twice without waiting will eventually give both chunks (nes ted)');
471
472 test(() => {
473
474 const reader = factory().reader;
475 assert_not_equals(reader.read(), reader.read(), 'the promises returned shoul d be distinct');
476
477 }, 'read() should return distinct promises each time');
478
479 promise_test(() => {
480
481 const reader = factory().reader;
482
483 const promise1 = reader.closed.then(v => {
484 assert_equals(v, undefined, 'reader closed should fulfill with undefined') ;
485 });
486
487 const promise2 = reader.read().then(r => {
488 assert_object_equals(r, { value: chunks[0], done: false },
489 'promise returned before cancellation should fulfill with a chunk');
490 });
491
492 reader.cancel();
493
494 const promise3 = reader.read().then(r => {
495 assert_object_equals(r, { value: undefined, done: true },
496 'promise returned after cancellation should fulfill w ith an end-of-stream signal');
497 });
498
499 return Promise.all([promise1, promise2, promise3]);
500
501 }, 'cancel() after a read() should still give that single read result');
502 };
503
504 self.templatedRSTwoChunksClosedReader = function (label, factory, chunks) {
505 test(() => {}, 'Running templatedRSTwoChunksClosedReader with ' + label);
506
507 promise_test(() => {
508
509 const reader = factory().reader;
510
511 return Promise.all([
512 reader.read().then(r => {
513 assert_object_equals(r, { value: chunks[0], done: false }, 'first result should be correct');
514 }),
515 reader.read().then(r => {
516 assert_object_equals(r, { value: chunks[1], done: false }, 'second resul t should be correct');
517 }),
518 reader.read().then(r => {
519 assert_object_equals(r, { value: undefined, done: true }, 'third result should be correct');
520 })
521 ]);
522
523 }, 'third read(), without waiting, should give { value: undefined, done: true } (sequential)');
524
525 promise_test(() => {
526
527 const reader = factory().reader;
528
529 return reader.read().then(r => {
530 assert_object_equals(r, { value: chunks[0], done: false }, 'first result s hould be correct');
531
532 return reader.read().then(r2 => {
533 assert_object_equals(r2, { value: chunks[1], done: false }, 'second resu lt should be correct');
534
535 return reader.read().then(r3 => {
536 assert_object_equals(r3, { value: undefined, done: true }, 'third resu lt should be correct');
537 });
538 });
539 });
540
541 }, 'third read(), without waiting, should give { value: undefined, done: true } (nested)');
542
543 promise_test(() => {
544
545 const streamAndReader = factory();
546 const stream = streamAndReader.stream;
547 const reader = streamAndReader.reader;
548
549 assert_true(stream.locked, 'stream should start locked');
550
551 const promise = reader.closed.then(v => {
552 assert_equals(v, undefined, 'reader closed should fulfill with undefined') ;
553 assert_true(stream.locked, 'stream should remain locked');
554 });
555
556 reader.read();
557 reader.read();
558
559 return promise;
560
561 }, 'draining the stream via read() should cause the reader closed promise to f ulfill, but locked stays true');
562
563 promise_test(() => {
564
565 const streamAndReader = factory();
566 const stream = streamAndReader.stream;
567 const reader = streamAndReader.reader;
568
569 const promise = reader.closed.then(() => {
570 assert_true(stream.locked, 'the stream should start locked');
571 reader.releaseLock(); // Releasing the lock after reader closed should not throw.
572 assert_false(stream.locked, 'the stream should end unlocked');
573 });
574
575 reader.read();
576 reader.read();
577
578 return promise;
579
580 }, 'releasing the lock after the stream is closed should cause locked to becom e false');
581
582 promise_test(t => {
583
584 const reader = factory().reader;
585
586 reader.releaseLock();
587
588 return Promise.all([
589 promise_rejects(t, new TypeError(), reader.read()),
590 promise_rejects(t, new TypeError(), reader.read()),
591 promise_rejects(t, new TypeError(), reader.read())
592 ]);
593
594 }, 'releasing the lock should cause further read() calls to reject with a Type Error');
595
596 promise_test(() => {
597
598 const streamAndReader = factory();
599 const stream = streamAndReader.stream;
600 const reader = streamAndReader.reader;
601
602 const readerClosed = reader.closed;
603
604 assert_equals(reader.closed, readerClosed, 'accessing reader.closed twice in succession gives the same value');
605
606 const promise = reader.read().then(() => {
607 assert_equals(reader.closed, readerClosed, 'reader.closed is the same afte r read() fulfills');
608
609 reader.releaseLock();
610
611 assert_equals(reader.closed, readerClosed, 'reader.closed is the same afte r releasing the lock');
612
613 const newReader = stream.getReader();
614 return newReader.read();
615 });
616
617 assert_equals(reader.closed, readerClosed, 'reader.closed is the same after calling read()');
618
619 return promise;
620
621 }, 'reader\'s closed property always returns the same promise');
622 };
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698