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 |