From 7b6126a59af1b78642f936ced6bf519f1fe4278b Mon Sep 17 00:00:00 2001 From: Daeyeon Jeong Date: Thu, 18 Aug 2022 03:36:25 +0900 Subject: [PATCH] test: update Web Streams WPT This updates the tests and the status file via running `git node wpt streams`. Signed-off-by: Daeyeon Jeong daeyeon.dev@gmail.com PR-URL: https://github.com/nodejs/node/pull/44234 Reviewed-By: Filip Skokan Reviewed-By: Joyee Cheung Reviewed-By: Antoine du Hamel --- test/fixtures/wpt/README.md | 2 +- .../streams/idlharness-shadowrealm.window.js | 2 + test/fixtures/wpt/streams/piping/abort.any.js | 175 ++-- .../piping/close-propagation-backward.any.js | 2 +- .../piping/close-propagation-forward.any.js | 2 +- .../piping/error-propagation-backward.any.js | 2 +- .../piping/error-propagation-forward.any.js | 2 +- .../wpt/streams/piping/flow-control.any.js | 2 +- .../wpt/streams/piping/general.any.js | 2 +- .../piping/multiple-propagation.any.js | 2 +- .../wpt/streams/piping/pipe-through.any.js | 65 +- .../streams/piping/then-interception.any.js | 2 +- .../streams/piping/throwing-options.any.js | 2 +- .../streams/piping/transform-streams.any.js | 2 +- .../wpt/streams/queuing-strategies.any.js | 17 +- .../bad-buffers-and-views.any.js | 51 +- .../construct-byob-request.any.js | 2 +- .../readable-byte-streams/general.any.js | 593 ++++++++++- .../non-transferable-buffers.any.js | 2 +- .../respond-after-enqueue.any.js | 55 + .../streams/readable-byte-streams/tee.any.js | 936 ++++++++++++++++++ .../readable-streams/async-iterator.any.js | 2 +- .../readable-streams/bad-strategies.any.js | 2 +- .../bad-underlying-sources.any.js | 2 +- .../streams/readable-streams/cancel.any.js | 2 +- .../readable-streams/constructor.any.js | 2 +- .../count-queuing-strategy-integration.any.js | 2 +- .../readable-streams/crashtests/empty.js | 0 .../crashtests/strategy-worker-terminate.html | 10 + .../crashtests/strategy-worker.js | 4 + .../cross-realm-crash.window.js | 13 + .../readable-streams/default-reader.any.js | 27 +- .../floating-point-total-queue-size.any.js | 2 +- .../garbage-collection.any.js | 18 +- .../streams/readable-streams/general.any.js | 3 +- .../wpt/streams/readable-streams/global.html | 162 +++ .../readable-streams/patched-global.any.js | 3 +- .../reentrant-strategies.any.js | 2 +- .../wpt/streams/readable-streams/tee.any.js | 112 +-- .../streams/readable-streams/templated.any.js | 2 +- .../streams/resources/recording-streams.js | 1 + .../streams/resources/rs-test-templates.js | 121 ++- .../wpt/streams/resources/test-utils.js | 25 +- .../streams/transferable/readable-stream.html | 27 +- .../transfer-with-messageport.window.js | 219 ++++ .../transferable/transform-stream.html | 8 +- .../wpt/streams/transferable/window.html | 11 +- .../streams/transferable/writable-stream.html | 30 +- .../transform-streams/backpressure.any.js | 2 +- .../streams/transform-streams/errors.any.js | 2 +- .../streams/transform-streams/flush.any.js | 2 +- .../streams/transform-streams/general.any.js | 2 +- .../streams/transform-streams/lipfuzz.any.js | 2 +- .../transform-streams/patched-global.any.js | 4 +- .../transform-streams/properties.any.js | 2 +- .../reentrant-strategies.any.js | 2 +- .../transform-streams/strategies.any.js | 2 +- .../transform-streams/terminate.any.js | 2 +- .../streams/writable-streams/aborting.any.js | 11 +- .../writable-streams/bad-strategies.any.js | 2 +- .../bad-underlying-sinks.any.js | 2 +- .../byte-length-queuing-strategy.any.js | 2 +- .../wpt/streams/writable-streams/close.any.js | 2 +- .../writable-streams/constructor.any.js | 2 +- .../count-queuing-strategy.any.js | 2 +- .../wpt/streams/writable-streams/error.any.js | 2 +- .../floating-point-total-queue-size.any.js | 2 +- .../streams/writable-streams/general.any.js | 2 +- .../writable-streams/properties.any.js | 2 +- .../reentrant-strategy.any.js | 2 +- .../wpt/streams/writable-streams/start.any.js | 2 +- .../wpt/streams/writable-streams/write.any.js | 2 +- test/fixtures/wpt/versions.json | 2 +- test/wpt/status/streams.json | 107 ++ 74 files changed, 2610 insertions(+), 290 deletions(-) create mode 100644 test/fixtures/wpt/streams/idlharness-shadowrealm.window.js create mode 100644 test/fixtures/wpt/streams/readable-byte-streams/respond-after-enqueue.any.js create mode 100644 test/fixtures/wpt/streams/readable-byte-streams/tee.any.js create mode 100644 test/fixtures/wpt/streams/readable-streams/crashtests/empty.js create mode 100644 test/fixtures/wpt/streams/readable-streams/crashtests/strategy-worker-terminate.html create mode 100644 test/fixtures/wpt/streams/readable-streams/crashtests/strategy-worker.js create mode 100644 test/fixtures/wpt/streams/readable-streams/cross-realm-crash.window.js create mode 100644 test/fixtures/wpt/streams/readable-streams/global.html create mode 100644 test/fixtures/wpt/streams/transferable/transfer-with-messageport.window.js diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md index 3bb20b27b93720..63175ead2a9c2d 100644 --- a/test/fixtures/wpt/README.md +++ b/test/fixtures/wpt/README.md @@ -24,7 +24,7 @@ Last update: - interfaces: https://github.com/web-platform-tests/wpt/tree/fc086c82d5/interfaces - performance-timeline: https://github.com/web-platform-tests/wpt/tree/17ebc3aea0/performance-timeline - resources: https://github.com/web-platform-tests/wpt/tree/c5b428f15a/resources -- streams: https://github.com/web-platform-tests/wpt/tree/8f60d94439/streams +- streams: https://github.com/web-platform-tests/wpt/tree/9e5ef42bd3/streams - url: https://github.com/web-platform-tests/wpt/tree/0e5b126cd0/url - user-timing: https://github.com/web-platform-tests/wpt/tree/df24fb604e/user-timing - wasm/jsapi: https://github.com/web-platform-tests/wpt/tree/d8dbe6990b/wasm/jsapi diff --git a/test/fixtures/wpt/streams/idlharness-shadowrealm.window.js b/test/fixtures/wpt/streams/idlharness-shadowrealm.window.js new file mode 100644 index 00000000000000..099b2475ca7e87 --- /dev/null +++ b/test/fixtures/wpt/streams/idlharness-shadowrealm.window.js @@ -0,0 +1,2 @@ +// META: script=/resources/idlharness-shadowrealm.js +idl_test_shadowrealm(["streams"], ["dom"]); diff --git a/test/fixtures/wpt/streams/piping/abort.any.js b/test/fixtures/wpt/streams/piping/abort.any.js index 3fe029de95a1b8..503de9dcaf0893 100644 --- a/test/fixtures/wpt/streams/piping/abort.any.js +++ b/test/fixtures/wpt/streams/piping/abort.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/recording-streams.js // META: script=../resources/test-utils.js 'use strict'; @@ -53,29 +53,28 @@ promise_test(t => { }); }, 'an aborted signal should cause the writable stream to reject with an AbortError'); -promise_test(() => { - let error; - const rs = recordingReadableStream(errorOnPull, hwm0); - const ws = new WritableStream(); - const abortController = new AbortController(); - const signal = abortController.signal; - abortController.abort(); - return rs.pipeTo(ws, { signal }) - .catch(e => { - error = e; - }) - .then(() => Promise.all([ - rs.getReader().closed, - ws.getWriter().closed.catch(e => { - assert_equals(e, error, 'the writable should be errored with the same object'); - }) - ])) - .then(() => { +for (const reason of [null, undefined, error1]) { + promise_test(async t => { + const rs = recordingReadableStream(errorOnPull, hwm0); + const ws = new WritableStream(); + const abortController = new AbortController(); + const signal = abortController.signal; + abortController.abort(reason); + const pipeToPromise = rs.pipeTo(ws, { signal }); + if (reason !== undefined) { + await promise_rejects_exactly(t, reason, pipeToPromise, 'pipeTo rejects with abort reason'); + } else { + await promise_rejects_dom(t, 'AbortError', pipeToPromise, 'pipeTo rejects with AbortError'); + } + const error = await pipeToPromise.catch(e => e); + await rs.getReader().closed; + await promise_rejects_exactly(t, error, ws.getWriter().closed, 'the writable should be errored with the same object'); + assert_equals(signal.reason, error, 'signal.reason should be error'), assert_equals(rs.events.length, 2, 'cancel should have been called'); assert_equals(rs.events[0], 'cancel', 'first event should be cancel'); assert_equals(rs.events[1], error, 'the readable should be canceled with the same object'); - }); -}, 'all the AbortError objects should be the same object'); + }, `(reason: '${reason}') all the error objects should be the same object`); +} promise_test(t => { const rs = recordingReadableStream(errorOnPull, hwm0); @@ -115,61 +114,74 @@ promise_test(t => { }); }, 'preventCancel and preventAbort should prevent canceling the readable and aborting the readable'); -promise_test(t => { - const rs = new ReadableStream({ - start(controller) { - controller.enqueue('a'); - controller.enqueue('b'); - controller.close(); - } - }); - const abortController = new AbortController(); - const signal = abortController.signal; - const ws = recordingWritableStream({ - write() { - abortController.abort(); +for (const reason of [null, undefined, error1]) { + promise_test(async t => { + const rs = new ReadableStream({ + start(controller) { + controller.enqueue('a'); + controller.enqueue('b'); + controller.close(); + } + }); + const abortController = new AbortController(); + const signal = abortController.signal; + const ws = recordingWritableStream({ + write() { + abortController.abort(reason); + } + }); + const pipeToPromise = rs.pipeTo(ws, { signal }); + if (reason !== undefined) { + await promise_rejects_exactly(t, reason, pipeToPromise, 'pipeTo rejects with abort reason'); + } else { + await promise_rejects_dom(t, 'AbortError', pipeToPromise, 'pipeTo rejects with AbortError'); } - }); - return promise_rejects_dom(t, 'AbortError', rs.pipeTo(ws, { signal }), 'pipeTo should reject') - .then(() => { - assert_equals(ws.events.length, 4, 'only chunk "a" should have been written'); - assert_array_equals(ws.events.slice(0, 3), ['write', 'a', 'abort'], 'events should match'); - assert_equals(ws.events[3].name, 'AbortError', 'abort reason should be an AbortError'); - }); -}, 'abort should prevent further reads'); + const error = await pipeToPromise.catch(e => e); + assert_equals(signal.reason, error, 'signal.reason should be error'); + assert_equals(ws.events.length, 4, 'only chunk "a" should have been written'); + assert_array_equals(ws.events.slice(0, 3), ['write', 'a', 'abort'], 'events should match'); + assert_equals(ws.events[3], error, 'abort reason should be error'); + }, `(reason: '${reason}') abort should prevent further reads`); +} -promise_test(t => { - let readController; - const rs = new ReadableStream({ - start(c) { - readController = c; - c.enqueue('a'); - c.enqueue('b'); - } - }); - const abortController = new AbortController(); - const signal = abortController.signal; - let resolveWrite; - const writePromise = new Promise(resolve => { - resolveWrite = resolve; - }); - const ws = recordingWritableStream({ - write() { - return writePromise; +for (const reason of [null, undefined, error1]) { + promise_test(async t => { + let readController; + const rs = new ReadableStream({ + start(c) { + readController = c; + c.enqueue('a'); + c.enqueue('b'); + } + }); + const abortController = new AbortController(); + const signal = abortController.signal; + let resolveWrite; + const writePromise = new Promise(resolve => { + resolveWrite = resolve; + }); + const ws = recordingWritableStream({ + write() { + return writePromise; + } + }, new CountQueuingStrategy({ highWaterMark: Infinity })); + const pipeToPromise = rs.pipeTo(ws, { signal }); + await delay(0); + await abortController.abort(reason); + await readController.close(); // Make sure the test terminates when signal is not implemented. + await resolveWrite(); + if (reason !== undefined) { + await promise_rejects_exactly(t, reason, pipeToPromise, 'pipeTo rejects with abort reason'); + } else { + await promise_rejects_dom(t, 'AbortError', pipeToPromise, 'pipeTo rejects with AbortError'); } - }, new CountQueuingStrategy({ highWaterMark: Infinity })); - const pipeToPromise = rs.pipeTo(ws, { signal }); - return delay(0).then(() => { - abortController.abort(); - readController.close(); // Make sure the test terminates when signal is not implemented. - resolveWrite(); - return promise_rejects_dom(t, 'AbortError', pipeToPromise, 'pipeTo should reject'); - }).then(() => { + const error = await pipeToPromise.catch(e => e); + assert_equals(signal.reason, error, 'signal.reason should be error'); assert_equals(ws.events.length, 6, 'chunks "a" and "b" should have been written'); assert_array_equals(ws.events.slice(0, 5), ['write', 'a', 'write', 'b', 'abort'], 'events should match'); - assert_equals(ws.events[5].name, 'AbortError', 'abort reason should be an AbortError'); - }); -}, 'all pending writes should complete on abort'); + assert_equals(ws.events[5], error, 'abort reason should be error'); + }, `(reason: '${reason}') all pending writes should complete on abort`); +} promise_test(t => { const rs = new ReadableStream({ @@ -373,3 +385,24 @@ promise_test(t => { assert_array_equals(rs.events, ['pull'], 'cancel should not have been called'); }); }, 'abort should do nothing after the writable is errored'); + +promise_test(async t => { + const rs = new ReadableStream({ + pull(c) { + c.enqueue(new Uint8Array([])); + }, + type: "bytes", + }); + const ws = new WritableStream(); + const [first, second] = rs.tee(); + + let aborted = false; + first.pipeTo(ws, { signal: AbortSignal.abort() }).catch(() => { + aborted = true; + }); + await delay(0); + assert_true(!aborted, "pipeTo should not resolve yet"); + await second.cancel(); + await delay(0); + assert_true(aborted, "pipeTo should be aborted now"); +}, "pipeTo on a teed readable byte stream should only be aborted when both branches are aborted"); diff --git a/test/fixtures/wpt/streams/piping/close-propagation-backward.any.js b/test/fixtures/wpt/streams/piping/close-propagation-backward.any.js index bd1e9cb92657b1..5ea47ab85c0c1f 100644 --- a/test/fixtures/wpt/streams/piping/close-propagation-backward.any.js +++ b/test/fixtures/wpt/streams/piping/close-propagation-backward.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/piping/close-propagation-forward.any.js b/test/fixtures/wpt/streams/piping/close-propagation-forward.any.js index fc3282eea74b40..71b6e262840090 100644 --- a/test/fixtures/wpt/streams/piping/close-propagation-forward.any.js +++ b/test/fixtures/wpt/streams/piping/close-propagation-forward.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/piping/error-propagation-backward.any.js b/test/fixtures/wpt/streams/piping/error-propagation-backward.any.js index 6dc203066e3d7e..ec74592f86effe 100644 --- a/test/fixtures/wpt/streams/piping/error-propagation-backward.any.js +++ b/test/fixtures/wpt/streams/piping/error-propagation-backward.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/piping/error-propagation-forward.any.js b/test/fixtures/wpt/streams/piping/error-propagation-forward.any.js index f35ec665eec22f..482da2f8a88e18 100644 --- a/test/fixtures/wpt/streams/piping/error-propagation-forward.any.js +++ b/test/fixtures/wpt/streams/piping/error-propagation-forward.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/piping/flow-control.any.js b/test/fixtures/wpt/streams/piping/flow-control.any.js index db83c011f4a718..09c4420f872adc 100644 --- a/test/fixtures/wpt/streams/piping/flow-control.any.js +++ b/test/fixtures/wpt/streams/piping/flow-control.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/rs-utils.js // META: script=../resources/recording-streams.js diff --git a/test/fixtures/wpt/streams/piping/general.any.js b/test/fixtures/wpt/streams/piping/general.any.js index 2e02dfad78a0fa..bec3480f653944 100644 --- a/test/fixtures/wpt/streams/piping/general.any.js +++ b/test/fixtures/wpt/streams/piping/general.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/piping/multiple-propagation.any.js b/test/fixtures/wpt/streams/piping/multiple-propagation.any.js index c9a486f3f9ac2f..a78652fc06795e 100644 --- a/test/fixtures/wpt/streams/piping/multiple-propagation.any.js +++ b/test/fixtures/wpt/streams/piping/multiple-propagation.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/piping/pipe-through.any.js b/test/fixtures/wpt/streams/piping/pipe-through.any.js index 35dbb456b3e2c6..26b1cd26a3c82f 100644 --- a/test/fixtures/wpt/streams/piping/pipe-through.any.js +++ b/test/fixtures/wpt/streams/piping/pipe-through.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/rs-utils.js // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js @@ -266,3 +266,66 @@ test(() => { } }), 'pipeThrough should throw'); }, 'pipeThrough() should throw if an option getter grabs a writer'); + +test(() => { + const rs = new ReadableStream(); + const readable = new ReadableStream(); + const writable = new WritableStream(); + rs.pipeThrough({readable, writable}, null); +}, 'pipeThrough() should not throw if option is null'); + +test(() => { + const rs = new ReadableStream(); + const readable = new ReadableStream(); + const writable = new WritableStream(); + rs.pipeThrough({readable, writable}, {signal:undefined}); +}, 'pipeThrough() should not throw if signal is undefined'); + +function tryPipeThrough(pair, options) +{ + const rs = new ReadableStream(); + if (!pair) + pair = {readable:new ReadableStream(), writable:new WritableStream()}; + try { + rs.pipeThrough(pair, options) + } catch (e) { + return e; + } +} + +test(() => { + let result = tryPipeThrough({ + get readable() { + return new ReadableStream(); + }, + get writable() { + throw "writable threw"; + } + }, { }); + assert_equals(result, "writable threw"); + + result = tryPipeThrough({ + get readable() { + throw "readable threw"; + }, + get writable() { + throw "writable threw"; + } + }, { }); + assert_equals(result, "readable threw"); + + result = tryPipeThrough({ + get readable() { + throw "readable threw"; + }, + get writable() { + throw "writable threw"; + } + }, { + get preventAbort() { + throw "preventAbort threw"; + } + }); + assert_equals(result, "readable threw"); + +}, 'pipeThrough() should throw if readable/writable getters throw'); diff --git a/test/fixtures/wpt/streams/piping/then-interception.any.js b/test/fixtures/wpt/streams/piping/then-interception.any.js index 9f772ea5841d8f..543f916d940d9a 100644 --- a/test/fixtures/wpt/streams/piping/then-interception.any.js +++ b/test/fixtures/wpt/streams/piping/then-interception.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/piping/throwing-options.any.js b/test/fixtures/wpt/streams/piping/throwing-options.any.js index bc1cf328da61e6..b9f906778f632b 100644 --- a/test/fixtures/wpt/streams/piping/throwing-options.any.js +++ b/test/fixtures/wpt/streams/piping/throwing-options.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; class ThrowingOptions { diff --git a/test/fixtures/wpt/streams/piping/transform-streams.any.js b/test/fixtures/wpt/streams/piping/transform-streams.any.js index a368fecd6f00d6..caae9fbad8848a 100644 --- a/test/fixtures/wpt/streams/piping/transform-streams.any.js +++ b/test/fixtures/wpt/streams/piping/transform-streams.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; promise_test(() => { diff --git a/test/fixtures/wpt/streams/queuing-strategies.any.js b/test/fixtures/wpt/streams/queuing-strategies.any.js index 1846ea63e35459..fa959ebba28338 100644 --- a/test/fixtures/wpt/streams/queuing-strategies.any.js +++ b/test/fixtures/wpt/streams/queuing-strategies.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; const highWaterMarkConversions = new Map([ @@ -75,8 +75,23 @@ for (const QueuingStrategy of [CountQueuingStrategy, ByteLengthQueuingStrategy]) assert_equals(sc.size(), 2, 'size() on the subclass should override the parent'); assert_true(sc.subClassMethod(), 'subClassMethod() should work'); }, `${QueuingStrategy.name}: subclassing should work correctly`); + + test(() => { + const size = new QueuingStrategy({ highWaterMark: 5 }).size; + assert_false('prototype' in size); + }, `${QueuingStrategy.name}: size should not have a prototype property`); } +test(() => { + const size = new CountQueuingStrategy({ highWaterMark: 5 }).size; + assert_throws_js(TypeError, () => new size()); +}, `CountQueuingStrategy: size should not be a constructor`); + +test(() => { + const size = new ByteLengthQueuingStrategy({ highWaterMark: 5 }).size; + assert_throws_js(TypeError, () => new size({ byteLength: 1024 })); +}, `ByteLengthQueuingStrategy: size should not be a constructor`); + test(() => { const size = (new CountQueuingStrategy({ highWaterMark: 5 })).size; assert_equals(size.length, 0); diff --git a/test/fixtures/wpt/streams/readable-byte-streams/bad-buffers-and-views.any.js b/test/fixtures/wpt/streams/readable-byte-streams/bad-buffers-and-views.any.js index eed3a5ed4f8d02..3322116b191840 100644 --- a/test/fixtures/wpt/streams/readable-byte-streams/bad-buffers-and-views.any.js +++ b/test/fixtures/wpt/streams/readable-byte-streams/bad-buffers-and-views.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; promise_test(() => { @@ -203,6 +203,38 @@ async_test(t => { }, 'ReadableStream with byte source: respondWithNewView() throws if the supplied view is zero-length on a ' + 'non-zero-length buffer (in the readable state)'); +async_test(t => { + const stream = new ReadableStream({ + pull: t.step_func_done(c => { + const view = c.byobRequest.view.subarray(1, 2); + + assert_throws_js(RangeError, () => c.byobRequest.respondWithNewView(view)); + }), + type: 'bytes' + }); + const reader = stream.getReader({ mode: 'byob' }); + + reader.read(new Uint8Array([4, 5, 6])); +}, 'ReadableStream with byte source: respondWithNewView() throws if the supplied view has a different offset ' + + '(in the readable state)'); + +async_test(t => { + const stream = new ReadableStream({ + pull: t.step_func_done(c => { + c.close(); + + const view = c.byobRequest.view.subarray(1, 1); + + assert_throws_js(RangeError, () => c.byobRequest.respondWithNewView(view)); + }), + type: 'bytes' + }); + const reader = stream.getReader({ mode: 'byob' }); + + reader.read(new Uint8Array([4, 5, 6])); +}, 'ReadableStream with byte source: respondWithNewView() throws if the supplied view has a different offset ' + + '(in the closed state)'); + async_test(t => { const stream = new ReadableStream({ pull: t.step_func_done(c => { @@ -218,6 +250,23 @@ async_test(t => { }, 'ReadableStream with byte source: respondWithNewView() throws if the supplied view\'s buffer has a ' + 'different length (in the readable state)'); +async_test(t => { + // Tests https://github.com/nodejs/node/issues/41886 + const stream = new ReadableStream({ + pull: t.step_func_done(c => { + const view = new Uint8Array(new ArrayBuffer(11), 0, 3); + + assert_throws_js(RangeError, () => c.byobRequest.respondWithNewView(view)); + }), + type: 'bytes', + autoAllocateChunkSize: 10 + }); + const reader = stream.getReader(); + + reader.read(); +}, 'ReadableStream with byte source: respondWithNewView() throws if the supplied view\'s buffer has a ' + + 'different length (autoAllocateChunkSize)'); + async_test(t => { const stream = new ReadableStream({ pull: t.step_func_done(c => { diff --git a/test/fixtures/wpt/streams/readable-byte-streams/construct-byob-request.any.js b/test/fixtures/wpt/streams/readable-byte-streams/construct-byob-request.any.js index 1386d84599a4cd..8d460a1c81b7bd 100644 --- a/test/fixtures/wpt/streams/readable-byte-streams/construct-byob-request.any.js +++ b/test/fixtures/wpt/streams/readable-byte-streams/construct-byob-request.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/rs-utils.js 'use strict'; diff --git a/test/fixtures/wpt/streams/readable-byte-streams/general.any.js b/test/fixtures/wpt/streams/readable-byte-streams/general.any.js index 9aa508225865c8..dd4fdc855786f2 100644 --- a/test/fixtures/wpt/streams/readable-byte-streams/general.any.js +++ b/test/fixtures/wpt/streams/readable-byte-streams/general.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/rs-utils.js // META: script=../resources/test-utils.js 'use strict'; @@ -236,15 +236,27 @@ promise_test(t => { }); }, 'ReadableStream with byte source: Test that erroring a stream does not release a BYOB reader automatically'); -test(() => { +promise_test(async t => { const stream = new ReadableStream({ type: 'bytes' }); const reader = stream.getReader(); - reader.read(); - assert_throws_js(TypeError, () => reader.releaseLock(), 'reader.releaseLock() must throw'); -}, 'ReadableStream with byte source: releaseLock() on ReadableStreamDefaultReader with pending read() must throw'); + const read = reader.read(); + reader.releaseLock(); + await promise_rejects_js(t, TypeError, read, 'pending read must reject'); +}, 'ReadableStream with byte source: releaseLock() on ReadableStreamDefaultReader must reject pending read()'); + +promise_test(async t => { + const stream = new ReadableStream({ + type: 'bytes' + }); + + const reader = stream.getReader({ mode: 'byob' }); + const read = reader.read(new Uint8Array(1)); + reader.releaseLock(); + await promise_rejects_js(t, TypeError, read, 'pending read must reject'); +}, 'ReadableStream with byte source: releaseLock() on ReadableStreamBYOBReader must reject pending read()'); promise_test(() => { let pullCount = 0; @@ -2111,7 +2123,7 @@ promise_test(() => { }); }, 'calling respond() should throw when canceled'); -promise_test(() => { +promise_test(async t => { let resolvePullCalledPromise; const pullCalledPromise = new Promise(resolve => { resolvePullCalledPromise = resolve; @@ -2127,14 +2139,13 @@ promise_test(() => { type: 'bytes' }); const reader = rs.getReader({ mode: 'byob' }); - reader.read(new Uint8Array(16)); - return pullCalledPromise.then(() => { - resolvePull(); - return delay(0).then(() => { - assert_throws_js(TypeError, () => reader.releaseLock(), 'releaseLock() should throw'); - }); - }); -}, 'pull() resolving should not make releaseLock() possible'); + const read = reader.read(new Uint8Array(16)); + await pullCalledPromise; + resolvePull(); + await delay(0); + reader.releaseLock(); + await promise_rejects_js(t, TypeError, read, 'pending read should reject'); +}, 'pull() resolving should not resolve read()'); promise_test(() => { // Tests https://github.com/whatwg/streams/issues/686 @@ -2334,3 +2345,557 @@ promise_test(async t => { }, 'ReadableStream with byte source: respondWithNewView() with a transferred zero-length view ' + '(in the closed state)'); + +promise_test(async t => { + let controller; + let pullCount = 0; + const rs = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 10, + start: t.step_func((c) => { + controller = c; + }), + pull: t.step_func(() => { + ++pullCount; + }) + }); + + await flushAsyncEvents(); + assert_equals(pullCount, 0, 'pull() must not have been invoked yet'); + + const reader1 = rs.getReader(); + const read1 = reader1.read(); + assert_equals(pullCount, 1, 'pull() must have been invoked once'); + const byobRequest1 = controller.byobRequest; + assert_equals(byobRequest1.view.byteLength, 10, 'first byobRequest.view.byteLength'); + + // enqueue() must discard the auto-allocated BYOB request + controller.enqueue(new Uint8Array([1, 2, 3])); + assert_equals(byobRequest1.view, null, 'first byobRequest must be invalidated after enqueue()'); + + const result1 = await read1; + assert_false(result1.done, 'first result.done'); + const view1 = result1.value; + assert_equals(view1.byteOffset, 0, 'first result.value.byteOffset'); + assert_equals(view1.byteLength, 3, 'first result.value.byteLength'); + assert_array_equals([...new Uint8Array(view1.buffer)], [1, 2, 3], 'first result.value.buffer'); + + reader1.releaseLock(); + + // read(view) should work after discarding the auto-allocated BYOB request + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint8Array([4, 5, 6])); + assert_equals(pullCount, 2, 'pull() must have been invoked twice'); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2.view.byteOffset, 0, 'second byobRequest.view.byteOffset'); + assert_equals(byobRequest2.view.byteLength, 3, 'second byobRequest.view.byteLength'); + assert_array_equals([...new Uint8Array(byobRequest2.view.buffer)], [4, 5, 6], 'second byobRequest.view.buffer'); + + byobRequest2.respond(3); + assert_equals(byobRequest2.view, null, 'second byobRequest must be invalidated after respond()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + const view2 = result2.value; + assert_equals(view2.byteOffset, 0, 'second result.value.byteOffset'); + assert_equals(view2.byteLength, 3, 'second result.value.byteLength'); + assert_array_equals([...new Uint8Array(view2.buffer)], [4, 5, 6], 'second result.value.buffer'); + + reader2.releaseLock(); + assert_equals(pullCount, 2, 'pull() must only have been invoked twice'); +}, 'ReadableStream with byte source: enqueue() discards auto-allocated BYOB request'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader({ mode: 'byob' }); + const read1 = reader1.read(new Uint8Array([1, 2, 3])); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint8Array([4, 5, 6])); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + assert_equals(controller.byobRequest, byobRequest1, 'byobRequest should be unchanged'); + assert_array_equals([...new Uint8Array(byobRequest1.view.buffer)], [1, 2, 3], 'byobRequest.view.buffer should be unchanged'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // respond() should fulfill the *second* read() request + byobRequest1.view[0] = 11; + byobRequest1.respond(1); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after respond()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([11, 5, 6]).subarray(0, 1), 'second result.value'); + +}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, respond()'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader({ mode: 'byob' }); + const read1 = reader1.read(new Uint8Array([1, 2, 3])); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint16Array(1)); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + assert_equals(controller.byobRequest, byobRequest1, 'byobRequest should be unchanged'); + assert_array_equals([...new Uint8Array(byobRequest1.view.buffer)], [1, 2, 3], 'byobRequest.view.buffer should be unchanged'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // respond(1) should partially fill the second read(), but not yet fulfill it + byobRequest1.view[0] = 0x11; + byobRequest1.respond(1); + + // second BYOB request should use remaining buffer from the second read() + const byobRequest2 = controller.byobRequest; + assert_not_equals(byobRequest2, null, 'second byobRequest should exist'); + assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'second byobRequest.view'); + + // second respond(1) should fill the read request and fulfill it + byobRequest2.view[0] = 0x22; + byobRequest2.respond(1); + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + const view2 = result2.value; + assert_equals(view2.byteOffset, 0, 'second result.value.byteOffset'); + assert_equals(view2.byteLength, 2, 'second result.value.byteLength'); + const dataView2 = new DataView(view2.buffer, view2.byteOffset, view2.byteLength); + assert_equals(dataView2.getUint16(0), 0x1122, 'second result.value[0]'); + +}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader with ' + + '1 element Uint16Array, respond(1)'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader({ mode: 'byob' }); + const read1 = reader1.read(new Uint8Array([1, 2, 3])); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint8Array([4, 5])); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + assert_equals(controller.byobRequest, byobRequest1, 'byobRequest should be unchanged'); + assert_array_equals([...new Uint8Array(byobRequest1.view.buffer)], [1, 2, 3], 'byobRequest.view.buffer should be unchanged'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // respond(3) should fulfill the second read(), and put 1 remaining byte in the queue + byobRequest1.view[0] = 6; + byobRequest1.view[1] = 7; + byobRequest1.view[2] = 8; + byobRequest1.respond(3); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after respond()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([6, 7]), 'second result.value'); + + // third read() should fulfill with the remaining byte + const result3 = await reader2.read(new Uint8Array([0, 0, 0])); + assert_false(result3.done, 'third result.done'); + assert_typed_array_equals(result3.value, new Uint8Array([8, 0, 0]).subarray(0, 1), 'third result.value'); + +}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader with ' + + '2 element Uint8Array, respond(3)'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader({ mode: 'byob' }); + const read1 = reader1.read(new Uint8Array([1, 2, 3])); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint8Array([4, 5, 6])); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // respondWithNewView() should fulfill the *second* read() request + byobRequest1.view[0] = 11; + byobRequest1.view[1] = 12; + byobRequest1.respondWithNewView(byobRequest1.view.subarray(0, 2)); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after respondWithNewView()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([11, 12, 6]).subarray(0, 2), 'second result.value'); + +}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, respondWithNewView()'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader({ mode: 'byob' }); + const read1 = reader1.read(new Uint8Array([1, 2, 3])); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint8Array([4, 5, 6])); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // enqueue() should fulfill the *second* read() request + controller.enqueue(new Uint8Array([11, 12])); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after enqueue()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([11, 12, 6]).subarray(0, 2), 'second result.value'); + +}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, enqueue()'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader({ mode: 'byob' }); + const read1 = reader1.read(new Uint8Array([1, 2, 3])); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([1, 2, 3]), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint8Array([4, 5, 6])); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // close() followed by respond(0) should fulfill the second read() + controller.close(); + byobRequest1.respond(0); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after respond()'); + + const result2 = await read2; + assert_true(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([4, 5, 6]).subarray(0, 0), 'second result.value'); +}, 'ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, ' + + 'close(), respond(0)'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 4, + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader(); + const read1 = reader1.read(); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array(4), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader(); + const read2 = reader2.read(); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // respond() should fulfill the *second* read() request + byobRequest1.view[0] = 11; + byobRequest1.respond(1); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after respond()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([11, 0, 0, 0]).subarray(0, 1), 'second result.value'); + +}, 'ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read() on second reader, respond()'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 4, + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader(); + const read1 = reader1.read(); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array(4), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader(); + const read2 = reader2.read(); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // enqueue() should fulfill the *second* read() request + controller.enqueue(new Uint8Array([11])); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after enqueue()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([11]), 'second result.value'); + +}, 'ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read() on second reader, enqueue()'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 4, + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader(); + const read1 = reader1.read(); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array(4), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint8Array([4, 5, 6])); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // respond() should fulfill the *second* read() request + byobRequest1.view[0] = 11; + byobRequest1.respond(1); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after respond()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([11, 5, 6]).subarray(0, 1), 'second result.value'); + +}, 'ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read(view) on second reader, respond()'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 4, + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader(); + const read1 = reader1.read(); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array(4), 'first byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint8Array([4, 5, 6])); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // enqueue() should fulfill the *second* read() request + controller.enqueue(new Uint8Array([11])); + const byobRequest2 = controller.byobRequest; + assert_equals(byobRequest2, null, 'byobRequest should be null after enqueue()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([11, 5, 6]).subarray(0, 1), 'second result.value'); + +}, 'ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read(view) on second reader, enqueue()'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader({ mode: 'byob' }); + const read1 = reader1.read(new Uint16Array(1)); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([0, 0]), 'first byobRequest.view'); + + // respond(1) should partially fill the first read(), but not yet fulfill it + byobRequest1.view[0] = 0x11; + byobRequest1.respond(1); + const byobRequest2 = controller.byobRequest; + assert_not_equals(byobRequest2, null, 'second byobRequest should exist'); + assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'second byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader({ mode: 'byob' }); + const read2 = reader2.read(new Uint16Array(1)); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + assert_equals(controller.byobRequest, byobRequest2, 'byobRequest should be unchanged'); + assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'byobRequest.view should be unchanged'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // second respond(1) should fill the read request and fulfill it + byobRequest2.view[0] = 0x22; + byobRequest2.respond(1); + assert_equals(controller.byobRequest, null, 'byobRequest should be invalidated after second respond()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + const view2 = result2.value; + assert_equals(view2.byteOffset, 0, 'second result.value.byteOffset'); + assert_equals(view2.byteLength, 2, 'second result.value.byteLength'); + const dataView2 = new DataView(view2.buffer, view2.byteOffset, view2.byteLength); + assert_equals(dataView2.getUint16(0), 0x1122, 'second result.value[0]'); + +}, 'ReadableStream with byte source: read(view) with 1 element Uint16Array, respond(1), releaseLock(), read(view) on ' + + 'second reader with 1 element Uint16Array, respond(1)'); + +promise_test(async t => { + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start: t.step_func((c) => { + controller = c; + }) + }); + await flushAsyncEvents(); + + const reader1 = rs.getReader({ mode: 'byob' }); + const read1 = reader1.read(new Uint16Array(1)); + const byobRequest1 = controller.byobRequest; + assert_not_equals(byobRequest1, null, 'first byobRequest should exist'); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([0, 0]), 'first byobRequest.view'); + + // respond(1) should partially fill the first read(), but not yet fulfill it + byobRequest1.view[0] = 0x11; + byobRequest1.respond(1); + const byobRequest2 = controller.byobRequest; + assert_not_equals(byobRequest2, null, 'second byobRequest should exist'); + assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'second byobRequest.view'); + + // releaseLock() should reject the pending read, but *not* invalidate the BYOB request + reader1.releaseLock(); + const reader2 = rs.getReader(); + const read2 = reader2.read(); + assert_not_equals(controller.byobRequest, null, 'byobRequest should not be invalidated after releaseLock()'); + assert_equals(controller.byobRequest, byobRequest2, 'byobRequest should be unchanged'); + assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11, 0]).subarray(1, 2), 'byobRequest.view should be unchanged'); + await promise_rejects_js(t, TypeError, read1, 'pending read must reject after releaseLock()'); + + // enqueue() should fulfill the read request and put remaining byte in the queue + controller.enqueue(new Uint8Array([0x22])); + assert_equals(controller.byobRequest, null, 'byobRequest should be invalidated after second respond()'); + + const result2 = await read2; + assert_false(result2.done, 'second result.done'); + assert_typed_array_equals(result2.value, new Uint8Array([0x11]), 'second result.value'); + + const result3 = await reader2.read(); + assert_false(result3.done, 'third result.done'); + assert_typed_array_equals(result3.value, new Uint8Array([0x22]), 'third result.value'); + +}, 'ReadableStream with byte source: read(view) with 1 element Uint16Array, respond(1), releaseLock(), read() on ' + + 'second reader, enqueue()'); + +promise_test(async t => { + // Tests https://github.com/nodejs/node/issues/41886 + const stream = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 10, + pull: t.step_func((c) => { + const newView = new Uint8Array(c.byobRequest.view.buffer, 0, 3); + newView.set([20, 21, 22]); + c.byobRequest.respondWithNewView(newView); + }) + }); + + const reader = stream.getReader(); + const result = await reader.read(); + assert_false(result.done, 'result.done'); + + const view = result.value; + assert_equals(view.byteOffset, 0, 'result.value.byteOffset'); + assert_equals(view.byteLength, 3, 'result.value.byteLength'); + assert_equals(view.buffer.byteLength, 10, 'result.value.buffer.byteLength'); + assert_array_equals([...new Uint8Array(view)], [20, 21, 22], 'result.value'); +}, 'ReadableStream with byte source: autoAllocateChunkSize, read(), respondWithNewView()'); diff --git a/test/fixtures/wpt/streams/readable-byte-streams/non-transferable-buffers.any.js b/test/fixtures/wpt/streams/readable-byte-streams/non-transferable-buffers.any.js index 7c0bffb78710fe..e8ea3c4f966763 100644 --- a/test/fixtures/wpt/streams/readable-byte-streams/non-transferable-buffers.any.js +++ b/test/fixtures/wpt/streams/readable-byte-streams/non-transferable-buffers.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; promise_test(async t => { diff --git a/test/fixtures/wpt/streams/readable-byte-streams/respond-after-enqueue.any.js b/test/fixtures/wpt/streams/readable-byte-streams/respond-after-enqueue.any.js new file mode 100644 index 00000000000000..b93cec97391e13 --- /dev/null +++ b/test/fixtures/wpt/streams/readable-byte-streams/respond-after-enqueue.any.js @@ -0,0 +1,55 @@ +// META: global=window,worker + +'use strict'; + +// Repro for Blink bug https://crbug.com/1255762. +promise_test(async () => { + const rs = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 10, + pull(controller) { + controller.enqueue(new Uint8Array([1, 2, 3])); + controller.byobRequest.respond(10); + } + }); + + const reader = rs.getReader(); + const {value, done} = await reader.read(); + assert_false(done, 'done should not be true'); + assert_array_equals(value, [1, 2, 3], 'value should be 3 bytes'); +}, 'byobRequest.respond() after enqueue() should not crash'); + +promise_test(async () => { + const rs = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 10, + pull(controller) { + const byobRequest = controller.byobRequest; + controller.enqueue(new Uint8Array([1, 2, 3])); + byobRequest.respond(10); + } + }); + + const reader = rs.getReader(); + const {value, done} = await reader.read(); + assert_false(done, 'done should not be true'); + assert_array_equals(value, [1, 2, 3], 'value should be 3 bytes'); +}, 'byobRequest.respond() with cached byobRequest after enqueue() should not crash'); + +promise_test(async () => { + const rs = new ReadableStream({ + type: 'bytes', + autoAllocateChunkSize: 10, + pull(controller) { + controller.enqueue(new Uint8Array([1, 2, 3])); + controller.byobRequest.respond(2); + } + }); + + const reader = rs.getReader(); + const [read1, read2] = await Promise.all([reader.read(), reader.read()]); + assert_false(read1.done, 'read1.done should not be true'); + assert_array_equals(read1.value, [1, 2, 3], 'read1.value should be 3 bytes'); + assert_false(read2.done, 'read2.done should not be true'); + assert_array_equals(read2.value, [0, 0], 'read2.value should be 2 bytes'); +}, 'byobRequest.respond() after enqueue() with double read should not crash'); diff --git a/test/fixtures/wpt/streams/readable-byte-streams/tee.any.js b/test/fixtures/wpt/streams/readable-byte-streams/tee.any.js new file mode 100644 index 00000000000000..85844669cd9088 --- /dev/null +++ b/test/fixtures/wpt/streams/readable-byte-streams/tee.any.js @@ -0,0 +1,936 @@ +// META: global=window,worker +// META: script=../resources/rs-utils.js +// META: script=../resources/test-utils.js +// META: script=../resources/recording-streams.js +// META: script=../resources/rs-test-templates.js +'use strict'; + +test(() => { + + const rs = new ReadableStream({ type: 'bytes' }); + const result = rs.tee(); + + assert_true(Array.isArray(result), 'return value should be an array'); + assert_equals(result.length, 2, 'array should have length 2'); + assert_equals(result[0].constructor, ReadableStream, '0th element should be a ReadableStream'); + assert_equals(result[1].constructor, ReadableStream, '1st element should be a ReadableStream'); + +}, 'ReadableStream teeing with byte source: rs.tee() returns an array of two ReadableStreams'); + +promise_test(async t => { + + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + c.enqueue(new Uint8Array([0x01])); + c.enqueue(new Uint8Array([0x02])); + c.close(); + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader({ mode: 'byob' }); + + reader2.closed.then(t.unreached_func('branch2 should not be closed')); + + { + const result = await reader1.read(new Uint8Array(1)); + assert_equals(result.done, false, 'done'); + assert_typed_array_equals(result.value, new Uint8Array([0x01]), 'value'); + } + + { + const result = await reader1.read(new Uint8Array(1)); + assert_equals(result.done, false, 'done'); + assert_typed_array_equals(result.value, new Uint8Array([0x02]), 'value'); + } + + { + const result = await reader1.read(new Uint8Array(1)); + assert_equals(result.done, true, 'done'); + assert_typed_array_equals(result.value, new Uint8Array([0]).subarray(0, 0), 'value'); + } + + { + const result = await reader2.read(new Uint8Array(1)); + assert_equals(result.done, false, 'done'); + assert_typed_array_equals(result.value, new Uint8Array([0x01]), 'value'); + } + + await reader1.closed; + +}, 'ReadableStream teeing with byte source: should be able to read one branch to the end without affecting the other'); + +promise_test(async () => { + + let pullCount = 0; + const enqueuedChunk = new Uint8Array([0x01]); + const rs = new ReadableStream({ + type: 'bytes', + pull(c) { + ++pullCount; + if (pullCount === 1) { + c.enqueue(enqueuedChunk); + } + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader(); + const reader2 = branch2.getReader(); + + const [result1, result2] = await Promise.all([reader1.read(), reader2.read()]); + assert_equals(result1.done, false, 'reader1 done'); + assert_equals(result2.done, false, 'reader2 done'); + + const view1 = result1.value; + const view2 = result2.value; + assert_typed_array_equals(view1, new Uint8Array([0x01]), 'reader1 value'); + assert_typed_array_equals(view2, new Uint8Array([0x01]), 'reader2 value'); + + assert_not_equals(view1.buffer, view2.buffer, 'chunks should have different buffers'); + assert_not_equals(enqueuedChunk.buffer, view1.buffer, 'enqueued chunk and branch1\'s chunk should have different buffers'); + assert_not_equals(enqueuedChunk.buffer, view2.buffer, 'enqueued chunk and branch2\'s chunk should have different buffers'); + +}, 'ReadableStream teeing with byte source: chunks should be cloned for each branch'); + +promise_test(async () => { + + let pullCount = 0; + const rs = new ReadableStream({ + type: 'bytes', + pull(c) { + ++pullCount; + if (pullCount === 1) { + c.byobRequest.view[0] = 0x01; + c.byobRequest.respond(1); + } + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader(); + const buffer = new Uint8Array([42, 42, 42]).buffer; + + { + const result = await reader1.read(new Uint8Array(buffer, 0, 1)); + assert_equals(result.done, false, 'done'); + assert_typed_array_equals(result.value, new Uint8Array([0x01, 42, 42]).subarray(0, 1), 'value'); + } + + { + const result = await reader2.read(); + assert_equals(result.done, false, 'done'); + assert_typed_array_equals(result.value, new Uint8Array([0x01]), 'value'); + } + +}, 'ReadableStream teeing with byte source: chunks for BYOB requests from branch 1 should be cloned to branch 2'); + +promise_test(async t => { + + const theError = { name: 'boo!' }; + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + c.enqueue(new Uint8Array([0x01])); + c.enqueue(new Uint8Array([0x02])); + }, + pull() { + throw theError; + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader({ mode: 'byob' }); + + { + const result = await reader1.read(new Uint8Array(1)); + assert_equals(result.done, false, 'first read from branch1 should not be done'); + assert_typed_array_equals(result.value, new Uint8Array([0x01]), 'first read from branch1'); + } + + { + const result = await reader1.read(new Uint8Array(1)); + assert_equals(result.done, false, 'second read from branch1 should not be done'); + assert_typed_array_equals(result.value, new Uint8Array([0x02]), 'second read from branch1'); + } + + await promise_rejects_exactly(t, theError, reader1.read(new Uint8Array(1))); + await promise_rejects_exactly(t, theError, reader2.read(new Uint8Array(1))); + + await Promise.all([ + promise_rejects_exactly(t, theError, reader1.closed), + promise_rejects_exactly(t, theError, reader2.closed) + ]); + +}, 'ReadableStream teeing with byte source: errors in the source should propagate to both branches'); + +promise_test(async () => { + + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + c.enqueue(new Uint8Array([0x01])); + c.enqueue(new Uint8Array([0x02])); + c.close(); + } + }); + + const [branch1, branch2] = rs.tee(); + branch1.cancel(); + + const [chunks1, chunks2] = await Promise.all([readableStreamToArray(branch1), readableStreamToArray(branch2)]); + assert_array_equals(chunks1, [], 'branch1 should have no chunks'); + assert_equals(chunks2.length, 2, 'branch2 should have two chunks'); + assert_typed_array_equals(chunks2[0], new Uint8Array([0x01]), 'first chunk from branch2'); + assert_typed_array_equals(chunks2[1], new Uint8Array([0x02]), 'second chunk from branch2'); + +}, 'ReadableStream teeing with byte source: canceling branch1 should not impact branch2'); + +promise_test(async () => { + + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + c.enqueue(new Uint8Array([0x01])); + c.enqueue(new Uint8Array([0x02])); + c.close(); + } + }); + + const [branch1, branch2] = rs.tee(); + branch2.cancel(); + + const [chunks1, chunks2] = await Promise.all([readableStreamToArray(branch1), readableStreamToArray(branch2)]); + assert_equals(chunks1.length, 2, 'branch1 should have two chunks'); + assert_typed_array_equals(chunks1[0], new Uint8Array([0x01]), 'first chunk from branch1'); + assert_typed_array_equals(chunks1[1], new Uint8Array([0x02]), 'second chunk from branch1'); + assert_array_equals(chunks2, [], 'branch2 should have no chunks'); + +}, 'ReadableStream teeing with byte source: canceling branch2 should not impact branch1'); + +templatedRSTeeCancel('ReadableStream teeing with byte source', (extras) => { + return new ReadableStream({ type: 'bytes', ...extras }); +}); + +promise_test(async () => { + + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + controller = c; + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader({ mode: 'byob' }); + + const promise = Promise.all([reader1.closed, reader2.closed]); + + controller.close(); + + // The branches are created with HWM 0, so we need to read from at least one of them + // to observe the stream becoming closed. + const read1 = await reader1.read(new Uint8Array(1)); + assert_equals(read1.done, true, 'first read from branch1 should be done'); + + await promise; + +}, 'ReadableStream teeing with byte source: closing the original should close the branches'); + +promise_test(async t => { + + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + controller = c; + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader({ mode: 'byob' }); + + const theError = { name: 'boo!' }; + const promise = Promise.all([ + promise_rejects_exactly(t, theError, reader1.closed), + promise_rejects_exactly(t, theError, reader2.closed) + ]); + + controller.error(theError); + await promise; + +}, 'ReadableStream teeing with byte source: erroring the original should immediately error the branches'); + +promise_test(async t => { + + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + controller = c; + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader(); + const reader2 = branch2.getReader(); + + const theError = { name: 'boo!' }; + const promise = Promise.all([ + promise_rejects_exactly(t, theError, reader1.read()), + promise_rejects_exactly(t, theError, reader2.read()) + ]); + + controller.error(theError); + await promise; + +}, 'ReadableStream teeing with byte source: erroring the original should error pending reads from default reader'); + +promise_test(async t => { + + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + controller = c; + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader({ mode: 'byob' }); + + const theError = { name: 'boo!' }; + const promise = Promise.all([ + promise_rejects_exactly(t, theError, reader1.read(new Uint8Array(1))), + promise_rejects_exactly(t, theError, reader2.read(new Uint8Array(1))) + ]); + + controller.error(theError); + await promise; + +}, 'ReadableStream teeing with byte source: erroring the original should error pending reads from BYOB reader'); + +promise_test(async () => { + + let controller; + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + controller = c; + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader({ mode: 'byob' }); + const cancelPromise = reader2.cancel(); + + controller.enqueue(new Uint8Array([0x01])); + + const read1 = await reader1.read(new Uint8Array(1)); + assert_equals(read1.done, false, 'first read() from branch1 should not be done'); + assert_typed_array_equals(read1.value, new Uint8Array([0x01]), 'first read() from branch1'); + + controller.close(); + + const read2 = await reader1.read(new Uint8Array(1)); + assert_equals(read2.done, true, 'second read() from branch1 should be done'); + + await Promise.all([ + reader1.closed, + cancelPromise + ]); + +}, 'ReadableStream teeing with byte source: canceling branch1 should finish when branch2 reads until end of stream'); + +promise_test(async t => { + + let controller; + const theError = { name: 'boo!' }; + const rs = new ReadableStream({ + type: 'bytes', + start(c) { + controller = c; + } + }); + + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader({ mode: 'byob' }); + const cancelPromise = reader2.cancel(); + + controller.error(theError); + + await Promise.all([ + promise_rejects_exactly(t, theError, reader1.read(new Uint8Array(1))), + cancelPromise + ]); + +}, 'ReadableStream teeing with byte source: canceling branch1 should finish when original stream errors'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + + // Create two branches, each with a HWM of 0. This should result in no chunks being pulled. + rs.tee(); + + await flushAsyncEvents(); + assert_array_equals(rs.events, [], 'pull should not be called'); + +}, 'ReadableStream teeing with byte source: should not pull any chunks if no branches are reading'); + +promise_test(async () => { + + const rs = recordingReadableStream({ + type: 'bytes', + pull(controller) { + controller.enqueue(new Uint8Array([0x01])); + } + }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + await Promise.all([ + reader1.read(new Uint8Array(1)), + reader2.read(new Uint8Array(1)) + ]); + assert_array_equals(rs.events, ['pull'], 'pull should be called once'); + +}, 'ReadableStream teeing with byte source: should only pull enough to fill the emptiest queue'); + +promise_test(async t => { + + const rs = recordingReadableStream({ type: 'bytes' }); + const theError = { name: 'boo!' }; + + rs.controller.error(theError); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + await flushAsyncEvents(); + assert_array_equals(rs.events, [], 'pull should not be called'); + + await Promise.all([ + promise_rejects_exactly(t, theError, reader1.closed), + promise_rejects_exactly(t, theError, reader2.closed) + ]); + +}, 'ReadableStream teeing with byte source: should not pull when original is already errored'); + +for (const branch of [1, 2]) { + promise_test(async t => { + + const rs = recordingReadableStream({ type: 'bytes' }); + const theError = { name: 'boo!' }; + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + await flushAsyncEvents(); + assert_array_equals(rs.events, [], 'pull should not be called'); + + const reader = (branch === 1) ? reader1 : reader2; + const read1 = reader.read(new Uint8Array(1)); + + await flushAsyncEvents(); + assert_array_equals(rs.events, ['pull'], 'pull should be called once'); + + rs.controller.error(theError); + + await Promise.all([ + promise_rejects_exactly(t, theError, read1), + promise_rejects_exactly(t, theError, reader1.closed), + promise_rejects_exactly(t, theError, reader2.closed) + ]); + + await flushAsyncEvents(); + assert_array_equals(rs.events, ['pull'], 'pull should be called once'); + + }, `ReadableStream teeing with byte source: stops pulling when original stream errors while branch ${branch} is reading`); +} + +promise_test(async t => { + + const rs = recordingReadableStream({ type: 'bytes' }); + const theError = { name: 'boo!' }; + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + await flushAsyncEvents(); + assert_array_equals(rs.events, [], 'pull should not be called'); + + const read1 = reader1.read(new Uint8Array(1)); + const read2 = reader2.read(new Uint8Array(1)); + + await flushAsyncEvents(); + assert_array_equals(rs.events, ['pull'], 'pull should be called once'); + + rs.controller.error(theError); + + await Promise.all([ + promise_rejects_exactly(t, theError, read1), + promise_rejects_exactly(t, theError, read2), + promise_rejects_exactly(t, theError, reader1.closed), + promise_rejects_exactly(t, theError, reader2.closed) + ]); + + await flushAsyncEvents(); + assert_array_equals(rs.events, ['pull'], 'pull should be called once'); + +}, 'ReadableStream teeing with byte source: stops pulling when original stream errors while both branches are reading'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + const read1 = reader1.read(new Uint8Array([0x11])); + const read2 = reader2.read(new Uint8Array([0x22])); + + const cancel1 = reader1.cancel(); + await flushAsyncEvents(); + const cancel2 = reader2.cancel(); + + const result1 = await read1; + assert_object_equals(result1, { value: undefined, done: true }); + const result2 = await read2; + assert_object_equals(result2, { value: undefined, done: true }); + + await Promise.all([cancel1, cancel2]); + +}, 'ReadableStream teeing with byte source: canceling both branches in sequence with delay'); + +promise_test(async t => { + + const theError = { name: 'boo!' }; + const rs = new ReadableStream({ + type: 'bytes', + cancel() { + throw theError; + } + }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + const read1 = reader1.read(new Uint8Array([0x11])); + const read2 = reader2.read(new Uint8Array([0x22])); + + const cancel1 = reader1.cancel(); + await flushAsyncEvents(); + const cancel2 = reader2.cancel(); + + const result1 = await read1; + assert_object_equals(result1, { value: undefined, done: true }); + const result2 = await read2; + assert_object_equals(result2, { value: undefined, done: true }); + + await Promise.all([ + promise_rejects_exactly(t, theError, cancel1), + promise_rejects_exactly(t, theError, cancel2) + ]); + +}, 'ReadableStream teeing with byte source: failing to cancel when canceling both branches in sequence with delay'); + +promise_test(async () => { + + let cancelResolve; + const cancelCalled = new Promise((resolve) => { + cancelResolve = resolve; + }); + const rs = recordingReadableStream({ + type: 'bytes', + cancel() { + cancelResolve(); + } + }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + const read1 = reader1.read(new Uint8Array([0x11])); + await flushAsyncEvents(); + const read2 = reader2.read(new Uint8Array([0x22])); + await flushAsyncEvents(); + + // We are reading into branch1's buffer. + const byobRequest1 = rs.controller.byobRequest; + assert_not_equals(byobRequest1, null); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([0x11]), 'byobRequest1.view'); + + // Cancelling branch1 should not affect the BYOB request. + const cancel1 = reader1.cancel(); + const result1 = await read1; + assert_equals(result1.done, true); + assert_equals(result1.value, undefined); + await flushAsyncEvents(); + const byobRequest2 = rs.controller.byobRequest; + assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11]), 'byobRequest2.view'); + + // Cancelling branch1 should invalidate the BYOB request. + const cancel2 = reader2.cancel(); + await cancelCalled; + const byobRequest3 = rs.controller.byobRequest; + assert_equals(byobRequest3, null); + const result2 = await read2; + assert_equals(result2.done, true); + assert_equals(result2.value, undefined); + + await Promise.all([cancel1, cancel2]); + +}, 'ReadableStream teeing with byte source: read from branch1 and branch2, cancel branch1, cancel branch2'); + +promise_test(async () => { + + let cancelResolve; + const cancelCalled = new Promise((resolve) => { + cancelResolve = resolve; + }); + const rs = recordingReadableStream({ + type: 'bytes', + cancel() { + cancelResolve(); + } + }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + const read1 = reader1.read(new Uint8Array([0x11])); + await flushAsyncEvents(); + const read2 = reader2.read(new Uint8Array([0x22])); + await flushAsyncEvents(); + + // We are reading into branch1's buffer. + const byobRequest1 = rs.controller.byobRequest; + assert_not_equals(byobRequest1, null); + assert_typed_array_equals(byobRequest1.view, new Uint8Array([0x11]), 'byobRequest1.view'); + + // Cancelling branch2 should not affect the BYOB request. + const cancel2 = reader2.cancel(); + const result2 = await read2; + assert_equals(result2.done, true); + assert_equals(result2.value, undefined); + await flushAsyncEvents(); + const byobRequest2 = rs.controller.byobRequest; + assert_typed_array_equals(byobRequest2.view, new Uint8Array([0x11]), 'byobRequest2.view'); + + // Cancelling branch1 should invalidate the BYOB request. + const cancel1 = reader1.cancel(); + await cancelCalled; + const byobRequest3 = rs.controller.byobRequest; + assert_equals(byobRequest3, null); + const result1 = await read1; + assert_equals(result1.done, true); + assert_equals(result1.value, undefined); + + await Promise.all([cancel1, cancel2]); + +}, 'ReadableStream teeing with byte source: read from branch1 and branch2, cancel branch2, cancel branch1'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + const read1 = reader1.read(new Uint8Array([0x11])); + await flushAsyncEvents(); + const read2 = reader2.read(new Uint8Array([0x22])); + await flushAsyncEvents(); + + // We are reading into branch1's buffer. + assert_typed_array_equals(rs.controller.byobRequest.view, new Uint8Array([0x11]), 'first byobRequest.view'); + + // Cancelling branch2 should not affect the BYOB request. + reader2.cancel(); + const result2 = await read2; + assert_equals(result2.done, true); + assert_equals(result2.value, undefined); + await flushAsyncEvents(); + assert_typed_array_equals(rs.controller.byobRequest.view, new Uint8Array([0x11]), 'second byobRequest.view'); + + // Respond to the BYOB request. + rs.controller.byobRequest.view[0] = 0x33; + rs.controller.byobRequest.respond(1); + + // branch1 should receive the read chunk. + const result1 = await read1; + assert_equals(result1.done, false); + assert_typed_array_equals(result1.value, new Uint8Array([0x33]), 'first read() from branch1'); + +}, 'ReadableStream teeing with byte source: read from branch1 and branch2, cancel branch2, enqueue to branch1'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + const read1 = reader1.read(new Uint8Array([0x11])); + await flushAsyncEvents(); + const read2 = reader2.read(new Uint8Array([0x22])); + await flushAsyncEvents(); + + // We are reading into branch1's buffer. + assert_typed_array_equals(rs.controller.byobRequest.view, new Uint8Array([0x11]), 'first byobRequest.view'); + + // Cancelling branch1 should not affect the BYOB request. + reader1.cancel(); + const result1 = await read1; + assert_equals(result1.done, true); + assert_equals(result1.value, undefined); + await flushAsyncEvents(); + assert_typed_array_equals(rs.controller.byobRequest.view, new Uint8Array([0x11]), 'second byobRequest.view'); + + // Respond to the BYOB request. + rs.controller.byobRequest.view[0] = 0x33; + rs.controller.byobRequest.respond(1); + + // branch2 should receive the read chunk. + const result2 = await read2; + assert_equals(result2.done, false); + assert_typed_array_equals(result2.value, new Uint8Array([0x33]), 'first read() from branch2'); + +}, 'ReadableStream teeing with byte source: read from branch1 and branch2, cancel branch1, respond to branch2'); + +promise_test(async () => { + + let pullCount = 0; + const byobRequestDefined = []; + const rs = new ReadableStream({ + type: 'bytes', + pull(c) { + ++pullCount; + byobRequestDefined.push(c.byobRequest !== null); + c.enqueue(new Uint8Array([pullCount])); + } + }); + + const [branch1, _] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + + const result1 = await reader1.read(new Uint8Array([0x11])); + assert_equals(result1.done, false, 'first read should not be done'); + assert_typed_array_equals(result1.value, new Uint8Array([0x1]), 'first read'); + assert_equals(pullCount, 1, 'pull() should be called once'); + assert_equals(byobRequestDefined[0], true, 'should have created a BYOB request for first read'); + + reader1.releaseLock(); + const reader2 = branch1.getReader(); + + const result2 = await reader2.read(); + assert_equals(result2.done, false, 'second read should not be done'); + assert_typed_array_equals(result2.value, new Uint8Array([0x2]), 'second read'); + assert_equals(pullCount, 2, 'pull() should be called twice'); + assert_equals(byobRequestDefined[1], false, 'should not have created a BYOB request for second read'); + +}, 'ReadableStream teeing with byte source: pull with BYOB reader, then pull with default reader'); + +promise_test(async () => { + + let pullCount = 0; + const byobRequestDefined = []; + const rs = new ReadableStream({ + type: 'bytes', + pull(c) { + ++pullCount; + byobRequestDefined.push(c.byobRequest !== null); + c.enqueue(new Uint8Array([pullCount])); + } + }); + + const [branch1, _] = rs.tee(); + const reader1 = branch1.getReader(); + + const result1 = await reader1.read(); + assert_equals(result1.done, false, 'first read should not be done'); + assert_typed_array_equals(result1.value, new Uint8Array([0x1]), 'first read'); + assert_equals(pullCount, 1, 'pull() should be called once'); + assert_equals(byobRequestDefined[0], false, 'should not have created a BYOB request for first read'); + + reader1.releaseLock(); + const reader2 = branch1.getReader({ mode: 'byob' }); + + const result2 = await reader2.read(new Uint8Array([0x22])); + assert_equals(result2.done, false, 'second read should not be done'); + assert_typed_array_equals(result2.value, new Uint8Array([0x2]), 'second read'); + assert_equals(pullCount, 2, 'pull() should be called twice'); + assert_equals(byobRequestDefined[1], true, 'should have created a BYOB request for second read'); + +}, 'ReadableStream teeing with byte source: pull with default reader, then pull with BYOB reader'); + +promise_test(async () => { + + const rs = recordingReadableStream({ + type: 'bytes' + }); + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + + // Wait for each branch's start() promise to resolve. + await flushAsyncEvents(); + + const read2 = reader2.read(new Uint8Array([0x22])); + const read1 = reader1.read(new Uint8Array([0x11])); + await flushAsyncEvents(); + + // branch2 should provide the BYOB request. + const byobRequest = rs.controller.byobRequest; + assert_typed_array_equals(byobRequest.view, new Uint8Array([0x22]), 'first BYOB request'); + byobRequest.view[0] = 0x01; + byobRequest.respond(1); + + const result1 = await read1; + assert_equals(result1.done, false, 'first read should not be done'); + assert_typed_array_equals(result1.value, new Uint8Array([0x1]), 'first read'); + + const result2 = await read2; + assert_equals(result2.done, false, 'second read should not be done'); + assert_typed_array_equals(result2.value, new Uint8Array([0x1]), 'second read'); + +}, 'ReadableStream teeing with byte source: read from branch2, then read from branch1'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader(); + const reader2 = branch2.getReader({ mode: 'byob' }); + await flushAsyncEvents(); + + const read1 = reader1.read(); + const read2 = reader2.read(new Uint8Array([0x22])); + await flushAsyncEvents(); + + // There should be no BYOB request. + assert_equals(rs.controller.byobRequest, null, 'first BYOB request'); + + // Close the stream. + rs.controller.close(); + + const result1 = await read1; + assert_equals(result1.done, true, 'read from branch1 should be done'); + assert_equals(result1.value, undefined, 'read from branch1'); + + // branch2 should get its buffer back. + const result2 = await read2; + assert_equals(result2.done, true, 'read from branch2 should be done'); + assert_typed_array_equals(result2.value, new Uint8Array([0x22]).subarray(0, 0), 'read from branch2'); + +}, 'ReadableStream teeing with byte source: read from branch1 with default reader, then close while branch2 has pending BYOB read'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + const [branch1, branch2] = rs.tee(); + const reader1 = branch1.getReader({ mode: 'byob' }); + const reader2 = branch2.getReader(); + await flushAsyncEvents(); + + const read2 = reader2.read(); + const read1 = reader1.read(new Uint8Array([0x11])); + await flushAsyncEvents(); + + // There should be no BYOB request. + assert_equals(rs.controller.byobRequest, null, 'first BYOB request'); + + // Close the stream. + rs.controller.close(); + + const result2 = await read2; + assert_equals(result2.done, true, 'read from branch2 should be done'); + assert_equals(result2.value, undefined, 'read from branch2'); + + // branch1 should get its buffer back. + const result1 = await read1; + assert_equals(result1.done, true, 'read from branch1 should be done'); + assert_typed_array_equals(result1.value, new Uint8Array([0x11]).subarray(0, 0), 'read from branch1'); + +}, 'ReadableStream teeing with byte source: read from branch2 with default reader, then close while branch1 has pending BYOB read'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + await flushAsyncEvents(); + + const read1 = reader1.read(new Uint8Array([0x11])); + const read2 = reader2.read(new Uint8Array([0x22])); + await flushAsyncEvents(); + + // branch1 should provide the BYOB request. + const byobRequest = rs.controller.byobRequest; + assert_typed_array_equals(byobRequest.view, new Uint8Array([0x11]), 'first BYOB request'); + + // Close the stream. + rs.controller.close(); + byobRequest.respond(0); + + // Both branches should get their buffers back. + const result1 = await read1; + assert_equals(result1.done, true, 'first read should be done'); + assert_typed_array_equals(result1.value, new Uint8Array([0x11]).subarray(0, 0), 'first read'); + + const result2 = await read2; + assert_equals(result2.done, true, 'second read should be done'); + assert_typed_array_equals(result2.value, new Uint8Array([0x22]).subarray(0, 0), 'second read'); + +}, 'ReadableStream teeing with byte source: close when both branches have pending BYOB reads'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader()); + const branch1Reads = [reader1.read(), reader1.read()]; + const branch2Reads = [reader2.read(), reader2.read()]; + + await flushAsyncEvents(); + rs.controller.enqueue(new Uint8Array([0x11])); + rs.controller.close(); + + const result1 = await branch1Reads[0]; + assert_equals(result1.done, false, 'first read() from branch1 should be not done'); + assert_typed_array_equals(result1.value, new Uint8Array([0x11]), 'first chunk from branch1 should be correct'); + const result2 = await branch2Reads[0]; + assert_equals(result2.done, false, 'first read() from branch2 should be not done'); + assert_typed_array_equals(result2.value, new Uint8Array([0x11]), 'first chunk from branch2 should be correct'); + + assert_object_equals(await branch1Reads[1], { value: undefined, done: true }, 'second read() from branch1 should be done'); + assert_object_equals(await branch2Reads[1], { value: undefined, done: true }, 'second read() from branch2 should be done'); + +}, 'ReadableStream teeing with byte source: enqueue() and close() while both branches are pulling'); + +promise_test(async () => { + + const rs = recordingReadableStream({ type: 'bytes' }); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader({ mode: 'byob' })); + const branch1Reads = [reader1.read(new Uint8Array(1)), reader1.read(new Uint8Array(1))]; + const branch2Reads = [reader2.read(new Uint8Array(1)), reader2.read(new Uint8Array(1))]; + + await flushAsyncEvents(); + rs.controller.byobRequest.view[0] = 0x11; + rs.controller.byobRequest.respond(1); + rs.controller.close(); + + const result1 = await branch1Reads[0]; + assert_equals(result1.done, false, 'first read() from branch1 should be not done'); + assert_typed_array_equals(result1.value, new Uint8Array([0x11]), 'first chunk from branch1 should be correct'); + const result2 = await branch2Reads[0]; + assert_equals(result2.done, false, 'first read() from branch2 should be not done'); + assert_typed_array_equals(result2.value, new Uint8Array([0x11]), 'first chunk from branch2 should be correct'); + + const result3 = await branch1Reads[1]; + assert_equals(result3.done, true, 'second read() from branch1 should be done'); + assert_typed_array_equals(result3.value, new Uint8Array([0]).subarray(0, 0), 'second chunk from branch1 should be correct'); + const result4 = await branch2Reads[1]; + assert_equals(result4.done, true, 'second read() from branch2 should be done'); + assert_typed_array_equals(result4.value, new Uint8Array([0]).subarray(0, 0), 'second chunk from branch2 should be correct'); + +}, 'ReadableStream teeing with byte source: respond() and close() while both branches are pulling'); diff --git a/test/fixtures/wpt/streams/readable-streams/async-iterator.any.js b/test/fixtures/wpt/streams/readable-streams/async-iterator.any.js index 7669a35d9a7a0c..3ccaca17bc1ac7 100644 --- a/test/fixtures/wpt/streams/readable-streams/async-iterator.any.js +++ b/test/fixtures/wpt/streams/readable-streams/async-iterator.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/rs-utils.js // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js diff --git a/test/fixtures/wpt/streams/readable-streams/bad-strategies.any.js b/test/fixtures/wpt/streams/readable-streams/bad-strategies.any.js index b795360fb7c7bb..521fbffe3ab479 100644 --- a/test/fixtures/wpt/streams/readable-streams/bad-strategies.any.js +++ b/test/fixtures/wpt/streams/readable-streams/bad-strategies.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; test(() => { diff --git a/test/fixtures/wpt/streams/readable-streams/bad-underlying-sources.any.js b/test/fixtures/wpt/streams/readable-streams/bad-underlying-sources.any.js index 6f59197a49b18b..e9cf4c924930b2 100644 --- a/test/fixtures/wpt/streams/readable-streams/bad-underlying-sources.any.js +++ b/test/fixtures/wpt/streams/readable-streams/bad-underlying-sources.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; diff --git a/test/fixtures/wpt/streams/readable-streams/cancel.any.js b/test/fixtures/wpt/streams/readable-streams/cancel.any.js index c3723a465c9988..800bd994417241 100644 --- a/test/fixtures/wpt/streams/readable-streams/cancel.any.js +++ b/test/fixtures/wpt/streams/readable-streams/cancel.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/rs-utils.js 'use strict'; diff --git a/test/fixtures/wpt/streams/readable-streams/constructor.any.js b/test/fixtures/wpt/streams/readable-streams/constructor.any.js index dcfd9e9c33861f..608dc48cfa39d7 100644 --- a/test/fixtures/wpt/streams/readable-streams/constructor.any.js +++ b/test/fixtures/wpt/streams/readable-streams/constructor.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; const error1 = new Error('error1'); diff --git a/test/fixtures/wpt/streams/readable-streams/count-queuing-strategy-integration.any.js b/test/fixtures/wpt/streams/readable-streams/count-queuing-strategy-integration.any.js index 78a25318b2dd5a..02ac5bae5c2f8a 100644 --- a/test/fixtures/wpt/streams/readable-streams/count-queuing-strategy-integration.any.js +++ b/test/fixtures/wpt/streams/readable-streams/count-queuing-strategy-integration.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; test(() => { diff --git a/test/fixtures/wpt/streams/readable-streams/crashtests/empty.js b/test/fixtures/wpt/streams/readable-streams/crashtests/empty.js new file mode 100644 index 00000000000000..e69de29bb2d1d6 diff --git a/test/fixtures/wpt/streams/readable-streams/crashtests/strategy-worker-terminate.html b/test/fixtures/wpt/streams/readable-streams/crashtests/strategy-worker-terminate.html new file mode 100644 index 00000000000000..a75c3c66b688df --- /dev/null +++ b/test/fixtures/wpt/streams/readable-streams/crashtests/strategy-worker-terminate.html @@ -0,0 +1,10 @@ + + + + diff --git a/test/fixtures/wpt/streams/readable-streams/crashtests/strategy-worker.js b/test/fixtures/wpt/streams/readable-streams/crashtests/strategy-worker.js new file mode 100644 index 00000000000000..dd0ab03b55f5f9 --- /dev/null +++ b/test/fixtures/wpt/streams/readable-streams/crashtests/strategy-worker.js @@ -0,0 +1,4 @@ +var b = new CountQueuingStrategy({ highWaterMark: 3 }); + +importScripts("empty.js"); +postMessage("done"); diff --git a/test/fixtures/wpt/streams/readable-streams/cross-realm-crash.window.js b/test/fixtures/wpt/streams/readable-streams/cross-realm-crash.window.js new file mode 100644 index 00000000000000..5fc7ce37a5f6d2 --- /dev/null +++ b/test/fixtures/wpt/streams/readable-streams/cross-realm-crash.window.js @@ -0,0 +1,13 @@ +// This is a repro for a crash bug that existed in Blink. See +// https://crbug.com/1290014. If there's no crash then the test passed. + +test(t => { + const iframeTag = document.createElement('iframe'); + document.body.appendChild(iframeTag); + + const readableStream = new ReadableStream(); + const reader = new iframeTag.contentWindow.ReadableStreamDefaultReader(readableStream); + iframeTag.remove(); + reader.cancel(); + reader.read(); +}, 'should not crash on reading from stream cancelled in destroyed realm'); diff --git a/test/fixtures/wpt/streams/readable-streams/default-reader.any.js b/test/fixtures/wpt/streams/readable-streams/default-reader.any.js index 60c740a8288631..59d7ab2f74db63 100644 --- a/test/fixtures/wpt/streams/readable-streams/default-reader.any.js +++ b/test/fixtures/wpt/streams/readable-streams/default-reader.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/rs-utils.js 'use strict'; @@ -512,3 +512,28 @@ promise_test(() => { reader.releaseLock(); }); }, 'controller.close() should clear the list of pending read requests'); + +promise_test(t => { + + let controller; + const rs = new ReadableStream({ + start(c) { + controller = c; + } + }); + + const reader1 = rs.getReader(); + const promise1 = promise_rejects_js(t, TypeError, reader1.read(), 'read() from reader1 should reject when reader1 is released'); + reader1.releaseLock(); + + controller.enqueue('a'); + + const reader2 = rs.getReader(); + const promise2 = reader2.read().then(r => { + assert_object_equals(r, { value: 'a', done: false }, 'read() from reader2 should resolve with enqueued chunk'); + }) + reader2.releaseLock(); + + return Promise.all([promise1, promise2]); + +}, 'Second reader can read chunks after first reader was released with pending read requests'); diff --git a/test/fixtures/wpt/streams/readable-streams/floating-point-total-queue-size.any.js b/test/fixtures/wpt/streams/readable-streams/floating-point-total-queue-size.any.js index 400482a450cad2..50cca3d951a942 100644 --- a/test/fixtures/wpt/streams/readable-streams/floating-point-total-queue-size.any.js +++ b/test/fixtures/wpt/streams/readable-streams/floating-point-total-queue-size.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; // Due to the limitations of floating-point precision, the calculation of desiredSize sometimes gives different answers diff --git a/test/fixtures/wpt/streams/readable-streams/garbage-collection.any.js b/test/fixtures/wpt/streams/readable-streams/garbage-collection.any.js index dad0ad1535a5bf..f7e2d06ae5cdf3 100644 --- a/test/fixtures/wpt/streams/readable-streams/garbage-collection.any.js +++ b/test/fixtures/wpt/streams/readable-streams/garbage-collection.any.js @@ -1,8 +1,8 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js 'use strict'; -promise_test(() => { +promise_test(async () => { let controller; new ReadableStream({ @@ -11,7 +11,7 @@ promise_test(() => { } }); - garbageCollect(); + await garbageCollect(); return delay(50).then(() => { controller.close(); @@ -22,7 +22,7 @@ promise_test(() => { }, 'ReadableStreamController methods should continue working properly when scripts lose their reference to the ' + 'readable stream'); -promise_test(() => { +promise_test(async () => { let controller; @@ -32,13 +32,13 @@ promise_test(() => { } }).getReader().closed; - garbageCollect(); + await garbageCollect(); return delay(50).then(() => controller.close()).then(() => closedPromise); }, 'ReadableStream closed promise should fulfill even if the stream and reader JS references are lost'); -promise_test(t => { +promise_test(async t => { const theError = new Error('boo'); let controller; @@ -49,20 +49,20 @@ promise_test(t => { } }).getReader().closed; - garbageCollect(); + await garbageCollect(); return delay(50).then(() => controller.error(theError)) .then(() => promise_rejects_exactly(t, theError, closedPromise)); }, 'ReadableStream closed promise should reject even if stream and reader JS references are lost'); -promise_test(() => { +promise_test(async () => { const rs = new ReadableStream({}); rs.getReader(); - garbageCollect(); + await garbageCollect(); return delay(50).then(() => assert_throws_js(TypeError, () => rs.getReader(), 'old reader should still be locking the stream even after garbage collection')); diff --git a/test/fixtures/wpt/streams/readable-streams/general.any.js b/test/fixtures/wpt/streams/readable-streams/general.any.js index efe7da74ad6c08..2a32b27943c82f 100644 --- a/test/fixtures/wpt/streams/readable-streams/general.any.js +++ b/test/fixtures/wpt/streams/readable-streams/general.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/rs-utils.js 'use strict'; @@ -630,6 +630,7 @@ promise_test(() => { let pullCalled = 0; let cancelCalled = 0; + /* eslint-disable no-use-before-define */ class Source { start(c) { startCalled++; diff --git a/test/fixtures/wpt/streams/readable-streams/global.html b/test/fixtures/wpt/streams/readable-streams/global.html new file mode 100644 index 00000000000000..08665d318eac88 --- /dev/null +++ b/test/fixtures/wpt/streams/readable-streams/global.html @@ -0,0 +1,162 @@ + + +Ensure Stream objects are created in expected globals. + + + + + + diff --git a/test/fixtures/wpt/streams/readable-streams/patched-global.any.js b/test/fixtures/wpt/streams/readable-streams/patched-global.any.js index d26dc56cfe6953..a64a054a97f1f5 100644 --- a/test/fixtures/wpt/streams/readable-streams/patched-global.any.js +++ b/test/fixtures/wpt/streams/readable-streams/patched-global.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; // Tests which patch the global environment are kept separate to avoid @@ -22,6 +22,7 @@ test(t => { const trappedProperties = ['highWaterMark', 'size', 'start', 'type', 'mode']; for (const property of trappedProperties) { + // eslint-disable-next-line no-extend-native, accessor-pairs Object.defineProperty(Object.prototype, property, { get() { throw new Error(`${property} getter called`); }, configurable: true diff --git a/test/fixtures/wpt/streams/readable-streams/reentrant-strategies.any.js b/test/fixtures/wpt/streams/readable-streams/reentrant-strategies.any.js index a02d08b0acc50a..b4988bc2433fd5 100644 --- a/test/fixtures/wpt/streams/readable-streams/reentrant-strategies.any.js +++ b/test/fixtures/wpt/streams/readable-streams/reentrant-strategies.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/recording-streams.js // META: script=../resources/rs-utils.js // META: script=../resources/test-utils.js diff --git a/test/fixtures/wpt/streams/readable-streams/tee.any.js b/test/fixtures/wpt/streams/readable-streams/tee.any.js index 761f6e9c3599c1..00397932f4b6e3 100644 --- a/test/fixtures/wpt/streams/readable-streams/tee.any.js +++ b/test/fixtures/wpt/streams/readable-streams/tee.any.js @@ -1,7 +1,8 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/rs-utils.js // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js +// META: script=../resources/rs-test-templates.js 'use strict'; test(() => { @@ -161,92 +162,9 @@ promise_test(() => { }, 'ReadableStream teeing: canceling branch2 should not impact branch1'); -promise_test(() => { - - const reason1 = new Error('We\'re wanted men.'); - const reason2 = new Error('I have the death sentence on twelve systems.'); - - let resolve; - const promise = new Promise(r => resolve = r); - const rs = new ReadableStream({ - cancel(reason) { - assert_array_equals(reason, [reason1, reason2], - 'the cancel reason should be an array containing those from the branches'); - resolve(); - } - }); - - const branch = rs.tee(); - const branch1 = branch[0]; - const branch2 = branch[1]; - branch1.cancel(reason1); - branch2.cancel(reason2); - - return promise; - -}, 'ReadableStream teeing: canceling both branches should aggregate the cancel reasons into an array'); - -promise_test(() => { - - const reason1 = new Error('This little one\'s not worth the effort.'); - const reason2 = new Error('Come, let me get you something.'); - - let resolve; - const promise = new Promise(r => resolve = r); - const rs = new ReadableStream({ - cancel(reason) { - assert_array_equals(reason, [reason1, reason2], - 'the cancel reason should be an array containing those from the branches'); - resolve(); - } - }); - - const branch = rs.tee(); - const branch1 = branch[0]; - const branch2 = branch[1]; - return Promise.all([ - branch2.cancel(reason2), - branch1.cancel(reason1), - promise - ]); - -}, 'ReadableStream teeing: canceling both branches in reverse order should aggregate the cancel reasons into an array'); - -promise_test(t => { - - const theError = { name: 'I\'ll be careful.' }; - const rs = new ReadableStream({ - cancel() { - throw theError; - } - }); - - const branch = rs.tee(); - const branch1 = branch[0]; - const branch2 = branch[1]; - - return Promise.all([ - promise_rejects_exactly(t, theError, branch1.cancel()), - promise_rejects_exactly(t, theError, branch2.cancel()) - ]); - -}, 'ReadableStream teeing: failing to cancel the original stream should cause cancel() to reject on branches'); - -promise_test(t => { - - const theError = { name: 'You just watch yourself!' }; - let controller; - const stream = new ReadableStream({ start(c) { controller = c; } }); - const [branch1, branch2] = stream.tee(); - - controller.error(theError); - - return Promise.all([ - promise_rejects_exactly(t, theError, branch1.cancel()), - promise_rejects_exactly(t, theError, branch2.cancel()) - ]); - -}, 'ReadableStream teeing: erroring a teed stream should properly handle canceled branches'); +templatedRSTeeCancel('ReadableStream teeing', (extras) => { + return new ReadableStream({ ...extras }); +}); promise_test(t => { @@ -539,3 +457,23 @@ promise_test(t => { }); }, 'ReadableStreamTee stops pulling when original stream errors while both branches are reading'); + +promise_test(async () => { + + const rs = recordingReadableStream(); + + const [reader1, reader2] = rs.tee().map(branch => branch.getReader()); + const branch1Reads = [reader1.read(), reader1.read()]; + const branch2Reads = [reader2.read(), reader2.read()]; + + await flushAsyncEvents(); + rs.controller.enqueue('a'); + rs.controller.close(); + + assert_object_equals(await branch1Reads[0], { value: 'a', done: false }, 'first chunk from branch1 should be correct'); + assert_object_equals(await branch2Reads[0], { value: 'a', done: false }, 'first chunk from branch2 should be correct'); + + assert_object_equals(await branch1Reads[1], { value: undefined, done: true }, 'second read() from branch1 should be done'); + assert_object_equals(await branch2Reads[1], { value: undefined, done: true }, 'second read() from branch2 should be done'); + +}, 'ReadableStream teeing: enqueue() and close() while both branches are pulling'); diff --git a/test/fixtures/wpt/streams/readable-streams/templated.any.js b/test/fixtures/wpt/streams/readable-streams/templated.any.js index 4d524e69fee19e..ecae3f4d8b129f 100644 --- a/test/fixtures/wpt/streams/readable-streams/templated.any.js +++ b/test/fixtures/wpt/streams/readable-streams/templated.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/rs-test-templates.js 'use strict'; diff --git a/test/fixtures/wpt/streams/resources/recording-streams.js b/test/fixtures/wpt/streams/resources/recording-streams.js index 34d02a143dccdb..661fe512f516c6 100644 --- a/test/fixtures/wpt/streams/resources/recording-streams.js +++ b/test/fixtures/wpt/streams/resources/recording-streams.js @@ -3,6 +3,7 @@ self.recordingReadableStream = (extras = {}, strategy) => { let controllerToCopyOver; const stream = new ReadableStream({ + type: extras.type, start(controller) { controllerToCopyOver = controller; diff --git a/test/fixtures/wpt/streams/resources/rs-test-templates.js b/test/fixtures/wpt/streams/resources/rs-test-templates.js index 700bd9c3ca9f9e..25751c477f5dc8 100644 --- a/test/fixtures/wpt/streams/resources/rs-test-templates.js +++ b/test/fixtures/wpt/streams/resources/rs-test-templates.js @@ -251,34 +251,27 @@ self.templatedRSEmptyReader = (label, factory) => { }, label + ': getReader() again on the stream should fail'); - promise_test(t => { + promise_test(async t => { const streamAndReader = factory(); const stream = streamAndReader.stream; const reader = streamAndReader.reader; - reader.read().then( - t.unreached_func('first read() should not fulfill'), - t.unreached_func('first read() should not reject') - ); - - reader.read().then( - t.unreached_func('second read() should not fulfill'), - t.unreached_func('second read() should not reject') - ); + const read1 = reader.read(); + const read2 = reader.read(); + const closed = reader.closed; - reader.closed.then( - t.unreached_func('closed should not fulfill'), - t.unreached_func('closed should not reject') - ); - - assert_throws_js(TypeError, () => reader.releaseLock(), 'releaseLock should throw a TypeError'); + reader.releaseLock(); - assert_true(stream.locked, 'the stream should still be locked'); + assert_false(stream.locked, 'the stream should be unlocked'); - return delay(500); + await Promise.all([ + promise_rejects_js(t, TypeError, read1, 'first read should reject'), + promise_rejects_js(t, TypeError, read2, 'second read should reject'), + promise_rejects_js(t, TypeError, closed, 'closed should reject') + ]); - }, label + ': releasing the lock with pending read requests should throw but the read requests should stay pending'); + }, label + ': releasing the lock should reject all pending read requests'); promise_test(t => { @@ -636,3 +629,93 @@ self.templatedRSTwoChunksClosedReader = function (label, factory, chunks) { }, label + ': reader\'s closed property always returns the same promise'); }; + +self.templatedRSTeeCancel = (label, factory) => { + test(() => {}, `Running templatedRSTeeCancel with ${label}`); + + promise_test(async () => { + + const reason1 = new Error('We\'re wanted men.'); + const reason2 = new Error('I have the death sentence on twelve systems.'); + + let resolve; + const promise = new Promise(r => resolve = r); + const rs = factory({ + cancel(reason) { + assert_array_equals(reason, [reason1, reason2], + 'the cancel reason should be an array containing those from the branches'); + resolve(); + } + }); + + const [branch1, branch2] = rs.tee(); + await Promise.all([ + branch1.cancel(reason1), + branch2.cancel(reason2), + promise + ]); + + }, `${label}: canceling both branches should aggregate the cancel reasons into an array`); + + promise_test(async () => { + + const reason1 = new Error('This little one\'s not worth the effort.'); + const reason2 = new Error('Come, let me get you something.'); + + let resolve; + const promise = new Promise(r => resolve = r); + const rs = factory({ + cancel(reason) { + assert_array_equals(reason, [reason1, reason2], + 'the cancel reason should be an array containing those from the branches'); + resolve(); + } + }); + + const [branch1, branch2] = rs.tee(); + await Promise.all([ + branch2.cancel(reason2), + branch1.cancel(reason1), + promise + ]); + + }, `${label}: canceling both branches in reverse order should aggregate the cancel reasons into an array`); + + promise_test(async t => { + + const theError = { name: 'I\'ll be careful.' }; + const rs = factory({ + cancel() { + throw theError; + } + }); + + const [branch1, branch2] = rs.tee(); + await Promise.all([ + promise_rejects_exactly(t, theError, branch1.cancel()), + promise_rejects_exactly(t, theError, branch2.cancel()) + ]); + + }, `${label}: failing to cancel the original stream should cause cancel() to reject on branches`); + + promise_test(async t => { + + const theError = { name: 'You just watch yourself!' }; + let controller; + const stream = factory({ + start(c) { + controller = c; + } + }); + + const [branch1, branch2] = stream.tee(); + controller.error(theError); + + await Promise.all([ + promise_rejects_exactly(t, theError, branch1.cancel()), + promise_rejects_exactly(t, theError, branch2.cancel()) + ]); + + }, `${label}: erroring a teed stream should properly handle canceled branches`); + +}; diff --git a/test/fixtures/wpt/streams/resources/test-utils.js b/test/fixtures/wpt/streams/resources/test-utils.js index 97d4261aa0507a..fb34e270ff3718 100644 --- a/test/fixtures/wpt/streams/resources/test-utils.js +++ b/test/fixtures/wpt/streams/resources/test-utils.js @@ -47,8 +47,11 @@ self.constructorThrowsForAll = (constructor, firstArgs) => { 'constructor should throw a TypeError')); }; -self.garbageCollect = () => { - if (self.gc) { +self.garbageCollect = async () => { + if (self.TestUtils?.gc) { + // https://testutils.spec.whatwg.org/#the-testutils-namespace + await TestUtils.gc(); + } else if (self.gc) { // Use --expose_gc for V8 (and Node.js) // to pass this flag at chrome launch use: --js-flags="--expose-gc" // Exposed in SpiderMonkey shell as well @@ -57,6 +60,7 @@ self.garbageCollect = () => { // Present in some WebKit development environments GCController.collect(); } else { + /* eslint-disable no-console */ console.warn('Tests are running without the ability to do manual garbage collection. They will still work, but ' + 'coverage will be suboptimal.'); /* eslint-enable no-console */ @@ -71,3 +75,20 @@ self.delay = ms => new Promise(resolve => step_timeout(resolve, ms)); // Some tests include promise resolutions which may mean the test code takes a couple of event loop visits itself. So go // around an extra 2 times to avoid complicating those tests. self.flushAsyncEvents = () => delay(0).then(() => delay(0)).then(() => delay(0)).then(() => delay(0)); + +self.assert_typed_array_equals = (actual, expected, message) => { + const prefix = message === undefined ? '' : `${message} `; + assert_equals(typeof actual, 'object', `${prefix}type is object`); + assert_equals(actual.constructor, expected.constructor, `${prefix}constructor`); + assert_equals(actual.byteOffset, expected.byteOffset, `${prefix}byteOffset`); + assert_equals(actual.byteLength, expected.byteLength, `${prefix}byteLength`); + assert_equals(actual.buffer.byteLength, expected.buffer.byteLength, `${prefix}buffer.byteLength`); + assert_array_equals([...actual], [...expected], `${prefix}contents`); + assert_array_equals([...new Uint8Array(actual.buffer)], [...new Uint8Array(expected.buffer)], `${prefix}buffer contents`); +}; + +self.makePromiseAndResolveFunc = () => { + let resolve; + const promise = new Promise(r => { resolve = r; }); + return [promise, resolve]; +}; diff --git a/test/fixtures/wpt/streams/transferable/readable-stream.html b/test/fixtures/wpt/streams/transferable/readable-stream.html index 59b57ce6723c10..b1ede4695bf4cd 100644 --- a/test/fixtures/wpt/streams/transferable/readable-stream.html +++ b/test/fixtures/wpt/streams/transferable/readable-stream.html @@ -135,10 +135,23 @@ assert_array_equals(rs.events, ['pull'], 'pull() should have been called'); }, 'the extra queue from transferring is counted in chunks'); +async function transferredReadableStreamWithCancelPromise() { + let resolveCancelCalled; + const cancelCalled = new Promise(resolve => { + resolveCancelCalled = resolve; + }); + const rs = await recordingTransferredReadableStream({ + cancel() { + resolveCancelCalled(); + } + }); + return { rs, cancelCalled }; +} + promise_test(async () => { - const rs = await recordingTransferredReadableStream(); + const { rs, cancelCalled } = await transferredReadableStreamWithCancelPromise(); rs.cancel('message'); - await delay(0); + await cancelCalled; assert_array_equals(rs.events, ['pull', 'cancel', 'message'], 'cancel() should have been called'); const reader = rs.getReader(); @@ -147,15 +160,7 @@ }, 'cancel should be propagated to the original'); promise_test(async () => { - let resolveCancelCalled; - const cancelCalled = new Promise(resolve => { - resolveCancelCalled = resolve; - }); - const rs = await recordingTransferredReadableStream({ - cancel() { - resolveCancelCalled(); - } - }); + const { rs, cancelCalled } = await transferredReadableStreamWithCancelPromise(); const reader = rs.getReader(); const readPromise = reader.read(); reader.cancel('done'); diff --git a/test/fixtures/wpt/streams/transferable/transfer-with-messageport.window.js b/test/fixtures/wpt/streams/transferable/transfer-with-messageport.window.js new file mode 100644 index 00000000000000..37f8c9df169607 --- /dev/null +++ b/test/fixtures/wpt/streams/transferable/transfer-with-messageport.window.js @@ -0,0 +1,219 @@ +"use strict"; + +function receiveEventOnce(target, name) { + return new Promise(resolve => { + target.addEventListener( + name, + ev => { + resolve(ev); + }, + { once: true } + ); + }); +} + +async function postAndTestMessageEvent(data, transfer, title) { + postMessage(data, "*", transfer); + const messagePortCount = transfer.filter(i => i instanceof MessagePort) + .length; + const ev = await receiveEventOnce(window, "message"); + assert_equals( + ev.ports.length, + messagePortCount, + `Correct number of ports ${title}` + ); + for (const [i, port] of ev.ports.entries()) { + assert_true( + port instanceof MessagePort, + `ports[${i}] include MessagePort ${title}` + ); + } + for (const [key, value] of Object.entries(data)) { + assert_true( + ev.data[key] instanceof value.constructor, + `data.${key} has correct interface ${value.constructor.name} ${title}` + ); + } +} + +async function transferMessagePortWithOrder1(stream) { + const channel = new MessageChannel(); + await postAndTestMessageEvent( + { stream, port2: channel.port2 }, + [stream, channel.port2], + `when transferring [${stream.constructor.name}, MessagePort]` + ); +} + +async function transferMessagePortWithOrder2(stream) { + const channel = new MessageChannel(); + await postAndTestMessageEvent( + { stream, port2: channel.port2 }, + [channel.port2, stream], + `when transferring [MessagePort, ${stream.constructor.name}]` + ); +} + +async function transferMessagePortWithOrder3(stream) { + const channel = new MessageChannel(); + await postAndTestMessageEvent( + { port1: channel.port1, stream, port2: channel.port2 }, + [channel.port1, stream, channel.port2], + `when transferring [MessagePort, ${stream.constructor.name}, MessagePort]` + ); +} + +async function transferMessagePortWithOrder4(stream) { + const channel = new MessageChannel(); + await postAndTestMessageEvent( + {}, + [channel.port1, stream, channel.port2], + `when transferring [MessagePort, ${stream.constructor.name}, MessagePort] but with empty data` + ); +} + +async function transferMessagePortWithOrder5(stream) { + const channel = new MessageChannel(); + await postAndTestMessageEvent( + { port2: channel.port2, port1: channel.port1, stream }, + [channel.port1, stream, channel.port2], + `when transferring [MessagePort, ${stream.constructor.name}, MessagePort] but with data having different order` + ); +} + +async function transferMessagePortWithOrder6(stream) { + const channel = new MessageChannel(); + await postAndTestMessageEvent( + { port2: channel.port2, port1: channel.port1 }, + [channel.port1, stream, channel.port2], + `when transferring [MessagePort, ${stream.constructor.name}, MessagePort] but with stream not being in the data` + ); +} + +async function transferMessagePortWithOrder7(stream) { + const channel = new MessageChannel(); + await postAndTestMessageEvent( + { stream }, + [channel.port1, stream, channel.port2], + `when transferring [MessagePort, ${stream.constructor.name}, MessagePort] but with ports not being in the data` + ); +} + +async function transferMessagePortWith(constructor) { + await transferMessagePortWithOrder1(new constructor()); + await transferMessagePortWithOrder2(new constructor()); + await transferMessagePortWithOrder3(new constructor()); +} + +async function advancedTransferMesagePortWith(constructor) { + await transferMessagePortWithOrder4(new constructor()); + await transferMessagePortWithOrder5(new constructor()); + await transferMessagePortWithOrder6(new constructor()); + await transferMessagePortWithOrder7(new constructor()); +} + +async function mixedTransferMessagePortWithOrder1() { + const channel = new MessageChannel(); + const readable = new ReadableStream(); + const writable = new WritableStream(); + const transform = new TransformStream(); + await postAndTestMessageEvent( + { + readable, + writable, + transform, + port1: channel.port1, + port2: channel.port2, + }, + [readable, writable, transform, channel.port1, channel.port2], + `when transferring [ReadableStream, WritableStream, TransformStream, MessagePort, MessagePort]` + ); +} + +async function mixedTransferMessagePortWithOrder2() { + const channel = new MessageChannel(); + const readable = new ReadableStream(); + const writable = new WritableStream(); + const transform = new TransformStream(); + await postAndTestMessageEvent( + { readable, writable, transform }, + [transform, channel.port1, readable, channel.port2, writable], + `when transferring [TransformStream, MessagePort, ReadableStream, MessagePort, WritableStream]` + ); +} + +async function mixedTransferMessagePortWithOrder3() { + const channel = new MessageChannel(); + const readable1 = new ReadableStream(); + const readable2 = new ReadableStream(); + const writable1 = new WritableStream(); + const writable2 = new WritableStream(); + const transform1 = new TransformStream(); + const transform2 = new TransformStream(); + await postAndTestMessageEvent( + { readable1, writable1, transform1, readable2, writable2, transform2 }, + [ + transform2, + channel.port1, + readable1, + channel.port2, + writable2, + readable2, + writable1, + transform1, + ], + `when transferring [TransformStream, MessagePort, ReadableStream, MessagePort, WritableStream, ReadableStream, WritableStream, TransformStream] but with the data having different order` + ); +} + +async function mixedTransferMesagePortWith() { + await mixedTransferMessagePortWithOrder1(); + await mixedTransferMessagePortWithOrder2(); + await mixedTransferMessagePortWithOrder3(); +} + +promise_test(async t => { + await transferMessagePortWith(ReadableStream); +}, "Transferring a MessagePort with a ReadableStream should set `.ports`"); + +promise_test(async t => { + await transferMessagePortWith(WritableStream); +}, "Transferring a MessagePort with a WritableStream should set `.ports`"); + +promise_test(async t => { + await transferMessagePortWith(TransformStream); +}, "Transferring a MessagePort with a TransformStream should set `.ports`"); + +promise_test(async t => { + await transferMessagePortWith(ReadableStream); +}, "Transferring a MessagePort with a ReadableStream should set `.ports`, advanced"); + +promise_test(async t => { + await transferMessagePortWith(WritableStream); +}, "Transferring a MessagePort with a WritableStream should set `.ports`, advanced"); + +promise_test(async t => { + await transferMessagePortWith(TransformStream); +}, "Transferring a MessagePort with a TransformStream should set `.ports`, advanced"); + +promise_test(async t => { + await mixedTransferMesagePortWith(); +}, "Transferring a MessagePort with multiple streams should set `.ports`"); + +test(() => { + assert_throws_dom("DataCloneError", () => + postMessage({ stream: new ReadableStream() }, "*") + ); +}, "ReadableStream must not be serializable"); + +test(() => { + assert_throws_dom("DataCloneError", () => + postMessage({ stream: new WritableStream() }, "*") + ); +}, "WritableStream must not be serializable"); + +test(() => { + assert_throws_dom("DataCloneError", () => + postMessage({ stream: new TransformStream() }, "*") + ); +}, "TransformStream must not be serializable"); diff --git a/test/fixtures/wpt/streams/transferable/transform-stream.html b/test/fixtures/wpt/streams/transferable/transform-stream.html index fbfbfe8fc1347a..355d5d807433d7 100644 --- a/test/fixtures/wpt/streams/transferable/transform-stream.html +++ b/test/fixtures/wpt/streams/transferable/transform-stream.html @@ -66,9 +66,14 @@ controller.close(); } }); + let resolve; + const ready = new Promise(r => resolve = r); let result = ''; const sink = new WritableStream({ write(chunk) { + if (result) { + resolve(); + } result += chunk; } }); @@ -93,8 +98,7 @@ }); postMessage({source, sink, transform1, transform2}, '*', [source, transform1, sink, transform2]); - return promise - .then(() => delay(0)) + return ready .then(() => { assert_equals(result, 'HELLO HELLO THERE THERE ', 'transforms should have been applied'); diff --git a/test/fixtures/wpt/streams/transferable/window.html b/test/fixtures/wpt/streams/transferable/window.html index beaf548fe641c5..11c868356b69a1 100644 --- a/test/fixtures/wpt/streams/transferable/window.html +++ b/test/fixtures/wpt/streams/transferable/window.html @@ -16,15 +16,10 @@ promise_test(t => { const orig = createOriginalReadableStream(); - const promise = new Promise(resolve => { - window.addEventListener('message', msg => { - const port = msg.data; - resolve(testMessageEvent(port)); - port.start(); - }, {once: true}); - }); const mc = new MessageChannel(); - postMessage(mc.port1, '*', [mc.port1]); + const promise = testMessageEvent(mc.port1); + mc.port1.start(); + mc.port2.postMessage(orig, [orig]); mc.port2.close(); assert_true(orig.locked, 'the original stream should be locked'); diff --git a/test/fixtures/wpt/streams/transferable/writable-stream.html b/test/fixtures/wpt/streams/transferable/writable-stream.html index adc6f457c27e87..7e25dad94d4cfd 100644 --- a/test/fixtures/wpt/streams/transferable/writable-stream.html +++ b/test/fixtures/wpt/streams/transferable/writable-stream.html @@ -87,9 +87,11 @@ }, 'effective queue size of a transferred writable should be 2'); promise_test(async () => { + const [writeCalled, resolveWriteCalled] = makePromiseAndResolveFunc(); let resolveWrite; const orig = new WritableStream({ write() { + resolveWriteCalled(); return new Promise(resolve => { resolveWrite = resolve; }); @@ -99,35 +101,43 @@ const writer = transferred.getWriter(); await writer.write('a'); let writeDone = false; - writer.write('b').then(() => { + const writePromise = writer.write('b').then(() => { writeDone = true; }); - await flushAsyncEvents(); + await writeCalled; assert_false(writeDone, 'second write should not have resolved yet'); resolveWrite(); - await delay(0); - assert_true(writeDone, 'second write should have resolved'); + await writePromise; // (makes sure this resolves) }, 'second write should wait for first underlying write to complete'); -promise_test(async t => { - const orig = recordingWritableStream(); +async function transferredWritableStreamWithAbortPromise() { + const [abortCalled, resolveAbortCalled] = makePromiseAndResolveFunc(); + const orig = recordingWritableStream({ + abort() { + resolveAbortCalled(); + } + }); const transferred = await transfer(orig); + return { orig, transferred, abortCalled }; +} + +promise_test(async t => { + const { orig, transferred, abortCalled } = await transferredWritableStreamWithAbortPromise(); transferred.abort('p'); - await delay(0); + await abortCalled; assert_array_equals(orig.events, ['abort', 'p'], 'abort() should have been called'); }, 'abort() should work'); promise_test(async t => { - const orig = recordingWritableStream(); - const transferred = await transfer(orig); + const { orig, transferred, abortCalled } = await transferredWritableStreamWithAbortPromise(); const writer = transferred.getWriter(); // A WritableStream object cannot be cloned. await promise_rejects_dom(t, 'DataCloneError', writer.write(new WritableStream()), 'the write should reject'); await promise_rejects_dom(t, 'DataCloneError', writer.closed, 'the stream should be errored'); - await delay(0); + await abortCalled; assert_equals(orig.events.length, 2, 'abort should have been called'); assert_equals(orig.events[0], 'abort', 'first event should be abort'); assert_equals(orig.events[1].name, 'DataCloneError', diff --git a/test/fixtures/wpt/streams/transform-streams/backpressure.any.js b/test/fixtures/wpt/streams/transform-streams/backpressure.any.js index 64c9d0930ed2f2..6befba41b79542 100644 --- a/test/fixtures/wpt/streams/transform-streams/backpressure.any.js +++ b/test/fixtures/wpt/streams/transform-streams/backpressure.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/recording-streams.js // META: script=../resources/test-utils.js 'use strict'; diff --git a/test/fixtures/wpt/streams/transform-streams/errors.any.js b/test/fixtures/wpt/streams/transform-streams/errors.any.js index ba26b32b75a6a4..0cca4c75479d6d 100644 --- a/test/fixtures/wpt/streams/transform-streams/errors.any.js +++ b/test/fixtures/wpt/streams/transform-streams/errors.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js 'use strict'; diff --git a/test/fixtures/wpt/streams/transform-streams/flush.any.js b/test/fixtures/wpt/streams/transform-streams/flush.any.js index dc40532957b14b..9287f6f5eb78eb 100644 --- a/test/fixtures/wpt/streams/transform-streams/flush.any.js +++ b/test/fixtures/wpt/streams/transform-streams/flush.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js 'use strict'; diff --git a/test/fixtures/wpt/streams/transform-streams/general.any.js b/test/fixtures/wpt/streams/transform-streams/general.any.js index d4f2a1d5a29cf6..c95691f7bf49df 100644 --- a/test/fixtures/wpt/streams/transform-streams/general.any.js +++ b/test/fixtures/wpt/streams/transform-streams/general.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/rs-utils.js 'use strict'; diff --git a/test/fixtures/wpt/streams/transform-streams/lipfuzz.any.js b/test/fixtures/wpt/streams/transform-streams/lipfuzz.any.js index c8c3803c6dfb4b..f9f148aaf1c6a4 100644 --- a/test/fixtures/wpt/streams/transform-streams/lipfuzz.any.js +++ b/test/fixtures/wpt/streams/transform-streams/lipfuzz.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; class LipFuzzTransformer { diff --git a/test/fixtures/wpt/streams/transform-streams/patched-global.any.js b/test/fixtures/wpt/streams/transform-streams/patched-global.any.js index 5bce0cb41ce437..2d04e3b948b324 100644 --- a/test/fixtures/wpt/streams/transform-streams/patched-global.any.js +++ b/test/fixtures/wpt/streams/transform-streams/patched-global.any.js @@ -1,15 +1,17 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; // Tests which patch the global environment are kept separate to avoid // interfering with other tests. test(t => { + // eslint-disable-next-line no-extend-native, accessor-pairs Object.defineProperty(Object.prototype, 'highWaterMark', { set() { throw new Error('highWaterMark setter called'); }, configurable: true }); + // eslint-disable-next-line no-extend-native, accessor-pairs Object.defineProperty(Object.prototype, 'size', { set() { throw new Error('size setter called'); }, configurable: true diff --git a/test/fixtures/wpt/streams/transform-streams/properties.any.js b/test/fixtures/wpt/streams/transform-streams/properties.any.js index f2ac482e0de223..02981b8bc76a5f 100644 --- a/test/fixtures/wpt/streams/transform-streams/properties.any.js +++ b/test/fixtures/wpt/streams/transform-streams/properties.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; const transformerMethods = { diff --git a/test/fixtures/wpt/streams/transform-streams/reentrant-strategies.any.js b/test/fixtures/wpt/streams/transform-streams/reentrant-strategies.any.js index 31e53949f3c26e..fc2f91886659f6 100644 --- a/test/fixtures/wpt/streams/transform-streams/reentrant-strategies.any.js +++ b/test/fixtures/wpt/streams/transform-streams/reentrant-strategies.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/recording-streams.js // META: script=../resources/rs-utils.js // META: script=../resources/test-utils.js diff --git a/test/fixtures/wpt/streams/transform-streams/strategies.any.js b/test/fixtures/wpt/streams/transform-streams/strategies.any.js index d465d31ab09736..94055ad99dc94b 100644 --- a/test/fixtures/wpt/streams/transform-streams/strategies.any.js +++ b/test/fixtures/wpt/streams/transform-streams/strategies.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/recording-streams.js // META: script=../resources/test-utils.js 'use strict'; diff --git a/test/fixtures/wpt/streams/transform-streams/terminate.any.js b/test/fixtures/wpt/streams/transform-streams/terminate.any.js index 8cb10679348b50..670006366db2af 100644 --- a/test/fixtures/wpt/streams/transform-streams/terminate.any.js +++ b/test/fixtures/wpt/streams/transform-streams/terminate.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/recording-streams.js // META: script=../resources/test-utils.js 'use strict'; diff --git a/test/fixtures/wpt/streams/writable-streams/aborting.any.js b/test/fixtures/wpt/streams/writable-streams/aborting.any.js index ab154a705ed0e9..e016cd191b876f 100644 --- a/test/fixtures/wpt/streams/writable-streams/aborting.any.js +++ b/test/fixtures/wpt/streams/writable-streams/aborting.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; @@ -1384,10 +1384,10 @@ test(t => { assert_true(ctrl.signal instanceof AbortSignal); assert_false(ctrl.signal.aborted); - assert_equals(ctrl.abortReason, undefined); + assert_equals(ctrl.signal.reason, undefined, 'signal.reason before abort'); ws.abort(e); assert_true(ctrl.signal.aborted); - assert_equals(ctrl.abortReason, e); + assert_equals(ctrl.signal.reason, e); }, 'WritableStreamDefaultController.signal'); promise_test(async t => { @@ -1405,10 +1405,11 @@ promise_test(async t => { await called; assert_false(ctrl.signal.aborted); - assert_equals(ctrl.abortReason, undefined); + assert_equals(ctrl.signal.reason, undefined, 'signal.reason before abort'); writer.abort(); assert_true(ctrl.signal.aborted); - assert_equals(ctrl.abortReason, undefined); + assert_true(ctrl.signal.reason instanceof DOMException, 'signal.reason is a DOMException'); + assert_equals(ctrl.signal.reason.name, 'AbortError', 'signal.reason is an AbortError'); }, 'the abort signal is signalled synchronously - write'); promise_test(async t => { diff --git a/test/fixtures/wpt/streams/writable-streams/bad-strategies.any.js b/test/fixtures/wpt/streams/writable-streams/bad-strategies.any.js index b180bae57c0585..63fa443065ee41 100644 --- a/test/fixtures/wpt/streams/writable-streams/bad-strategies.any.js +++ b/test/fixtures/wpt/streams/writable-streams/bad-strategies.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; const error1 = new Error('a unique string'); diff --git a/test/fixtures/wpt/streams/writable-streams/bad-underlying-sinks.any.js b/test/fixtures/wpt/streams/writable-streams/bad-underlying-sinks.any.js index 0bfc036246a870..d0b3467978ea05 100644 --- a/test/fixtures/wpt/streams/writable-streams/bad-underlying-sinks.any.js +++ b/test/fixtures/wpt/streams/writable-streams/bad-underlying-sinks.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/writable-streams/byte-length-queuing-strategy.any.js b/test/fixtures/wpt/streams/writable-streams/byte-length-queuing-strategy.any.js index 9a61dd7cc69787..ce1962e8917f32 100644 --- a/test/fixtures/wpt/streams/writable-streams/byte-length-queuing-strategy.any.js +++ b/test/fixtures/wpt/streams/writable-streams/byte-length-queuing-strategy.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; promise_test(t => { diff --git a/test/fixtures/wpt/streams/writable-streams/close.any.js b/test/fixtures/wpt/streams/writable-streams/close.any.js index cf997ed84cdcac..88855a92efd550 100644 --- a/test/fixtures/wpt/streams/writable-streams/close.any.js +++ b/test/fixtures/wpt/streams/writable-streams/close.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/writable-streams/constructor.any.js b/test/fixtures/wpt/streams/writable-streams/constructor.any.js index 75eed2a993fe5e..eaac90e48b8f86 100644 --- a/test/fixtures/wpt/streams/writable-streams/constructor.any.js +++ b/test/fixtures/wpt/streams/writable-streams/constructor.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; const error1 = new Error('error1'); diff --git a/test/fixtures/wpt/streams/writable-streams/count-queuing-strategy.any.js b/test/fixtures/wpt/streams/writable-streams/count-queuing-strategy.any.js index 30edb3eb315c62..064e16e81506f1 100644 --- a/test/fixtures/wpt/streams/writable-streams/count-queuing-strategy.any.js +++ b/test/fixtures/wpt/streams/writable-streams/count-queuing-strategy.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; test(() => { diff --git a/test/fixtures/wpt/streams/writable-streams/error.any.js b/test/fixtures/wpt/streams/writable-streams/error.any.js index be986fccc6eac6..faf3fdd9521430 100644 --- a/test/fixtures/wpt/streams/writable-streams/error.any.js +++ b/test/fixtures/wpt/streams/writable-streams/error.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; const error1 = new Error('error1'); diff --git a/test/fixtures/wpt/streams/writable-streams/floating-point-total-queue-size.any.js b/test/fixtures/wpt/streams/writable-streams/floating-point-total-queue-size.any.js index 8e77ba0bb31185..bd34cc53a69579 100644 --- a/test/fixtures/wpt/streams/writable-streams/floating-point-total-queue-size.any.js +++ b/test/fixtures/wpt/streams/writable-streams/floating-point-total-queue-size.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; // Due to the limitations of floating-point precision, the calculation of desiredSize sometimes gives different answers diff --git a/test/fixtures/wpt/streams/writable-streams/general.any.js b/test/fixtures/wpt/streams/writable-streams/general.any.js index fdd10b29aa0ebc..cede7fd0845b74 100644 --- a/test/fixtures/wpt/streams/writable-streams/general.any.js +++ b/test/fixtures/wpt/streams/writable-streams/general.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; test(() => { diff --git a/test/fixtures/wpt/streams/writable-streams/properties.any.js b/test/fixtures/wpt/streams/writable-streams/properties.any.js index 0f7f876d8b6fc4..c95bd7d0c080ba 100644 --- a/test/fixtures/wpt/streams/writable-streams/properties.any.js +++ b/test/fixtures/wpt/streams/writable-streams/properties.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker 'use strict'; const sinkMethods = { diff --git a/test/fixtures/wpt/streams/writable-streams/reentrant-strategy.any.js b/test/fixtures/wpt/streams/writable-streams/reentrant-strategy.any.js index afde413b4252d1..eb05cc068043ea 100644 --- a/test/fixtures/wpt/streams/writable-streams/reentrant-strategy.any.js +++ b/test/fixtures/wpt/streams/writable-streams/reentrant-strategy.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/writable-streams/start.any.js b/test/fixtures/wpt/streams/writable-streams/start.any.js index 02b5f2a387625a..82d869430dd700 100644 --- a/test/fixtures/wpt/streams/writable-streams/start.any.js +++ b/test/fixtures/wpt/streams/writable-streams/start.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/streams/writable-streams/write.any.js b/test/fixtures/wpt/streams/writable-streams/write.any.js index e3defa834820d4..f0246f6cad39fd 100644 --- a/test/fixtures/wpt/streams/writable-streams/write.any.js +++ b/test/fixtures/wpt/streams/writable-streams/write.any.js @@ -1,4 +1,4 @@ -// META: global=window,worker,jsshell +// META: global=window,worker // META: script=../resources/test-utils.js // META: script=../resources/recording-streams.js 'use strict'; diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json index 4cd0db3c499d59..3e223cd7d93b35 100644 --- a/test/fixtures/wpt/versions.json +++ b/test/fixtures/wpt/versions.json @@ -56,7 +56,7 @@ "path": "resources" }, "streams": { - "commit": "8f60d9443949c323522a2009518d54d5d6ab5541", + "commit": "9e5ef42bd34b5b19b76d0d4cb19012e52c222664", "path": "streams" }, "url": { diff --git a/test/wpt/status/streams.json b/test/wpt/status/streams.json index b45fb191f2fcf8..a0b258c4325b4a 100644 --- a/test/wpt/status/streams.json +++ b/test/wpt/status/streams.json @@ -1,8 +1,115 @@ { + "piping/abort.any.js": { + "fail": { + "expected": [ + "(reason: 'null') all the error objects should be the same object", + "(reason: 'undefined') all the error objects should be the same object", + "(reason: 'error1: error1') all the error objects should be the same object", + "(reason: 'null') abort should prevent further reads", + "(reason: 'undefined') abort should prevent further reads", + "(reason: 'error1: error1') abort should prevent further reads", + "(reason: 'null') all pending writes should complete on abort", + "(reason: 'undefined') all pending writes should complete on abort", + "(reason: 'error1: error1') all pending writes should complete on abort", + "pipeTo on a teed readable byte stream should only be aborted when both branches are aborted" + ] + } + }, "queuing-strategies-size-function-per-global.window.js": { "skip": "Browser-specific test" }, + "queuing-strategies.any.js": { + "fail": { + "expected": [ + "CountQueuingStrategy: size should not have a prototype property", + "ByteLengthQueuingStrategy: size should not have a prototype property", + "CountQueuingStrategy: size should not be a constructor", + "ByteLengthQueuingStrategy: size should not be a constructor" + ] + } + }, + "readable-byte-streams/general.any.js": { + "fail": { + "expected": [ + "ReadableStream with byte source: releaseLock() on ReadableStreamDefaultReader must reject pending read()", + "ReadableStream with byte source: releaseLock() on ReadableStreamBYOBReader must reject pending read()", + "pull() resolving should not resolve read()", + "ReadableStream with byte source: enqueue() discards auto-allocated BYOB request", + "ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, respond()", + "ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader with 1 element Uint16Array, respond(1)", + "ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader with 2 element Uint8Array, respond(3)", + "ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, respondWithNewView()", + "ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, enqueue()", + "ReadableStream with byte source: releaseLock() with pending read(view), read(view) on second reader, close(), respond(0)", + "ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read() on second reader, respond()", + "ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read() on second reader, enqueue()", + "ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read(view) on second reader, respond()", + "ReadableStream with byte source: autoAllocateChunkSize, releaseLock() with pending read(), read(view) on second reader, enqueue()", + "ReadableStream with byte source: read(view) with 1 element Uint16Array, respond(1), releaseLock(), read(view) on second reader with 1 element Uint16Array, respond(1)", + "ReadableStream with byte source: read(view) with 1 element Uint16Array, respond(1), releaseLock(), read() on second reader, enqueue()" + ] + } + }, + "readable-byte-streams/tee.any.js": { + "fail": { + "expected": [ + "ReadableStream teeing with byte source: should be able to read one branch to the end without affecting the other", + "ReadableStream teeing with byte source: chunks should be cloned for each branch", + "ReadableStream teeing with byte source: chunks for BYOB requests from branch 1 should be cloned to branch 2", + "ReadableStream teeing with byte source: errors in the source should propagate to both branches", + "ReadableStream teeing with byte source: closing the original should close the branches", + "ReadableStream teeing with byte source: erroring the original should immediately error the branches", + "ReadableStream teeing with byte source: erroring the original should error pending reads from BYOB reader", + "ReadableStream teeing with byte source: canceling branch1 should finish when branch2 reads until end of stream", + "ReadableStream teeing with byte source: canceling branch1 should finish when original stream errors", + "ReadableStream teeing with byte source: should not pull any chunks if no branches are reading", + "ReadableStream teeing with byte source: should only pull enough to fill the emptiest queue", + "ReadableStream teeing with byte source: should not pull when original is already errored", + "ReadableStream teeing with byte source: stops pulling when original stream errors while branch 1 is reading", + "ReadableStream teeing with byte source: stops pulling when original stream errors while branch 2 is reading", + "ReadableStream teeing with byte source: stops pulling when original stream errors while both branches are reading", + "ReadableStream teeing with byte source: canceling both branches in sequence with delay", + "ReadableStream teeing with byte source: failing to cancel when canceling both branches in sequence with delay", + "ReadableStream teeing with byte source: read from branch1 and branch2, cancel branch1, cancel branch2", + "ReadableStream teeing with byte source: read from branch1 and branch2, cancel branch2, cancel branch1", + "ReadableStream teeing with byte source: read from branch1 and branch2, cancel branch2, enqueue to branch1", + "ReadableStream teeing with byte source: read from branch1 and branch2, cancel branch1, respond to branch2", + "ReadableStream teeing with byte source: pull with BYOB reader, then pull with default reader", + "ReadableStream teeing with byte source: pull with default reader, then pull with BYOB reader", + "ReadableStream teeing with byte source: read from branch2, then read from branch1", + "ReadableStream teeing with byte source: read from branch1 with default reader, then close while branch2 has pending BYOB read", + "ReadableStream teeing with byte source: read from branch2 with default reader, then close while branch1 has pending BYOB read", + "ReadableStream teeing with byte source: close when both branches have pending BYOB reads", + "ReadableStream teeing with byte source: respond() and close() while both branches are pulling" + ] + } + }, + "readable-streams/cross-realm-crash.window.js": { + "skip": "Browser-specific test" + }, + "readable-streams/default-reader.any.js": { + "fail": { + "expected": [ + "Second reader can read chunks after first reader was released with pending read requests" + ] + } + }, + "readable-streams/templated.any.js": { + "fail": { + "expected": [ + "ReadableStream (empty) reader: releasing the lock should reject all pending read requests" + ] + } + }, "transferable/deserialize-error.window.js": { "skip": "Browser-specific test" + }, + "transferable/transfer-with-messageport.window.js": { + "skip": "Browser-specific test" + }, + "writable-streams/aborting.any.js": { + "fail": { + "expected": ["WritableStreamDefaultController.signal"] + } } }