OLD | NEW |
(Empty) | |
| 1 'use strict'; |
| 2 |
| 3 if (self.importScripts) { |
| 4 self.importScripts('/resources/testharness.js'); |
| 5 self.importScripts('../resources/test-utils.js'); |
| 6 self.importScripts('../resources/rs-test-templates.js'); |
| 7 } |
| 8 |
| 9 // Run the readable stream test templates against readable streams created direc
tly using the constructor |
| 10 |
| 11 const theError = { name: 'boo!' }; |
| 12 const chunks = ['a', 'b']; |
| 13 |
| 14 templatedRSEmpty('ReadableStream (empty)', () => { |
| 15 return new ReadableStream(); |
| 16 }); |
| 17 |
| 18 templatedRSEmptyReader('ReadableStream (empty) reader', () => { |
| 19 return streamAndDefaultReader(new ReadableStream()); |
| 20 }); |
| 21 |
| 22 templatedRSClosed('ReadableStream (closed via call in start)', () => { |
| 23 return new ReadableStream({ |
| 24 start(c) { |
| 25 c.close(); |
| 26 } |
| 27 }); |
| 28 }); |
| 29 |
| 30 templatedRSClosedReader('ReadableStream reader (closed before getting reader)',
() => { |
| 31 let controller; |
| 32 const stream = new ReadableStream({ |
| 33 start(c) { |
| 34 controller = c; |
| 35 } |
| 36 }); |
| 37 controller.close(); |
| 38 const result = streamAndDefaultReader(stream); |
| 39 return result; |
| 40 }); |
| 41 |
| 42 templatedRSClosedReader('ReadableStream reader (closed after getting reader)', (
) => { |
| 43 let controller; |
| 44 const stream = new ReadableStream({ |
| 45 start(c) { |
| 46 controller = c; |
| 47 } |
| 48 }); |
| 49 const result = streamAndDefaultReader(stream); |
| 50 controller.close(); |
| 51 return result; |
| 52 }); |
| 53 |
| 54 templatedRSClosed('ReadableStream (closed via cancel)', () => { |
| 55 const stream = new ReadableStream(); |
| 56 stream.cancel(); |
| 57 return stream; |
| 58 }); |
| 59 |
| 60 templatedRSClosedReader('ReadableStream reader (closed via cancel after getting
reader)', () => { |
| 61 const stream = new ReadableStream(); |
| 62 const result = streamAndDefaultReader(stream); |
| 63 result.reader.cancel(); |
| 64 return result; |
| 65 }); |
| 66 |
| 67 templatedRSErrored('ReadableStream (errored via call in start)', () => { |
| 68 return new ReadableStream({ |
| 69 start(c) { |
| 70 c.error(theError); |
| 71 } |
| 72 }); |
| 73 }, theError); |
| 74 |
| 75 templatedRSErroredSyncOnly('ReadableStream (errored via call in start)', () => { |
| 76 return new ReadableStream({ |
| 77 start(c) { |
| 78 c.error(theError); |
| 79 } |
| 80 }); |
| 81 }, theError); |
| 82 |
| 83 templatedRSErrored('ReadableStream (errored via returning a rejected promise in
start)', () => { |
| 84 return new ReadableStream({ |
| 85 start() { |
| 86 return Promise.reject(theError); |
| 87 } |
| 88 }); |
| 89 }, theError); |
| 90 |
| 91 templatedRSErroredReader('ReadableStream (errored via returning a rejected promi
se in start) reader', () => { |
| 92 return streamAndDefaultReader(new ReadableStream({ |
| 93 start() { |
| 94 return Promise.reject(theError); |
| 95 } |
| 96 })); |
| 97 }, theError); |
| 98 |
| 99 templatedRSErroredReader('ReadableStream reader (errored before getting reader)'
, () => { |
| 100 let controller; |
| 101 const stream = new ReadableStream({ |
| 102 start(c) { |
| 103 controller = c; |
| 104 } |
| 105 }); |
| 106 controller.error(theError); |
| 107 return streamAndDefaultReader(stream); |
| 108 }, theError); |
| 109 |
| 110 templatedRSErroredReader('ReadableStream reader (errored after getting reader)',
() => { |
| 111 let controller; |
| 112 const result = streamAndDefaultReader(new ReadableStream({ |
| 113 start(c) { |
| 114 controller = c; |
| 115 } |
| 116 })); |
| 117 controller.error(theError); |
| 118 return result; |
| 119 }, theError); |
| 120 |
| 121 templatedRSTwoChunksOpenReader('ReadableStream (two chunks enqueued, still open)
reader', () => { |
| 122 return streamAndDefaultReader(new ReadableStream({ |
| 123 start(c) { |
| 124 c.enqueue(chunks[0]); |
| 125 c.enqueue(chunks[1]); |
| 126 } |
| 127 })); |
| 128 }, chunks); |
| 129 |
| 130 templatedRSTwoChunksClosedReader('ReadableStream (two chunks enqueued, then clos
ed) reader', () => { |
| 131 let doClose; |
| 132 const stream = new ReadableStream({ |
| 133 start(c) { |
| 134 c.enqueue(chunks[0]); |
| 135 c.enqueue(chunks[1]); |
| 136 doClose = c.close.bind(c); |
| 137 } |
| 138 }); |
| 139 const result = streamAndDefaultReader(stream); |
| 140 doClose(); |
| 141 return result; |
| 142 }, chunks); |
| 143 |
| 144 function streamAndDefaultReader(stream) { |
| 145 return { stream, reader: stream.getReader() }; |
| 146 } |
| 147 |
| 148 done(); |
OLD | NEW |