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/recording-streams.js'); | |
7 } | |
8 | |
9 promise_test(() => { | |
10 const ws = new WritableStream({ | |
11 close() { | |
12 return 'Hello'; | |
13 } | |
14 }); | |
15 | |
16 const writer = ws.getWriter(); | |
17 | |
18 const closePromise = writer.close(); | |
19 return closePromise.then(value => assert_equals(value, undefined, 'fulfillment
value must be undefined')); | |
20 }, 'fulfillment value of ws.close() call must be undefined even if the underlyin
g sink returns a non-undefined ' + | |
21 'value'); | |
22 | |
23 promise_test(t => { | |
24 const passedError = new Error('error me'); | |
25 let controller; | |
26 const ws = new WritableStream({ | |
27 close(c) { | |
28 controller = c; | |
29 return delay(50); | |
30 } | |
31 }); | |
32 | |
33 const writer = ws.getWriter(); | |
34 | |
35 return Promise.all([ | |
36 writer.close(), | |
37 delay(10).then(() => controller.error(passedError)), | |
38 promise_rejects(t, passedError, writer.closed, | |
39 'closed promise should be rejected with the passed error'), | |
40 delay(70).then(() => promise_rejects(t, passedError, writer.closed, 'closed
should stay rejected')) | |
41 ]); | |
42 }, 'when sink calls error asynchronously while closing, the stream should become
errored'); | |
43 | |
44 promise_test(t => { | |
45 const passedError = new Error('error me'); | |
46 const ws = new WritableStream({ | |
47 close(controller) { | |
48 controller.error(passedError); | |
49 } | |
50 }); | |
51 | |
52 const writer = ws.getWriter(); | |
53 | |
54 return writer.close().then(() => promise_rejects(t, passedError, writer.closed
, 'closed should stay rejected')); | |
55 }, 'when sink calls error synchronously while closing, the stream should become
errored'); | |
56 | |
57 promise_test(() => { | |
58 const ws = recordingWritableStream(); | |
59 | |
60 const writer = ws.getWriter(); | |
61 | |
62 return writer.ready.then(() => { | |
63 assert_equals(writer.desiredSize, 1, 'desiredSize should be 1'); | |
64 | |
65 writer.close(); | |
66 assert_equals(writer.desiredSize, 1, 'desiredSize should be still 1'); | |
67 | |
68 return writer.ready.then(v => { | |
69 assert_equals(v, undefined, 'ready promise should be fulfilled with undefi
ned'); | |
70 assert_array_equals(ws.events, ['close'], 'write and abort should not be c
alled'); | |
71 }); | |
72 }); | |
73 }, 'when close is called on a WritableStream in writable state, ready should ret
urn a fulfilled promise'); | |
74 | |
75 promise_test(() => { | |
76 const ws = recordingWritableStream({ | |
77 write() { | |
78 return new Promise(() => {}); | |
79 } | |
80 }); | |
81 | |
82 const writer = ws.getWriter(); | |
83 | |
84 return writer.ready.then(() => { | |
85 writer.write('a'); | |
86 | |
87 assert_equals(writer.desiredSize, 0, 'desiredSize should be 0'); | |
88 | |
89 let calledClose = false; | |
90 return Promise.all([ | |
91 writer.ready.then(v => { | |
92 assert_equals(v, undefined, 'ready promise should be fulfilled with unde
fined'); | |
93 assert_true(calledClose, 'ready should not be fulfilled before writer.cl
ose() is called'); | |
94 assert_array_equals(ws.events, ['write', 'a'], 'sink abort() should not
be called'); | |
95 }), | |
96 flushAsyncEvents().then(() => { | |
97 writer.close(); | |
98 calledClose = true; | |
99 }) | |
100 ]); | |
101 }); | |
102 }, 'when close is called on a WritableStream in waiting state, ready promise sho
uld be fulfilled'); | |
103 | |
104 promise_test(() => { | |
105 let asyncCloseFinished = false; | |
106 const ws = recordingWritableStream({ | |
107 close() { | |
108 return flushAsyncEvents().then(() => { | |
109 asyncCloseFinished = true; | |
110 }); | |
111 } | |
112 }); | |
113 | |
114 const writer = ws.getWriter(); | |
115 return writer.ready.then(() => { | |
116 writer.write('a'); | |
117 | |
118 writer.close(); | |
119 | |
120 return writer.ready.then(v => { | |
121 assert_false(asyncCloseFinished, 'ready promise should be fulfilled before
async close completes'); | |
122 assert_equals(v, undefined, 'ready promise should be fulfilled with undefi
ned'); | |
123 assert_array_equals(ws.events, ['write', 'a', 'close'], 'sink abort() shou
ld not be called'); | |
124 }); | |
125 }); | |
126 }, 'when close is called on a WritableStream in waiting state, ready should be f
ulfilled immediately even if close ' + | |
127 'takes a long time'); | |
128 | |
129 promise_test(t => { | |
130 const rejection = { name: 'letter' }; | |
131 const ws = new WritableStream({ | |
132 close() { | |
133 return { | |
134 then(onFulfilled, onRejected) { onRejected(rejection); } | |
135 }; | |
136 } | |
137 }); | |
138 return promise_rejects(t, rejection, ws.getWriter().close(), 'close() should r
eturn a rejection'); | |
139 }, 'returning a thenable from close() should work'); | |
140 | |
141 promise_test(t => { | |
142 const ws = new WritableStream(); | |
143 const writer = ws.getWriter(); | |
144 return writer.ready.then(() => { | |
145 const closePromise = writer.close(); | |
146 const closedPromise = writer.closed; | |
147 writer.releaseLock(); | |
148 return Promise.all([ | |
149 closePromise, | |
150 promise_rejects(t, new TypeError(), closedPromise, '.closed promise should
be rejected') | |
151 ]); | |
152 }); | |
153 }, 'releaseLock() should not change the result of sync close()'); | |
154 | |
155 promise_test(t => { | |
156 const ws = new WritableStream({ | |
157 close() { | |
158 return flushAsyncEvents(); | |
159 } | |
160 }); | |
161 const writer = ws.getWriter(); | |
162 return writer.ready.then(() => { | |
163 const closePromise = writer.close(); | |
164 const closedPromise = writer.closed; | |
165 writer.releaseLock(); | |
166 return Promise.all([ | |
167 closePromise, | |
168 promise_rejects(t, new TypeError(), closedPromise, '.closed promise should
be rejected') | |
169 ]); | |
170 }); | |
171 }, 'releaseLock() should not change the result of async close()'); | |
172 | |
173 promise_test(() => { | |
174 let resolveClose; | |
175 const ws = new WritableStream({ | |
176 close() { | |
177 const promise = new Promise(resolve => { | |
178 resolveClose = resolve; | |
179 }); | |
180 return promise; | |
181 } | |
182 }); | |
183 const writer = ws.getWriter(); | |
184 const closePromise = writer.close(); | |
185 writer.releaseLock(); | |
186 return delay(0).then(() => { | |
187 resolveClose(); | |
188 return closePromise.then(() => { | |
189 assert_equals(ws.getWriter().desiredSize, 0, 'desiredSize should be 0'); | |
190 }); | |
191 }); | |
192 }, 'close() should set state to CLOSED even if writer has detached'); | |
193 | |
194 promise_test(() => { | |
195 let resolveClose; | |
196 const ws = new WritableStream({ | |
197 close() { | |
198 const promise = new Promise(resolve => { | |
199 resolveClose = resolve; | |
200 }); | |
201 return promise; | |
202 } | |
203 }); | |
204 const writer = ws.getWriter(); | |
205 writer.close(); | |
206 writer.releaseLock(); | |
207 return delay(0).then(() => { | |
208 const abortingWriter = ws.getWriter(); | |
209 const abortPromise = abortingWriter.abort(); | |
210 abortingWriter.releaseLock(); | |
211 resolveClose(); | |
212 return abortPromise; | |
213 }); | |
214 }, 'the promise returned by async abort during close should resolve'); | |
215 | |
216 done(); | |
OLD | NEW |