- From: wpt-stability-bot <web-platform-tests-notifications@w3.org>
- Date: Fri, 20 Jan 2017 20:31:21 GMT
- To: public-web-platform-tests-notifications@w3.org
# Firefox (nightly channel) #
Testing web-platform-tests at revision 54e8054f0b00c35a92468c281027855958dd664b
Using browser at version BuildID 20170118211214; SourceStamp a5253dce8b67c2248d7b92ef664a6dd6664e7609
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/flow-control.html">/streams/piping/flow-control.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Piping from an empty ReadableStream into a WritableStream that does not desire chunks, but then the readable stream becomes non-empty and the writable stream starts desiring chunks` | FAIL |
| `Piping to a WritableStream that does not consume the writes fast enough exerts backpressure on the ReadableStream` | FAIL |
| `Piping from a non-empty ReadableStream into a WritableStream that does not desire chunks` | FAIL |
| `Piping from a non-empty ReadableStream into a WritableStream that does not desire chunks, but then does` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/close-propagation-forward.serviceworker.https.html">/streams/piping/close-propagation-forward.serviceworker.https.html</a></summary>
| Subtest | Results |
|-----------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose omitted; fulfilled close promise` | FAIL |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose = true` | FAIL |
| `Service worker test setup` | PASS |
| `Closing must be propagated forward: starts closed; preventClose = 1 (truthy)` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose omitted; rejected close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose omitted; rejected close promise` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose omitted; rejected close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = Symbol() (truthy)` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = true, preventAbort = true` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose = true` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = true (truthy)` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = false (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = true, preventAbort = true, preventCancel = true` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose = true` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = -0 (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = undefined (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = [object Object] (truthy)` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = NaN (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose omitted; fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = a (truthy)` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose omitted; fulfilled close promise` | FAIL |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose omitted; rejected close promise` | FAIL |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose omitted; fulfilled close promise` | FAIL |
| `Closing must be propagated forward: shutdown must not occur until the final write completes` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = 0 (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = null (falsy); fulfilled close promise` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/general.serviceworker.https.html">/streams/readable-streams/general.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream can be constructed with no errors` | FAIL |
| `ReadableStream: enqueue should throw when the stream is readable but draining` | FAIL |
| `ReadableStream: should not call pull until the previous pull call's promise fulfills` | FAIL |
| `ReadableStream: should not call pull after start if the stream is now closed` | FAIL |
| `ReadableStream pull should be able to close a stream.` | FAIL |
| `ReadableStream start controller parameter should be extensible` | FAIL |
| `ReadableStream should be able to enqueue different objects.` | FAIL |
| `Service worker test setup` | PASS |
| `ReadableStream constructor should throw for non-function start arguments` | FAIL |
| `ReadableStream constructor can get initial garbage as cancel argument` | FAIL |
| `ReadableStream: should not call pull() in reaction to read()ing the last chunk, if draining` | FAIL |
| `ReadableStream constructor can get initial garbage as pull argument` | FAIL |
| `ReadableStream: should call underlying source methods as methods` | FAIL |
| `ReadableStream pull should be able to error a stream and throw.` | FAIL |
| `ReadableStream: should only call pull once on a non-empty stream read from before start fulfills` | FAIL |
| `ReadableStream: should only call pull once upon starting the stream` | FAIL |
| `ReadableStream: should call pull in reaction to read()ing the last chunk, if not draining` | FAIL |
| `ReadableStream start should be called with the proper parameters` | FAIL |
| `ReadableStream can't be constructed with an invalid type` | FAIL |
| `ReadableStream: should pull after start, and after every read` | FAIL |
| `ReadableStream strategies: the default strategy should give desiredSize of 1 to start, decreasing by 1 per enqueue` | FAIL |
| `ReadableStream instances should have the correct list of properties` | FAIL |
| `ReadableStream strategies: the default strategy should continue giving desiredSize of 1 if the chunks are read immediately` | FAIL |
| `ReadableStream pull should be able to error a stream.` | FAIL |
| `ReadableStream should be able to call start method within prototype chain of its source` | FAIL |
| `ReadableStream: should only call pull once on a non-empty stream read from after start fulfills` | FAIL |
| `ReadableStream: if pull rejects, it should error the stream` | FAIL |
| `ReadableStream integration test: adapting a random push source` | FAIL |
| `ReadableStream: enqueue should throw when the stream is closed` | FAIL |
| `ReadableStream can't be constructed with garbage` | FAIL |
| `ReadableStream integration test: adapting an async pull source` | FAIL |
| `ReadableStream: should call pull when trying to read from a started, empty stream` | FAIL |
| `ReadableStream integration test: adapting a sync pull source` | FAIL |
| `ReadableStream: should call pull after enqueueing from inside pull (with no read requests), if strategy allows` | FAIL |
| `ReadableStream start should be able to return a promise and reject it` | FAIL |
| `ReadableStream start should be able to return a promise` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/pipe-through.html">/streams/readable-streams/pipe-through.html</a></summary>
| Subtest | Results |
|-------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream.prototype.pipeThrough should throw when "this" has no pipeTo method` | FAIL |
| `ReadableStream.prototype.pipeThrough should work generically on its this and its arguments` | FAIL |
| `ReadableStream.prototype.pipeThrough should rethrow errors from accessing pipeTo, readable, or writable` | FAIL |
| `ReadableStream.prototype.pipeThrough should throw when its first argument is not convertible to an object` | FAIL |
| `ReadableStream.prototype.pipeThrough should work with missing readable, writable, or options` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/tee.serviceworker.https.html">/streams/readable-streams/tee.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream teeing: values should be equal across each branch` | FAIL |
| `ReadableStream teeing: canceling branch1 should not impact branch2` | FAIL |
| `ReadableStream teeing: closing the original should immediately close the branches` | FAIL |
| `ReadableStream teeing: rs.tee() returns an array of two ReadableStreams` | FAIL |
| `ReadableStream teeing: errors in the source should propagate to both branches` | FAIL |
| `ReadableStream teeing: canceling branch2 should not impact branch2` | FAIL |
| `ReadableStream teeing: failing to cancel the original stream should cause cancel() to reject on branches` | FAIL |
| `Service worker test setup` | PASS |
| `ReadableStream teeing: canceling both branches should aggregate the cancel reasons into an array` | FAIL |
| `ReadableStream teeing: should be able to read one branch to the end without affecting the other` | FAIL |
| `ReadableStream teeing: erroring the original should immediately error the branches` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/byte-length-queuing-strategy.html">/streams/writable-streams/byte-length-queuing-strategy.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Closing a writable stream with in-flight writes below the high water mark delays the close call properly` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/bad-strategies.serviceworker.https.html">/streams/writable-streams/bad-strategies.serviceworker.https.html</a></summary>
| Subtest | Results |
|-----------------------------------------------------------|---------|
| | OK |
| `reject any non-function value for strategy.size` | FAIL |
| `Writable stream: invalid strategy.size return value` | FAIL |
| `Writable stream: invalid strategy.highWaterMark` | FAIL |
| `Writable stream: throwing strategy.highWaterMark getter` | FAIL |
| `Writable stream: throwing strategy.size method` | FAIL |
| `Service worker test setup` | PASS |
| `Writable stream: throwing strategy.size getter` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-byte-streams/general.serviceworker.https.html">/streams/readable-byte-streams/general.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream with byte source: Multiple read(view), close() and respond()` | FAIL |
| `ReadableStream with byte source: Throwing in pull function must error the stream` | FAIL |
| `ReadableStream with byte source: Automatic pull() after start()` | FAIL |
| `ReadableStream with byte source: Multiple enqueue(), getReader(), then read(view)` | FAIL |
| `ReadableStream with byte source: read(view), then respond() and close() in pull()` | FAIL |
| `ReadableStream with byte source: Test that closing a stream does not release a reader automatically` | FAIL |
| `ReadableStream with byte source: A stream must be errored if close()-d before fulfilling read(view) with Uint16Array` | FAIL |
| `ReadableStream with byte source: read(view), then respond() with a transferred ArrayBuffer` | FAIL |
| `ReadableStream with byte source: enqueue() with Uint16Array, getReader(), then read()` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) with a smaller views` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view)` | FAIL |
| `Service worker test setup` | PASS |
| `ReadableStream with byte source: Test that erroring a stream does not release a reader automatically` | FAIL |
| `ReadableStream with byte source: Respond to pull() by enqueue()` | FAIL |
| `ReadableStream with byte source: read() twice, then enqueue() twice` | FAIL |
| `ReadableStreamBYOBReader constructor requires a ReadableStream with type "bytes"` | FAIL |
| `ReadableStream with byte source: releaseLock() on ReadableStreamReader with pending read() must throw` | FAIL |
| `ReadableStreamBYOBReader constructor requires a ReadableStream argument` | FAIL |
| `ReadableStream with byte source: Mix of auto allocate and BYOB` | FAIL |
| `ReadableStream with byte source: read(view) with Uint16Array on close()-d stream with 1 byte enqueue()-d must fail` | FAIL |
| `ReadableStream with byte source: read(view), then respond() with too big value` | FAIL |
| `ReadableStream with byte source: read(view) with Uint32Array, then fill it by multiple respond() calls` | FAIL |
| `ReadableStream with byte source: autoAllocateChunkSize` | FAIL |
| `ReadableStream with byte source: cancel() with partially filled pending pull() request` | FAIL |
| `ReadableStream with byte source: Construct and expect start and pull being called` | FAIL |
| `ReadableStream with byte source: read(view), then respond()` | FAIL |
| `ReadableStream with byte source: read(view), then error()` | FAIL |
| `ReadableStream with byte source: read(view), but pull() function is not callable` | FAIL |
| `ReadableStream with byte source: Automatic pull() after start() and read(view)` | FAIL |
| `ReadableStreamBYOBReader can be constructed directly` | FAIL |
| `ReadableStream with byte source: Throwing in pull in response to read() must be ignored if the stream is errored in it` | FAIL |
| `ReadableStream with byte source: read(view) with zero-length view must fail` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then cancel() (mode = not BYOB)` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then cancel() (mode = BYOB)` | FAIL |
| `ReadableStream with byte source can be constructed with no errors` | FAIL |
| `ReadableStream with byte source: Test that closing a stream does not release a BYOB reader automatically` | FAIL |
| `ReadableStream with byte source: read(), then error()` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read()` | FAIL |
| `ReadableStream with byte source: read(), but pull() function is not callable` | FAIL |
| `getReader({mode: "byob"}) throws on non-bytes streams` | FAIL |
| `ReadableStream with byte source: respond(3) to read(view) with 2 element Uint16Array enqueues the 1 byte remainder` | FAIL |
| `ReadableStream with byte source: enqueue() 1 byte, getReader(), then read(view) with Uint16Array` | FAIL |
| `ReadableStream with byte source: enqueue() 3 byte, getReader(), then read(view) with 2-element Uint16Array` | FAIL |
| `ReadableStream with byte source: Automatic pull() after start() and read()` | FAIL |
| `ReadableStream with byte source: Throw if close()-ed more than once` | FAIL |
| `ReadableStream with byte source: getReader(), read(view), then cancel()` | FAIL |
| `ReadableStream with byte source: Throwing in pull in response to read(view) must be ignored if the stream is errored in it` | FAIL |
| `ReadableStream with byte source: getReader() with mode set to byob, then releaseLock()` | FAIL |
| `ReadableStream with byte source: getReader(), enqueue(), close(), then read()` | FAIL |
| `ReadableStream with byte source: Throwing in pull in response to read(view) function must error the stream` | FAIL |
| `ReadableStream with byte source: getReader(), then releaseLock()` | FAIL |
| `ReadableStreamBYOBReader constructor requires an unlocked ReadableStream` | FAIL |
| `ReadableStream with byte source: Even read(view) with passing ArrayBufferView like object as view must fail` | FAIL |
| `ReadableStream with byte source: enqueue(), close(), getReader(), then read()` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) with a bigger view` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) where view.buffer is not fully covered by view` | FAIL |
| `ReadableStream with byte source: read() on an errored stream` | FAIL |
| `ReadableStream with byte source: Push source that doesn't understand pull signal` | FAIL |
| `ReadableStream with byte source: Throw on enqueue() after close()` | FAIL |
| `ReadableStream with byte source: read(view) with passing an empty object as view must fail` | FAIL |
| `ReadableStream with byte source: Multiple read(view), big enqueue()` | FAIL |
| `ReadableStream with byte source: Construct with highWaterMark of 0` | FAIL |
| `ReadableStream with byte source: Respond to pull() by enqueue() asynchronously` | FAIL |
| `ReadableStream with byte source: Multiple read(view) and multiple enqueue()` | FAIL |
| `ReadableStream with byte source: Test that erroring a stream does not release a BYOB reader automatically` | FAIL |
| `ReadableStream with byte source: read(view) with passing undefined as view must fail` | FAIL |
| `ReadableStream with byte source: read(view) on an errored stream` | FAIL |
| `ReadableStream with byte source: enqueue(), read(view) partially, then read()` | FAIL |
| `ReadableStream with byte source: No automatic pull call if start doesn't finish` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/byte-length-queuing-strategy.html">/streams/byte-length-queuing-strategy.html</a></summary>
| Subtest | Results |
|--------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Can construct a ByteLengthQueuingStrategy with a valid high water mark` | FAIL |
| `ByteLengthQueuingStrategy constructor behaves as expected with strange arguments` | FAIL |
| `ByteLengthQueuingStrategy instances have the correct properties` | FAIL |
| `Can construct a ByteLengthQueuingStrategy with any value as its high water mark` | FAIL |
| `ByteLengthQueuingStrategy size behaves as expected with strange arguments` | FAIL |
| `ByteLengthQueuingStrategy.prototype.size should work generically on its this and its arguments` | FAIL |
| `ByteLengthQueuingStrategy's highWaterMark property can be set to anything` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/count-queuing-strategy-integration.html">/streams/readable-streams/count-queuing-strategy-integration.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------|---------|
| | OK |
| `Can construct a readable stream with a valid CountQueuingStrategy` | FAIL |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 1)` | FAIL |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 0)` | FAIL |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 4)` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/pipe-through.html">/streams/piping/pipe-through.html</a></summary>
| Subtest | Results |
|--------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `pipeThrough can handle calling a pipeTo that returns a non-promise thenable object` | FAIL |
| `pipeThrough generically calls pipeTo with the appropriate args` | FAIL |
| `Piping through a duck-typed pass-through transform stream should work` | FAIL |
| `Piping through a transform errored on the writable end does not cause an unhandled promise rejection` | FAIL |
| `pipeThrough can handle calling a pipeTo that returns a non-promise object` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/brand-checks.html">/streams/readable-streams/brand-checks.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStreamController.prototype.close enforces a brand check` | FAIL |
| `ReadableStreamReader.prototype.closed enforces a brand check` | FAIL |
| `ReadableStreamReader.prototype.read enforces a brand check` | FAIL |
| `ReadableStreamReader.prototype.cancel enforces a brand check` | FAIL |
| `Can get the ReadableStreamController constructor indirectly` | FAIL |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | FAIL |
| `ReadableStream.prototype.cancel enforces a brand check` | FAIL |
| `ReadableStreamReader.prototype.releaseLock enforces a brand check` | FAIL |
| `ReadableStream.prototype.tee enforces a brand check` | FAIL |
| `ReadableStream.prototype.getReader enforces a brand check` | FAIL |
| `ReadableStreamReader enforces a brand check on its argument` | PASS |
| `ReadableStreamController enforces a brand check on its argument` | PASS |
| `Can get the ReadableStreamReader constructor indirectly` | FAIL |
| `ReadableStreamController.prototype.error enforces a brand check` | FAIL |
| `ReadableStreamController.prototype.enqueue enforces a brand check` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/transform-streams.serviceworker.https.html">/streams/piping/transform-streams.serviceworker.https.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Service worker test setup` | PASS |
| `Piping through an identity transform stream should close the destination when the source closes` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/bad-underlying-sinks.html">/streams/writable-streams/bad-underlying-sinks.html</a></summary>
| Subtest | Results |
|-----------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `write: returning a promise that becomes rejected after the writer write() should cause writer write() and ready to reject` | FAIL |
| `abort: non-function abort method with .apply` | FAIL |
| `write: throwing method should cause write() and closed to reject` | FAIL |
| `close: returning a rejected promise should cause writer close() and ready to reject` | FAIL |
| `close: throwing method should cause writer close() and ready to reject` | FAIL |
| `write: returning a rejected promise (second write) should cause writer write() and ready to reject` | FAIL |
| `abort: throwing getter should cause abort() and closed to reject` | FAIL |
| `close: throwing getter should cause writer close() to reject` | FAIL |
| `write: throwing getter should cause write() and closed to reject` | FAIL |
| `start: errors in start cause WritableStream constructor to throw` | FAIL |
| `abort: throwing method should cause abort() and closed to reject` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/multiple-propagation.serviceworker.https.html">/streams/piping/multiple-propagation.serviceworker.https.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------|---------|
| | OK |
| `Piping from an errored readable stream to a closed writable stream` | FAIL |
| `Piping from a closed readable stream to a closed writable stream` | FAIL |
| `Piping from a closed readable stream to an errored writable stream` | FAIL |
| `Piping from an errored readable stream to an errored writable stream` | FAIL |
| `Service worker test setup` | PASS |
| `Piping from an errored readable stream to an errored writable stream; preventAbort = true` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/general.serviceworker.https.html">/streams/writable-streams/general.serviceworker.https.html</a></summary>
| Subtest | Results |
|-------------------------------------------------------------------|---------|
| | OK |
| `closed and ready on a released writer` | FAIL |
| `ws.getWriter() on an errored WritableStream` | FAIL |
| `ws.getWriter() on an aborted WritableStream` | FAIL |
| `WritableStream's strategy.size should not be called as a method` | FAIL |
| `ws.getWriter() on a closing WritableStream` | FAIL |
| `methods should not not have .apply() or .call() called` | FAIL |
| `Service worker test setup` | PASS |
| `WritableStream should call underlying sink methods as methods` | FAIL |
| `ws.getWriter() on a closed WritableStream` | FAIL |
| `desiredSize on a writer for a closed stream` | FAIL |
| `desiredSize on a released writer` | FAIL |
| `redundant releaseLock() is no-op` | FAIL |
| `desiredSize initial value` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/close-propagation-backward.html">/streams/piping/close-propagation-backward.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Closing must be propagated backward: starts closed; preventCancel = undefined (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = -0 (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel omitted; rejected cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = 1 (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = true, preventAbort = true, preventClose = true` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = null (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = [object Object] (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = a (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = Symbol() (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = 0 (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = NaN (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = true (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = true, preventAbort = true` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = false (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = (falsy); fulfilled cancel promise` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/error-propagation-forward.html">/streams/piping/error-propagation-forward.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = true` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = true, preventCancel = true, preventClose = true` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = true` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = a (truthy)` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = -0 (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = [object Object] (truthy)` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = true` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = false (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = null (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = true, preventCancel = true` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: shutdown must not occur until the final write completes` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = undefined (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = 1 (truthy)` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = true` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = Symbol() (truthy)` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = true (truthy)` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = NaN (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = 0 (falsy); fulfilled abort promise` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/constructor.html">/streams/writable-streams/constructor.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `controller argument should be passed to write method` | FAIL |
| `WritableStream should be constructible with no arguments` | FAIL |
| `WritableStream instances should have standard methods and properties` | FAIL |
| `WritableStreamDefaultWriter constructor should throw when stream argument is locked` | FAIL |
| `controller argument should be passed to start method` | FAIL |
| `WritableStreamDefaultWriter should throw unless passed a WritableStream` | FAIL |
| `WritableStream should be writable and ready should fulfill immediately if the strategy does not apply backpressure` | FAIL |
| `WritableStreamDefaultController constructor should throw when passed an initialised WritableStream` | FAIL |
| `WritableStreamDefaultController constructor should throw unless passed a WritableStream` | FAIL |
| `highWaterMark should be reflected to desiredSize` | FAIL |
| `controller argument should be passed to close method` | FAIL |
| `private constructors should not be exported` | PASS |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/count-queuing-strategy.html">/streams/count-queuing-strategy.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------|---------|
| | OK |
| `Can construct a CountQueuingStrategy with a valid high water mark` | FAIL |
| `CountQueuingStrategy constructor behaves as expected with strange arguments` | FAIL |
| `CountQueuingStrategy.prototype.size should work generically on its this and its arguments` | FAIL |
| `CountQueuingStrategy size behaves as expected with strange arguments` | FAIL |
| `Can construct a CountQueuingStrategy with any value as its high water mark` | FAIL |
| `CountQueuingStrategy instances have the correct properties` | FAIL |
| `CountQueuingStrategy's highWaterMark property can be set to anything` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/count-queuing-strategy-integration.serviceworker.https.html">/streams/readable-streams/count-queuing-strategy-integration.serviceworker.https.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------|---------|
| | OK |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 4)` | FAIL |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 1)` | FAIL |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 0)` | FAIL |
| `Service worker test setup` | PASS |
| `Can construct a readable stream with a valid CountQueuingStrategy` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/aborting.serviceworker.https.html">/streams/writable-streams/aborting.serviceworker.https.html</a></summary>
| Subtest | Results |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `underlying abort() should not be called until underlying write() completes` | FAIL |
| `.closed should not resolve before fulfilled write()` | FAIL |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects` | FAIL |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)` | FAIL |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects` | FAIL |
| `close() should use error from underlying write() on abort` | FAIL |
| `underlying abort() should not be called if underlying close() has started` | FAIL |
| `Aborting a WritableStream passes through the given reason` | FAIL |
| `underlying abort() should be called while closing if underlying close() has not started yet` | FAIL |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one` | FAIL |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error` | FAIL |
| `writer.ready should reject on controller error without waiting for underlying write` | FAIL |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError` | FAIL |
| `if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason` | FAIL |
| `Aborting a WritableStream prevents further writes after any that are in progress` | FAIL |
| `writes should be satisfied in order when aborting` | FAIL |
| `.closed should not resolve before rejected write(); write() error should overwrite abort() error` | FAIL |
| `Aborting a WritableStream immediately prevents future writes` | FAIL |
| `Aborting a WritableStream should cause the writer's unsettled ready promise to reject` | FAIL |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value` | FAIL |
| `writes should be satisfied in order after rejected write when aborting` | FAIL |
| `releaseLock() while aborting should reject the original closed promise` | FAIL |
| `releaseLock() during delayed async abort() should create a new rejected closed promise` | FAIL |
| `returning a thenable from abort() should work` | FAIL |
| `abort() on a released writer rejects` | FAIL |
| `Closing a WritableStream and aborting it while it closes causes the stream to error` | FAIL |
| `Aborting a WritableStream after it is closed is a no-op` | FAIL |
| `writer close() promise should resolve before abort() promise` | FAIL |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects` | FAIL |
| `Closing but then immediately aborting a WritableStream causes the stream to error` | FAIL |
| `Service worker test setup` | PASS |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/flow-control.serviceworker.https.html">/streams/piping/flow-control.serviceworker.https.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Piping to a WritableStream that does not consume the writes fast enough exerts backpressure on the ReadableStream` | FAIL |
| `Piping from a non-empty ReadableStream into a WritableStream that does not desire chunks, but then does` | FAIL |
| `Service worker test setup` | PASS |
| `Piping from an empty ReadableStream into a WritableStream that does not desire chunks, but then the readable stream becomes non-empty and the writable stream starts desiring chunks` | FAIL |
| `Piping from a non-empty ReadableStream into a WritableStream that does not desire chunks` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/brand-checks.html">/streams/writable-streams/brand-checks.html</a></summary>
| Subtest | Results |
|---------|---------|
| | ERROR |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/start.serviceworker.https.html">/streams/writable-streams/start.serviceworker.https.html</a></summary>
| Subtest | Results |
|-------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `underlying sink's write or close should not be called if start throws` | FAIL |
| `underlying sink's write or close should not be invoked if the promise returned by start is rejected` | FAIL |
| `returning a thenable from start() should work` | FAIL |
| `underlying sink's write should not be called until start finishes` | FAIL |
| `underlying sink's close should not be called until start finishes` | FAIL |
| `Service worker test setup` | PASS |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/bad-strategies.serviceworker.https.html">/streams/readable-streams/bad-strategies.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------|---------|
| | OK |
| `Readable stream: throwing strategy.highWaterMark getter` | FAIL |
| `Readable stream: strategy.size errors the stream and then throws` | FAIL |
| `Readable stream: throwing strategy.size method` | FAIL |
| `Readable stream: throwing strategy.size getter` | FAIL |
| `Service worker test setup` | PASS |
| `Readable stream: invalid strategy.highWaterMark` | FAIL |
| `Readable stream: invalid strategy.size return value` | FAIL |
| `Readable stream: strategy.size errors the stream and then returns Infinity` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/count-queuing-strategy.html">/streams/writable-streams/count-queuing-strategy.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------|---------|
| | OK |
| `Correctly governs the value of a WritableStream's state property (HWM = 0)` | FAIL |
| `Can construct a writable stream with a valid CountQueuingStrategy` | FAIL |
| `Correctly governs the value of a WritableStream's state property (HWM = 4)` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/garbage-collection.html">/streams/readable-streams/garbage-collection.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream closed promise should fulfill even if the stream and reader JS references are lost` | FAIL |
| `Garbage-collecting a ReadableStreamReader should not unlock its stream` | FAIL |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost` | FAIL |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/general.html">/streams/piping/general.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------------|---------|
| | OK |
| `pipeTo must fail if the ReadableStream is locked, and not lock the WritableStream` | FAIL |
| `Piping from a ReadableStream for which a chunk becomes asynchronously readable after the pipeTo` | FAIL |
| `an undefined rejection from write should cause pipeTo() to reject when preventCancel is true` | FAIL |
| `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is true` | FAIL |
| `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is false` | FAIL |
| `Piping must lock both the ReadableStream and WritableStream` | FAIL |
| `pipeTo must check the brand of its ReadableStream this value` | FAIL |
| `pipeTo must fail if the WritableStream is locked, and not lock the ReadableStream` | FAIL |
| `Piping finishing must unlock both the ReadableStream and WritableStream` | FAIL |
| `pipeTo must check the brand of its WritableStream argument` | FAIL |
| `an undefined rejection from write should cause pipeTo() to reject when preventCancel is false` | FAIL |
| `Piping from a ReadableStream from which lots of chunks are synchronously readable` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/garbage-collection.serviceworker.https.html">/streams/readable-streams/garbage-collection.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Garbage-collecting a ReadableStreamReader should not unlock its stream` | FAIL |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost` | FAIL |
| `Service worker test setup` | PASS |
| `ReadableStream closed promise should fulfill even if the stream and reader JS references are lost` | FAIL |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/close-propagation-forward.html">/streams/piping/close-propagation-forward.html</a></summary>
| Subtest | Results |
|-----------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose omitted; fulfilled close promise` | FAIL |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose = true` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = 1 (truthy)` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose omitted; rejected close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose omitted; rejected close promise` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose omitted; rejected close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = Symbol() (truthy)` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = true, preventAbort = true` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose = true` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = true (truthy)` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = false (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = true, preventAbort = true, preventCancel = true` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose = true` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = -0 (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = undefined (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = [object Object] (truthy)` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = NaN (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose omitted; fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = a (truthy)` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose omitted; fulfilled close promise` | FAIL |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose omitted; rejected close promise` | FAIL |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose omitted; fulfilled close promise` | FAIL |
| `Closing must be propagated forward: shutdown must not occur until the final write completes` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = 0 (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = (falsy); fulfilled close promise` | FAIL |
| `Closing must be propagated forward: starts closed; preventClose = null (falsy); fulfilled close promise` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/transform-streams.html">/streams/piping/transform-streams.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Piping through an identity transform stream should close the destination when the source closes` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/brand-checks.serviceworker.https.html">/streams/writable-streams/brand-checks.serviceworker.https.html</a></summary>
| Subtest | Results |
|-----------------------------|---------|
| | OK |
| `Service worker test setup` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/cancel.html">/streams/readable-streams/cancel.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream cancellation: integration test on an infinite stream derived from a random push source` | FAIL |
| `ReadableStream cancellation: cancel(reason) should pass through the given reason to the underlying source` | FAIL |
| `ReadableStream cancellation: cancelling before start finishes should prevent pull() from being called` | FAIL |
| `ReadableStream cancellation: returning a value from the underlying source's cancel should not affect the fulfillment value of the promise returned by the stream's cancel` | FAIL |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should reject when that one does` | FAIL |
| `ReadableStream cancellation: cancel() on a locked stream should fail and not call the underlying source cancel` | FAIL |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should fulfill when that one does (2)` | FAIL |
| `ReadableStream cancellation: should fulfill promise when cancel callback went fine` | FAIL |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should fulfill when that one does (1)` | FAIL |
| `ReadableStream cancellation: should reject promise when cancel callback raises an exception` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/general.html">/streams/writable-streams/general.html</a></summary>
| Subtest | Results |
|-------------------------------------------------------------------|---------|
| | OK |
| `closed and ready on a released writer` | FAIL |
| `ws.getWriter() on an errored WritableStream` | FAIL |
| `ws.getWriter() on an aborted WritableStream` | FAIL |
| `WritableStream's strategy.size should not be called as a method` | FAIL |
| `ws.getWriter() on a closing WritableStream` | FAIL |
| `methods should not not have .apply() or .call() called` | FAIL |
| `WritableStream should call underlying sink methods as methods` | FAIL |
| `ws.getWriter() on a closed WritableStream` | FAIL |
| `desiredSize on a writer for a closed stream` | FAIL |
| `desiredSize on a released writer` | FAIL |
| `redundant releaseLock() is no-op` | FAIL |
| `desiredSize initial value` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/start.html">/streams/writable-streams/start.html</a></summary>
| Subtest | Results |
|-------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `underlying sink's write or close should not be called if start throws` | FAIL |
| `underlying sink's write or close should not be invoked if the promise returned by start is rejected` | FAIL |
| `returning a thenable from start() should work` | FAIL |
| `underlying sink's write should not be called until start finishes` | FAIL |
| `underlying sink's close should not be called until start finishes` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/cancel.serviceworker.https.html">/streams/readable-streams/cancel.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream cancellation: integration test on an infinite stream derived from a random push source` | FAIL |
| `ReadableStream cancellation: cancel(reason) should pass through the given reason to the underlying source` | FAIL |
| `ReadableStream cancellation: cancelling before start finishes should prevent pull() from being called` | FAIL |
| `ReadableStream cancellation: returning a value from the underlying source's cancel should not affect the fulfillment value of the promise returned by the stream's cancel` | FAIL |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should reject when that one does` | FAIL |
| `ReadableStream cancellation: cancel() on a locked stream should fail and not call the underlying source cancel` | FAIL |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should fulfill when that one does (2)` | FAIL |
| `Service worker test setup` | PASS |
| `ReadableStream cancellation: should fulfill promise when cancel callback went fine` | FAIL |
| `ReadableStream cancellation: if the underlying source's cancel method returns a promise, the promise returned by the stream's cancel should fulfill when that one does (1)` | FAIL |
| `ReadableStream cancellation: should reject promise when cancel callback raises an exception` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/close.html">/streams/writable-streams/close.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `releaseLock() should not change the result of async close()` | FAIL |
| `when sink calls error asynchronously while closing, the stream should become errored` | FAIL |
| `the promise returned by async abort during close should resolve` | FAIL |
| `releaseLock() should not change the result of sync close()` | FAIL |
| `when close is called on a WritableStream in writable state, ready should return a fulfilled promise` | FAIL |
| `returning a thenable from close() should work` | FAIL |
| `when sink calls error synchronously while closing, the stream should become errored` | FAIL |
| `close() should set state to CLOSED even if writer has detached` | FAIL |
| `when close is called on a WritableStream in waiting state, ready promise should be fulfilled` | FAIL |
| `fulfillment value of ws.close() call must be undefined even if the underlying sink returns a non-undefined value` | FAIL |
| `when close is called on a WritableStream in waiting state, ready should be fulfilled immediately even if close takes a long time` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/readable-stream-reader.serviceworker.https.html">/streams/readable-streams/readable-stream-reader.serviceworker.https.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamReader closed promise` | FAIL |
| `Service worker test setup` | PASS |
| `Reading twice on a closed stream` | FAIL |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via direct construction)` | FAIL |
| `Multiple readers can access the stream in sequence` | FAIL |
| `cancel() on a reader does not release the reader` | FAIL |
| `Getting a second reader after erroring the stream and releasing the reader should succeed` | FAIL |
| `ReadableStreamReader constructor should get a ReadableStream object as argument` | PASS |
| `ReadableStreamReader: if start rejects with no parameter, it should error the stream with an undefined error` | FAIL |
| `ReadableStreamReader closed promise should be rejected with undefined if that is the error` | FAIL |
| `closed should be rejected after reader releases its lock (multiple stream locks)` | FAIL |
| `Cannot use an already-released reader to unlock a stream again` | FAIL |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)` | FAIL |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via getReader)` | FAIL |
| `Constructing a ReadableStreamReader directly should be OK if the stream is errored` | FAIL |
| `Reading twice on a stream that gets closed` | FAIL |
| `Can get the ReadableStreamReader constructor indirectly` | FAIL |
| `ReadableStreamReader instances should have the correct list of properties` | FAIL |
| `Constructing a ReadableStreamReader directly should be OK if the stream is closed` | FAIL |
| `Reading from a reader for an empty stream will wait until a chunk is available` | FAIL |
| `Reading twice on a stream that gets errored` | FAIL |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamReader closed promise` | FAIL |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via getReader)` | FAIL |
| `cancel() on a released reader is a no-op and does not pass through` | FAIL |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via direct construction)` | FAIL |
| `ReadableStreamReader closed should always return the same promise object` | FAIL |
| `Reading twice on an errored stream` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/error-propagation-backward.serviceworker.https.html">/streams/piping/error-propagation-backward.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = true, preventAbort = true, preventClose = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = 0 (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = -0 (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = false; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = 1 (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = false; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = a (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel omitted; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = undefined (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = null (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = false; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = true (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = false (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: starts errored; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = NaN (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping due to last write; source is closed; preventCancel omitted (but cancel is never called)` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write, preventCancel = true; preventAbort = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel omitted; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping due to last write; source is closed; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = false; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel omitted; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = Symbol() (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; preventCancel omitted; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = [object Object] (truthy)` | FAIL |
| `Errors must be propagated backward: erroring via the controller errors once pending write completes` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Service worker test setup` | PASS |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/bad-strategies.html">/streams/readable-streams/bad-strategies.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------|---------|
| | OK |
| `Readable stream: throwing strategy.highWaterMark getter` | FAIL |
| `Readable stream: invalid strategy.highWaterMark` | FAIL |
| `Readable stream: throwing strategy.size method` | FAIL |
| `Readable stream: throwing strategy.size getter` | FAIL |
| `Readable stream: strategy.size errors the stream and then throws` | FAIL |
| `Readable stream: invalid strategy.size return value` | FAIL |
| `Readable stream: strategy.size errors the stream and then returns Infinity` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/brand-checks.serviceworker.https.html">/streams/readable-streams/brand-checks.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStreamController.prototype.close enforces a brand check` | FAIL |
| `ReadableStreamReader.prototype.closed enforces a brand check` | FAIL |
| `ReadableStreamReader.prototype.read enforces a brand check` | FAIL |
| `ReadableStreamReader.prototype.cancel enforces a brand check` | FAIL |
| `Can get the ReadableStreamController constructor indirectly` | FAIL |
| `ReadableStreamController.prototype.enqueue enforces a brand check` | FAIL |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | FAIL |
| `ReadableStream.prototype.cancel enforces a brand check` | FAIL |
| `ReadableStreamReader.prototype.releaseLock enforces a brand check` | FAIL |
| `ReadableStream.prototype.tee enforces a brand check` | FAIL |
| `ReadableStream.prototype.getReader enforces a brand check` | FAIL |
| `Service worker test setup` | PASS |
| `ReadableStreamController enforces a brand check on its argument` | PASS |
| `Can get the ReadableStreamReader constructor indirectly` | FAIL |
| `ReadableStreamController.prototype.error enforces a brand check` | FAIL |
| `ReadableStreamReader enforces a brand check on its argument` | PASS |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/bad-underlying-sinks.serviceworker.https.html">/streams/writable-streams/bad-underlying-sinks.serviceworker.https.html</a></summary>
| Subtest | Results |
|-----------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `write: returning a promise that becomes rejected after the writer write() should cause writer write() and ready to reject` | FAIL |
| `abort: non-function abort method with .apply` | FAIL |
| `write: throwing method should cause write() and closed to reject` | FAIL |
| `close: returning a rejected promise should cause writer close() and ready to reject` | FAIL |
| `close: throwing method should cause writer close() and ready to reject` | FAIL |
| `write: returning a rejected promise (second write) should cause writer write() and ready to reject` | FAIL |
| `Service worker test setup` | PASS |
| `abort: throwing getter should cause abort() and closed to reject` | FAIL |
| `close: throwing getter should cause writer close() to reject` | FAIL |
| `write: throwing getter should cause write() and closed to reject` | FAIL |
| `start: errors in start cause WritableStream constructor to throw` | FAIL |
| `abort: throwing method should cause abort() and closed to reject` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/close-propagation-backward.serviceworker.https.html">/streams/piping/close-propagation-backward.serviceworker.https.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Closing must be propagated backward: starts closed; preventCancel = undefined (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = -0 (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = 1 (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = true, preventAbort = true, preventClose = true` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = null (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = [object Object] (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel omitted; rejected cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Service worker test setup` | PASS |
| `Closing must be propagated backward: starts closed; preventCancel = a (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = Symbol() (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = 0 (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = NaN (falsy); fulfilled cancel promise` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = true (truthy)` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = true, preventAbort = true` | FAIL |
| `Closing must be propagated backward: starts closed; preventCancel = false (falsy); fulfilled cancel promise` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/error-propagation-forward.serviceworker.https.html">/streams/piping/error-propagation-forward.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = true` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = true, preventCancel = true, preventClose = true` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = false; rejected abort promise` | FAIL |
| `Service worker test setup` | PASS |
| `Errors must be propagated forward: starts errored; preventAbort = a (truthy)` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = -0 (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = [object Object] (truthy)` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = true` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = false (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = null (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = true, preventCancel = true` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: shutdown must not occur until the final write completes` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = false; fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = false; rejected abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = undefined (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = 1 (truthy)` | FAIL |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = true` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = Symbol() (truthy)` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = true (truthy)` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = NaN (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: starts errored; preventAbort = 0 (falsy); fulfilled abort promise` | FAIL |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = true` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/constructor.serviceworker.https.html">/streams/writable-streams/constructor.serviceworker.https.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `controller argument should be passed to write method` | FAIL |
| `WritableStream should be constructible with no arguments` | FAIL |
| `WritableStream instances should have standard methods and properties` | FAIL |
| `WritableStreamDefaultWriter constructor should throw when stream argument is locked` | FAIL |
| `controller argument should be passed to start method` | FAIL |
| `WritableStreamDefaultWriter should throw unless passed a WritableStream` | FAIL |
| `Service worker test setup` | PASS |
| `WritableStream should be writable and ready should fulfill immediately if the strategy does not apply backpressure` | FAIL |
| `WritableStreamDefaultController constructor should throw when passed an initialised WritableStream` | FAIL |
| `WritableStreamDefaultController constructor should throw unless passed a WritableStream` | FAIL |
| `highWaterMark should be reflected to desiredSize` | FAIL |
| `controller argument should be passed to close method` | FAIL |
| `private constructors should not be exported` | PASS |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/count-queuing-strategy.serviceworker.https.html">/streams/count-queuing-strategy.serviceworker.https.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------|---------|
| | OK |
| `Can construct a CountQueuingStrategy with a valid high water mark` | FAIL |
| `CountQueuingStrategy constructor behaves as expected with strange arguments` | FAIL |
| `CountQueuingStrategy.prototype.size should work generically on its this and its arguments` | FAIL |
| `CountQueuingStrategy size behaves as expected with strange arguments` | FAIL |
| `Can construct a CountQueuingStrategy with any value as its high water mark` | FAIL |
| `CountQueuingStrategy instances have the correct properties` | FAIL |
| `Service worker test setup` | PASS |
| `CountQueuingStrategy's highWaterMark property can be set to anything` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/pipe-through.serviceworker.https.html">/streams/piping/pipe-through.serviceworker.https.html</a></summary>
| Subtest | Results |
|--------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `pipeThrough can handle calling a pipeTo that returns a non-promise thenable object` | FAIL |
| `pipeThrough generically calls pipeTo with the appropriate args` | FAIL |
| `Piping through a duck-typed pass-through transform stream should work` | FAIL |
| `Service worker test setup` | PASS |
| `Piping through a transform errored on the writable end does not cause an unhandled promise rejection` | FAIL |
| `pipeThrough can handle calling a pipeTo that returns a non-promise object` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/bad-strategies.html">/streams/writable-streams/bad-strategies.html</a></summary>
| Subtest | Results |
|-----------------------------------------------------------|---------|
| | OK |
| `reject any non-function value for strategy.size` | FAIL |
| `Writable stream: invalid strategy.size return value` | FAIL |
| `Writable stream: invalid strategy.highWaterMark` | FAIL |
| `Writable stream: throwing strategy.highWaterMark getter` | FAIL |
| `Writable stream: throwing strategy.size method` | FAIL |
| `Writable stream: throwing strategy.size getter` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/count-queuing-strategy.serviceworker.https.html">/streams/writable-streams/count-queuing-strategy.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------|---------|
| | OK |
| `Correctly governs the value of a WritableStream's state property (HWM = 0)` | FAIL |
| `Can construct a writable stream with a valid CountQueuingStrategy` | FAIL |
| `Service worker test setup` | PASS |
| `Correctly governs the value of a WritableStream's state property (HWM = 4)` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/write.html">/streams/writable-streams/write.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `fulfillment value of ws.write() call should be undefined even if the underlying sink returns a non-undefined value` | FAIL |
| `WritableStream should complete asynchronous writes before close resolves` | FAIL |
| `returning a thenable from write() should work` | FAIL |
| `WritableStream should complete synchronous writes before close resolves` | FAIL |
| `when sink's write throws an error, the stream should become errored and the promise should reject` | FAIL |
| `WritableStream should transition to waiting until write is acknowledged` | FAIL |
| `WritableStreamDefaultWriter should work when manually constructed` | FAIL |
| `a large queue of writes should be processed completely` | FAIL |
| `when write returns a rejected promise, queued writes and close should be cleared` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/byte-length-queuing-strategy.serviceworker.https.html">/streams/byte-length-queuing-strategy.serviceworker.https.html</a></summary>
| Subtest | Results |
|--------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Can construct a ByteLengthQueuingStrategy with a valid high water mark` | FAIL |
| `ByteLengthQueuingStrategy constructor behaves as expected with strange arguments` | FAIL |
| `ByteLengthQueuingStrategy instances have the correct properties` | FAIL |
| `Can construct a ByteLengthQueuingStrategy with any value as its high water mark` | FAIL |
| `ByteLengthQueuingStrategy's highWaterMark property can be set to anything` | FAIL |
| `ByteLengthQueuingStrategy size behaves as expected with strange arguments` | FAIL |
| `ByteLengthQueuingStrategy.prototype.size should work generically on its this and its arguments` | FAIL |
| `Service worker test setup` | PASS |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/close.serviceworker.https.html">/streams/writable-streams/close.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `releaseLock() should not change the result of async close()` | FAIL |
| `when sink calls error asynchronously while closing, the stream should become errored` | FAIL |
| `the promise returned by async abort during close should resolve` | FAIL |
| `releaseLock() should not change the result of sync close()` | FAIL |
| `when close is called on a WritableStream in writable state, ready should return a fulfilled promise` | FAIL |
| `returning a thenable from close() should work` | FAIL |
| `when sink calls error synchronously while closing, the stream should become errored` | FAIL |
| `close() should set state to CLOSED even if writer has detached` | FAIL |
| `when close is called on a WritableStream in waiting state, ready promise should be fulfilled` | FAIL |
| `Service worker test setup` | PASS |
| `fulfillment value of ws.close() call must be undefined even if the underlying sink returns a non-undefined value` | FAIL |
| `when close is called on a WritableStream in waiting state, ready should be fulfilled immediately even if close takes a long time` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/pipe-through.serviceworker.https.html">/streams/readable-streams/pipe-through.serviceworker.https.html</a></summary>
| Subtest | Results |
|-------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream.prototype.pipeThrough should throw when "this" has no pipeTo method` | FAIL |
| `ReadableStream.prototype.pipeThrough should work generically on its this and its arguments` | FAIL |
| `Service worker test setup` | PASS |
| `ReadableStream.prototype.pipeThrough should rethrow errors from accessing pipeTo, readable, or writable` | FAIL |
| `ReadableStream.prototype.pipeThrough should throw when its first argument is not convertible to an object` | FAIL |
| `ReadableStream.prototype.pipeThrough should work with missing readable, writable, or options` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/writable-streams/aborting.html">/streams/writable-streams/aborting.html</a></summary>
| Subtest | Results |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `underlying abort() should not be called until underlying write() completes` | FAIL |
| `.closed should not resolve before fulfilled write()` | FAIL |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects` | FAIL |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)` | FAIL |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects` | FAIL |
| `close() should use error from underlying write() on abort` | FAIL |
| `underlying abort() should not be called if underlying close() has started` | FAIL |
| `Aborting a WritableStream passes through the given reason` | FAIL |
| `underlying abort() should be called while closing if underlying close() has not started yet` | FAIL |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one` | FAIL |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error` | FAIL |
| `writer.ready should reject on controller error without waiting for underlying write` | FAIL |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError` | FAIL |
| `if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason` | FAIL |
| `Aborting a WritableStream prevents further writes after any that are in progress` | FAIL |
| `writes should be satisfied in order when aborting` | FAIL |
| `.closed should not resolve before rejected write(); write() error should overwrite abort() error` | FAIL |
| `Aborting a WritableStream immediately prevents future writes` | FAIL |
| `Aborting a WritableStream should cause the writer's unsettled ready promise to reject` | FAIL |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value` | FAIL |
| `writes should be satisfied in order after rejected write when aborting` | FAIL |
| `releaseLock() while aborting should reject the original closed promise` | FAIL |
| `releaseLock() during delayed async abort() should create a new rejected closed promise` | FAIL |
| `returning a thenable from abort() should work` | FAIL |
| `abort() on a released writer rejects` | FAIL |
| `Closing a WritableStream and aborting it while it closes causes the stream to error` | FAIL |
| `Aborting a WritableStream after it is closed is a no-op` | FAIL |
| `writer close() promise should resolve before abort() promise` | FAIL |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects` | FAIL |
| `Closing but then immediately aborting a WritableStream causes the stream to error` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/tee.html">/streams/readable-streams/tee.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream teeing: values should be equal across each branch` | FAIL |
| `ReadableStream teeing: canceling branch1 should not impact branch2` | FAIL |
| `ReadableStream teeing: closing the original should immediately close the branches` | FAIL |
| `ReadableStream teeing: rs.tee() returns an array of two ReadableStreams` | FAIL |
| `ReadableStream teeing: errors in the source should propagate to both branches` | FAIL |
| `ReadableStream teeing: canceling branch2 should not impact branch2` | FAIL |
| `ReadableStream teeing: failing to cancel the original stream should cause cancel() to reject on branches` | FAIL |
| `ReadableStream teeing: canceling both branches should aggregate the cancel reasons into an array` | FAIL |
| `ReadableStream teeing: should be able to read one branch to the end without affecting the other` | FAIL |
| `ReadableStream teeing: erroring the original should immediately error the branches` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/write.serviceworker.https.html">/streams/writable-streams/write.serviceworker.https.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `fulfillment value of ws.write() call should be undefined even if the underlying sink returns a non-undefined value` | FAIL |
| `WritableStream should complete asynchronous writes before close resolves` | FAIL |
| `returning a thenable from write() should work` | FAIL |
| `WritableStream should complete synchronous writes before close resolves` | FAIL |
| `when sink's write throws an error, the stream should become errored and the promise should reject` | FAIL |
| `WritableStream should transition to waiting until write is acknowledged` | FAIL |
| `Service worker test setup` | PASS |
| `WritableStreamDefaultWriter should work when manually constructed` | FAIL |
| `a large queue of writes should be processed completely` | FAIL |
| `when write returns a rejected promise, queued writes and close should be cleared` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/templated.serviceworker.https.html">/streams/readable-streams/templated.serviceworker.https.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Running templatedRSClosed with ReadableStream (closed via cancel)` | PASS |
| `ReadableStream (errored via call in start): getReader() should return a reader that acts errored` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock should cause further read() calls to reject with a TypeError` | FAIL |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (sequential)` | FAIL |
| `ReadableStream reader (errored before getting reader): read() should reject with the error` | FAIL |
| `ReadableStream (empty) reader: instances have the correct methods and properties` | FAIL |
| `ReadableStream (closed via call in start): should be able to acquire multiple readers if they are released in succession` | FAIL |
| `ReadableStream (empty) reader: releasing the lock should cause locked to become false` | FAIL |
| `Running templatedRSErrored with ReadableStream (errored via call in start)` | PASS |
| `ReadableStream (errored via call in start): locked should be false` | FAIL |
| `ReadableStream (empty) reader: getReader() again on the stream should fail` | FAIL |
| `Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader)` | PASS |
| `ReadableStream (empty) reader: two read()s should both never settle` | FAIL |
| `ReadableStream reader (closed after getting reader): read() should work when used within another read() fulfill callback` | FAIL |
| `ReadableStream (two chunks enqueued, still open) reader: read() should return distinct promises each time` | FAIL |
| `ReadableStream (empty): calling getReader with invalid arguments should throw appropriate errors` | FAIL |
| `Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start)` | PASS |
| `Running templatedRSEmptyReader with ReadableStream (empty) reader` | PASS |
| `ReadableStream reader (closed via cancel after getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream (closed via cancel): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: reader's closed property always returns the same promise` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): read() multiple times should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start): getReader() should return a reader that acts errored` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): closed should fulfill with undefined` | FAIL |
| `ReadableStream (closed via cancel): should be able to acquire multiple readers if they are released in succession` | FAIL |
| `Running templatedRSErroredReader with ReadableStream reader (errored before getting reader)` | PASS |
| `ReadableStream reader (closed after getting reader): read() multiple times should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start): locked should be false` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): read() should work when used within another read() fulfill callback` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start) reader: closed should reject with the error` | FAIL |
| `ReadableStream (empty) reader: locked should be true` | FAIL |
| `Running templatedRSClosedReader with ReadableStream reader (closed after getting reader)` | PASS |
| `ReadableStream reader (errored before getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream (closed via call in start): locked should be false` | FAIL |
| `ReadableStream (errored via call in start): reader cancel() should return a distinct rejected promise each time` | FAIL |
| `ReadableStream (two chunks enqueued, still open) reader: cancel() after a read() should still give that single read result` | FAIL |
| `ReadableStream reader (closed before getting reader): read() multiple times should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream reader (closed after getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream reader (closed after getting reader): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream (empty) reader: releasing the lock should cause further read() calls to reject with a TypeError` | FAIL |
| `Running templatedRSEmpty with ReadableStream (empty)` | PASS |
| `ReadableStream reader (closed before getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream reader (errored after getting reader): read() should reject with the error` | FAIL |
| `ReadableStream reader (closed before getting reader): closed should fulfill with undefined` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true` | FAIL |
| `ReadableStream (closed via call in start): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start) reader: read() should reject with the error` | FAIL |
| `ReadableStream (empty): instances have the correct methods and properties` | FAIL |
| `ReadableStream (closed via call in start): getReader() should be OK` | FAIL |
| `ReadableStream reader (errored after getting reader): closed should reject with the error` | FAIL |
| `ReadableStream (empty) reader: releasing the lock with pending read requests should throw but the read requests should stay pending` | FAIL |
| `Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start)` | PASS |
| `ReadableStream (closed via cancel): locked should be false` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (sequential)` | FAIL |
| `Running templatedRSErroredReader with ReadableStream reader (errored after getting reader)` | PASS |
| `ReadableStream reader (closed after getting reader): closed should fulfill with undefined` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (nested)` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): read() should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream reader (closed before getting reader): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream reader (errored after getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock after the stream is closed should cause locked to become false` | FAIL |
| `ReadableStream (closed via cancel): getReader() should be OK` | FAIL |
| `ReadableStream reader (closed before getting reader): read() should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream (empty) reader: releasing the lock should cause closed calls to reject with a TypeError` | FAIL |
| `ReadableStream (errored via call in start): should be able to obtain a second reader, with the correct closed promise` | FAIL |
| `Running templatedRSClosed with ReadableStream (closed via call in start)` | PASS |
| `ReadableStream reader (closed before getting reader): read() should work when used within another read() fulfill callback` | FAIL |
| `ReadableStream (closed via cancel): should not be able to acquire a second reader if we don't release the first one` | FAIL |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (nested)` | FAIL |
| `ReadableStream (empty) reader: canceling via the stream should fail` | FAIL |
| `ReadableStream (empty) reader: read() should never settle` | FAIL |
| `Service worker test setup` | PASS |
| `ReadableStream reader (errored before getting reader): closed should reject with the error` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start): read() twice should give the error each time` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream reader (closed after getting reader): read() should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream (empty) reader: canceling via the reader should cause the reader to act closed` | FAIL |
| `ReadableStream (errored via call in start): cancel() should return a distinct rejected promise each time` | FAIL |
| `ReadableStream (errored via call in start): should not be able to obtain additional readers if we don't release the first lock` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start) reader: releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream (errored via call in start): read() twice should give the error each time` | FAIL |
| `ReadableStream (closed via call in start): should not be able to acquire a second reader if we don't release the first one` | FAIL |
| `Running templatedRSClosedReader with ReadableStream reader (closed before getting reader)` | PASS |
| `ReadableStream (empty) reader: read() should return distinct promises each time` | FAIL |
| `Running templatedRSTwoChunksClosedReader with ReadableStream (two chunks enqueued, then closed) reader` | PASS |
| `Running templatedRSTwoChunksOpenReader with ReadableStream (two chunks enqueued, still open) reader` | PASS |
| `Running templatedRSErroredReader with ReadableStream (errored via returning a rejected promise in start) reader` | PASS |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/readable-streams/bad-underlying-sources.serviceworker.https.html">/streams/readable-streams/bad-underlying-sources.serviceworker.https.html</a></summary>
| Subtest | Results |
|--------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Underlying source pull: throwing getter (second pull)` | FAIL |
| `Underlying source start: throwing method` | FAIL |
| `Underlying source cancel: throwing getter` | FAIL |
| `Underlying source cancel: throwing method` | FAIL |
| `Underlying source: calling close after error should throw` | FAIL |
| `Service worker test setup` | PASS |
| `Underlying source: calling close on a non-empty canceled stream should throw` | FAIL |
| `Underlying source pull: throwing method (second pull)` | FAIL |
| `Underlying source: calling error and returning a rejected promise from pull should cause the stream to error with the first error` | FAIL |
| `Underlying source start: throwing getter` | FAIL |
| `Underlying source: calling enqueue on an empty canceled stream should throw` | FAIL |
| `Underlying source: calling enqueue on a closed stream should throw` | FAIL |
| `Underlying source: calling enqueue on an errored stream should throw` | FAIL |
| `Underlying source: calling enqueue on a non-empty canceled stream should throw` | FAIL |
| `Underlying source: throwing pull method (initial pull)` | FAIL |
| `Underlying source: throwing pull getter (initial pull)` | FAIL |
| `Underlying source: calling close twice on an empty stream should throw the second time` | FAIL |
| `Underlying source: calling error and returning a rejected promise from start should cause the stream to error with the first error` | FAIL |
| `Underlying source: calling close on an empty canceled stream should throw` | FAIL |
| `Underlying source: calling close twice on a non-empty stream should throw the second time` | FAIL |
| `Underlying source: calling error after close should throw` | FAIL |
| `Underlying source: calling error twice should throw the second time` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/writable-streams/byte-length-queuing-strategy.serviceworker.https.html">/streams/writable-streams/byte-length-queuing-strategy.serviceworker.https.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Closing a writable stream with in-flight writes below the high water mark delays the close call properly` | FAIL |
| `Service worker test setup` | PASS |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/bad-underlying-sources.html">/streams/readable-streams/bad-underlying-sources.html</a></summary>
| Subtest | Results |
|--------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Underlying source pull: throwing getter (second pull)` | FAIL |
| `Underlying source start: throwing method` | FAIL |
| `Underlying source cancel: throwing getter` | FAIL |
| `Underlying source cancel: throwing method` | FAIL |
| `Underlying source: calling close after error should throw` | FAIL |
| `Underlying source: calling close on a non-empty canceled stream should throw` | FAIL |
| `Underlying source pull: throwing method (second pull)` | FAIL |
| `Underlying source: calling error and returning a rejected promise from pull should cause the stream to error with the first error` | FAIL |
| `Underlying source start: throwing getter` | FAIL |
| `Underlying source: calling enqueue on an empty canceled stream should throw` | FAIL |
| `Underlying source: calling enqueue on a closed stream should throw` | FAIL |
| `Underlying source: calling enqueue on an errored stream should throw` | FAIL |
| `Underlying source: calling enqueue on a non-empty canceled stream should throw` | FAIL |
| `Underlying source: throwing pull method (initial pull)` | FAIL |
| `Underlying source: throwing pull getter (initial pull)` | FAIL |
| `Underlying source: calling close twice on an empty stream should throw the second time` | FAIL |
| `Underlying source: calling error and returning a rejected promise from start should cause the stream to error with the first error` | FAIL |
| `Underlying source: calling close on an empty canceled stream should throw` | FAIL |
| `Underlying source: calling close twice on a non-empty stream should throw the second time` | FAIL |
| `Underlying source: calling error after close should throw` | FAIL |
| `Underlying source: calling error twice should throw the second time` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/readable-stream-reader.html">/streams/readable-streams/readable-stream-reader.html</a></summary>
| Subtest | Results |
|----------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Cannot use an already-released reader to unlock a stream again` | FAIL |
| `Reading twice on a closed stream` | FAIL |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via direct construction)` | FAIL |
| `Multiple readers can access the stream in sequence` | FAIL |
| `cancel() on a reader does not release the reader` | FAIL |
| `Getting a second reader after erroring the stream and releasing the reader should succeed` | FAIL |
| `ReadableStreamReader constructor should get a ReadableStream object as argument` | PASS |
| `ReadableStreamReader: if start rejects with no parameter, it should error the stream with an undefined error` | FAIL |
| `ReadableStreamReader closed promise should be rejected with undefined if that is the error` | FAIL |
| `closed should be rejected after reader releases its lock (multiple stream locks)` | FAIL |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamReader closed promise` | FAIL |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)` | FAIL |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via getReader)` | FAIL |
| `Constructing a ReadableStreamReader directly should be OK if the stream is errored` | FAIL |
| `Reading twice on a stream that gets closed` | FAIL |
| `Can get the ReadableStreamReader constructor indirectly` | FAIL |
| `ReadableStreamReader instances should have the correct list of properties` | FAIL |
| `Constructing a ReadableStreamReader directly should be OK if the stream is closed` | FAIL |
| `Reading from a reader for an empty stream will wait until a chunk is available` | FAIL |
| `Reading twice on a stream that gets errored` | FAIL |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamReader closed promise` | FAIL |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via getReader)` | FAIL |
| `cancel() on a released reader is a no-op and does not pass through` | FAIL |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via direct construction)` | FAIL |
| `ReadableStreamReader closed should always return the same promise object` | FAIL |
| `Reading twice on an errored stream` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/error-propagation-backward.html">/streams/piping/error-propagation-backward.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = true, preventAbort = true, preventClose = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = 0 (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = -0 (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = false; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = 1 (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = false; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = a (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel omitted; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = undefined (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = null (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = false; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = true (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = false (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: starts errored; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = NaN (falsy); fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping due to last write; source is closed; preventCancel omitted (but cancel is never called)` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write, preventCancel = true; preventAbort = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel omitted; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping due to last write; source is closed; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = false; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel omitted; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = Symbol() (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; preventCancel omitted; rejected cancel promise` | FAIL |
| `Errors must be propagated backward: becomes errored after piping; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = true` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = [object Object] (truthy)` | FAIL |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel omitted; fulfilled cancel promise` | FAIL |
| `Errors must be propagated backward: erroring via the controller errors once pending write completes` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/general.html">/streams/readable-streams/general.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream can be constructed with no errors` | FAIL |
| `ReadableStream: enqueue should throw when the stream is readable but draining` | FAIL |
| `ReadableStream: should not call pull until the previous pull call's promise fulfills` | FAIL |
| `ReadableStream: should not call pull after start if the stream is now closed` | FAIL |
| `ReadableStream pull should be able to close a stream.` | FAIL |
| `ReadableStream start controller parameter should be extensible` | FAIL |
| `ReadableStream should be able to enqueue different objects.` | FAIL |
| `ReadableStream constructor should throw for non-function start arguments` | FAIL |
| `ReadableStream constructor can get initial garbage as cancel argument` | FAIL |
| `ReadableStream: should not call pull() in reaction to read()ing the last chunk, if draining` | FAIL |
| `ReadableStream constructor can get initial garbage as pull argument` | FAIL |
| `ReadableStream: should call underlying source methods as methods` | FAIL |
| `ReadableStream pull should be able to error a stream and throw.` | FAIL |
| `ReadableStream: should only call pull once on a non-empty stream read from before start fulfills` | FAIL |
| `ReadableStream: should only call pull once upon starting the stream` | FAIL |
| `ReadableStream: should call pull in reaction to read()ing the last chunk, if not draining` | FAIL |
| `ReadableStream start should be called with the proper parameters` | FAIL |
| `ReadableStream can't be constructed with an invalid type` | FAIL |
| `ReadableStream: should pull after start, and after every read` | FAIL |
| `ReadableStream strategies: the default strategy should give desiredSize of 1 to start, decreasing by 1 per enqueue` | FAIL |
| `ReadableStream instances should have the correct list of properties` | FAIL |
| `ReadableStream strategies: the default strategy should continue giving desiredSize of 1 if the chunks are read immediately` | FAIL |
| `ReadableStream pull should be able to error a stream.` | FAIL |
| `ReadableStream should be able to call start method within prototype chain of its source` | FAIL |
| `ReadableStream: should only call pull once on a non-empty stream read from after start fulfills` | FAIL |
| `ReadableStream: if pull rejects, it should error the stream` | FAIL |
| `ReadableStream integration test: adapting a random push source` | FAIL |
| `ReadableStream: enqueue should throw when the stream is closed` | FAIL |
| `ReadableStream can't be constructed with garbage` | FAIL |
| `ReadableStream integration test: adapting an async pull source` | FAIL |
| `ReadableStream: should call pull when trying to read from a started, empty stream` | FAIL |
| `ReadableStream integration test: adapting a sync pull source` | FAIL |
| `ReadableStream: should call pull after enqueueing from inside pull (with no read requests), if strategy allows` | FAIL |
| `ReadableStream start should be able to return a promise and reject it` | FAIL |
| `ReadableStream start should be able to return a promise` | FAIL |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4589/streams/piping/general.serviceworker.https.html">/streams/piping/general.serviceworker.https.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------------|---------|
| | OK |
| `pipeTo must fail if the ReadableStream is locked, and not lock the WritableStream` | FAIL |
| `Piping from a ReadableStream for which a chunk becomes asynchronously readable after the pipeTo` | FAIL |
| `an undefined rejection from write should cause pipeTo() to reject when preventCancel is true` | FAIL |
| `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is true` | FAIL |
| `Piping from a ReadableStream from which lots of chunks are synchronously readable` | FAIL |
| `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is false` | FAIL |
| `Piping must lock both the ReadableStream and WritableStream` | FAIL |
| `pipeTo must check the brand of its ReadableStream this value` | FAIL |
| `Service worker test setup` | PASS |
| `Piping finishing must unlock both the ReadableStream and WritableStream` | FAIL |
| `pipeTo must check the brand of its WritableStream argument` | FAIL |
| `an undefined rejection from write should cause pipeTo() to reject when preventCancel is false` | FAIL |
| `pipeTo must fail if the WritableStream is locked, and not lock the ReadableStream` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-streams/templated.html">/streams/readable-streams/templated.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `Running templatedRSClosed with ReadableStream (closed via cancel)` | PASS |
| `ReadableStream (errored via call in start): getReader() should return a reader that acts errored` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock should cause further read() calls to reject with a TypeError` | FAIL |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (sequential)` | FAIL |
| `ReadableStream reader (errored before getting reader): read() should reject with the error` | FAIL |
| `ReadableStream (empty) reader: instances have the correct methods and properties` | FAIL |
| `ReadableStream (closed via call in start): should be able to acquire multiple readers if they are released in succession` | FAIL |
| `ReadableStream (empty) reader: releasing the lock should cause locked to become false` | FAIL |
| `Running templatedRSErrored with ReadableStream (errored via call in start)` | PASS |
| `ReadableStream (errored via call in start): locked should be false` | FAIL |
| `ReadableStream (empty) reader: getReader() again on the stream should fail` | FAIL |
| `Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader)` | PASS |
| `ReadableStream (empty) reader: two read()s should both never settle` | FAIL |
| `ReadableStream reader (closed after getting reader): read() should work when used within another read() fulfill callback` | FAIL |
| `ReadableStream (two chunks enqueued, still open) reader: read() should return distinct promises each time` | FAIL |
| `ReadableStream (empty): calling getReader with invalid arguments should throw appropriate errors` | FAIL |
| `Running templatedRSErrored with ReadableStream (errored via returning a rejected promise in start)` | PASS |
| `Running templatedRSEmptyReader with ReadableStream (empty) reader` | PASS |
| `ReadableStream reader (closed via cancel after getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream (closed via cancel): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: reader's closed property always returns the same promise` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): read() multiple times should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start): getReader() should return a reader that acts errored` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): closed should fulfill with undefined` | FAIL |
| `ReadableStream (closed via cancel): should be able to acquire multiple readers if they are released in succession` | FAIL |
| `Running templatedRSErroredReader with ReadableStream reader (errored before getting reader)` | PASS |
| `ReadableStream reader (closed after getting reader): read() multiple times should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start): locked should be false` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): read() should work when used within another read() fulfill callback` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start) reader: closed should reject with the error` | FAIL |
| `ReadableStream (empty) reader: locked should be true` | FAIL |
| `Running templatedRSClosedReader with ReadableStream reader (closed after getting reader)` | PASS |
| `ReadableStream reader (errored before getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream (closed via call in start): locked should be false` | FAIL |
| `ReadableStream (errored via call in start): reader cancel() should return a distinct rejected promise each time` | FAIL |
| `ReadableStream (two chunks enqueued, still open) reader: cancel() after a read() should still give that single read result` | FAIL |
| `ReadableStream reader (closed before getting reader): read() multiple times should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream reader (closed after getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream reader (closed after getting reader): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream (empty) reader: releasing the lock should cause further read() calls to reject with a TypeError` | FAIL |
| `Running templatedRSEmpty with ReadableStream (empty)` | PASS |
| `ReadableStream reader (closed before getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream reader (errored after getting reader): read() should reject with the error` | FAIL |
| `ReadableStream reader (closed before getting reader): closed should fulfill with undefined` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true` | FAIL |
| `ReadableStream (closed via call in start): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start) reader: read() should reject with the error` | FAIL |
| `ReadableStream (empty): instances have the correct methods and properties` | FAIL |
| `ReadableStream (closed via call in start): getReader() should be OK` | FAIL |
| `ReadableStream reader (errored after getting reader): closed should reject with the error` | FAIL |
| `ReadableStream (empty) reader: releasing the lock with pending read requests should throw but the read requests should stay pending` | FAIL |
| `Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start)` | PASS |
| `ReadableStream (closed via cancel): locked should be false` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (sequential)` | FAIL |
| `Running templatedRSErroredReader with ReadableStream reader (errored after getting reader)` | PASS |
| `ReadableStream reader (closed after getting reader): closed should fulfill with undefined` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (nested)` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): read() should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream reader (closed before getting reader): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream reader (errored after getting reader): releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock after the stream is closed should cause locked to become false` | FAIL |
| `ReadableStream (closed via cancel): getReader() should be OK` | FAIL |
| `ReadableStream reader (closed before getting reader): read() should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream (empty) reader: releasing the lock should cause closed calls to reject with a TypeError` | FAIL |
| `ReadableStream (errored via call in start): should be able to obtain a second reader, with the correct closed promise` | FAIL |
| `Running templatedRSClosed with ReadableStream (closed via call in start)` | PASS |
| `ReadableStream reader (closed before getting reader): read() should work when used within another read() fulfill callback` | FAIL |
| `ReadableStream (closed via cancel): should not be able to acquire a second reader if we don't release the first one` | FAIL |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (nested)` | FAIL |
| `ReadableStream (empty) reader: canceling via the stream should fail` | FAIL |
| `ReadableStream (empty) reader: read() should never settle` | FAIL |
| `ReadableStream reader (errored before getting reader): closed should reject with the error` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start): read() twice should give the error each time` | FAIL |
| `ReadableStream reader (closed via cancel after getting reader): cancel() should return a distinct fulfilled promise each time` | FAIL |
| `ReadableStream reader (closed after getting reader): read() should fulfill with { value: undefined, done: true }` | FAIL |
| `ReadableStream (empty) reader: canceling via the reader should cause the reader to act closed` | FAIL |
| `ReadableStream (errored via call in start): cancel() should return a distinct rejected promise each time` | FAIL |
| `ReadableStream (errored via call in start): should not be able to obtain additional readers if we don't release the first lock` | FAIL |
| `ReadableStream (errored via returning a rejected promise in start) reader: releasing the lock should cause closed to reject and change identity` | FAIL |
| `ReadableStream (errored via call in start): read() twice should give the error each time` | FAIL |
| `ReadableStream (closed via call in start): should not be able to acquire a second reader if we don't release the first one` | FAIL |
| `Running templatedRSClosedReader with ReadableStream reader (closed before getting reader)` | PASS |
| `ReadableStream (empty) reader: read() should return distinct promises each time` | FAIL |
| `Running templatedRSTwoChunksClosedReader with ReadableStream (two chunks enqueued, then closed) reader` | PASS |
| `Running templatedRSTwoChunksOpenReader with ReadableStream (two chunks enqueued, still open) reader` | PASS |
| `Running templatedRSErroredReader with ReadableStream (errored via returning a rejected promise in start) reader` | PASS |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/readable-byte-streams/general.html">/streams/readable-byte-streams/general.html</a></summary>
| Subtest | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
| | OK |
| `ReadableStream with byte source: Multiple read(view), close() and respond()` | FAIL |
| `ReadableStream with byte source: Throwing in pull function must error the stream` | FAIL |
| `ReadableStream with byte source: Automatic pull() after start()` | FAIL |
| `ReadableStream with byte source: Multiple enqueue(), getReader(), then read(view)` | FAIL |
| `ReadableStream with byte source: read(view), then respond() and close() in pull()` | FAIL |
| `ReadableStream with byte source: Test that closing a stream does not release a reader automatically` | FAIL |
| `ReadableStream with byte source: A stream must be errored if close()-d before fulfilling read(view) with Uint16Array` | FAIL |
| `ReadableStream with byte source: read(view), then respond() with a transferred ArrayBuffer` | FAIL |
| `ReadableStream with byte source: enqueue() with Uint16Array, getReader(), then read()` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) with a smaller views` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view)` | FAIL |
| `ReadableStream with byte source: Test that erroring a stream does not release a reader automatically` | FAIL |
| `ReadableStream with byte source: Respond to pull() by enqueue()` | FAIL |
| `ReadableStream with byte source: read() twice, then enqueue() twice` | FAIL |
| `ReadableStreamBYOBReader constructor requires a ReadableStream with type "bytes"` | FAIL |
| `ReadableStream with byte source: releaseLock() on ReadableStreamReader with pending read() must throw` | FAIL |
| `ReadableStreamBYOBReader constructor requires a ReadableStream argument` | FAIL |
| `ReadableStream with byte source: Mix of auto allocate and BYOB` | FAIL |
| `ReadableStream with byte source: read(view) with Uint16Array on close()-d stream with 1 byte enqueue()-d must fail` | FAIL |
| `ReadableStream with byte source: read(view), then respond() with too big value` | FAIL |
| `ReadableStream with byte source: read(view) with Uint32Array, then fill it by multiple respond() calls` | FAIL |
| `ReadableStream with byte source: autoAllocateChunkSize` | FAIL |
| `ReadableStream with byte source: cancel() with partially filled pending pull() request` | FAIL |
| `ReadableStream with byte source: Construct and expect start and pull being called` | FAIL |
| `ReadableStream with byte source: read(view), then respond()` | FAIL |
| `ReadableStream with byte source: read(view), then error()` | FAIL |
| `ReadableStream with byte source: read(view), but pull() function is not callable` | FAIL |
| `ReadableStream with byte source: Automatic pull() after start() and read(view)` | FAIL |
| `ReadableStreamBYOBReader can be constructed directly` | FAIL |
| `ReadableStream with byte source: Throwing in pull in response to read() must be ignored if the stream is errored in it` | FAIL |
| `ReadableStream with byte source: read(view) with zero-length view must fail` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then cancel() (mode = not BYOB)` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then cancel() (mode = BYOB)` | FAIL |
| `ReadableStream with byte source can be constructed with no errors` | FAIL |
| `ReadableStream with byte source: Test that closing a stream does not release a BYOB reader automatically` | FAIL |
| `ReadableStream with byte source: read(), then error()` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read()` | FAIL |
| `ReadableStream with byte source: read(), but pull() function is not callable` | FAIL |
| `getReader({mode: "byob"}) throws on non-bytes streams` | FAIL |
| `ReadableStream with byte source: respond(3) to read(view) with 2 element Uint16Array enqueues the 1 byte remainder` | FAIL |
| `ReadableStream with byte source: enqueue() 1 byte, getReader(), then read(view) with Uint16Array` | FAIL |
| `ReadableStream with byte source: enqueue() 3 byte, getReader(), then read(view) with 2-element Uint16Array` | FAIL |
| `ReadableStream with byte source: Automatic pull() after start() and read()` | FAIL |
| `ReadableStream with byte source: Throw if close()-ed more than once` | FAIL |
| `ReadableStream with byte source: getReader(), read(view), then cancel()` | FAIL |
| `ReadableStream with byte source: Throwing in pull in response to read(view) must be ignored if the stream is errored in it` | FAIL |
| `ReadableStream with byte source: getReader() with mode set to byob, then releaseLock()` | FAIL |
| `ReadableStream with byte source: getReader(), enqueue(), close(), then read()` | FAIL |
| `ReadableStream with byte source: Throwing in pull in response to read(view) function must error the stream` | FAIL |
| `ReadableStream with byte source: getReader(), then releaseLock()` | FAIL |
| `ReadableStreamBYOBReader constructor requires an unlocked ReadableStream` | FAIL |
| `ReadableStream with byte source: Even read(view) with passing ArrayBufferView like object as view must fail` | FAIL |
| `ReadableStream with byte source: enqueue(), close(), getReader(), then read()` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) with a bigger view` | FAIL |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) where view.buffer is not fully covered by view` | FAIL |
| `ReadableStream with byte source: read() on an errored stream` | FAIL |
| `ReadableStream with byte source: Push source that doesn't understand pull signal` | FAIL |
| `ReadableStream with byte source: Throw on enqueue() after close()` | FAIL |
| `ReadableStream with byte source: read(view) with passing an empty object as view must fail` | FAIL |
| `ReadableStream with byte source: Multiple read(view), big enqueue()` | FAIL |
| `ReadableStream with byte source: Construct with highWaterMark of 0` | FAIL |
| `ReadableStream with byte source: Respond to pull() by enqueue() asynchronously` | FAIL |
| `ReadableStream with byte source: Multiple read(view) and multiple enqueue()` | FAIL |
| `ReadableStream with byte source: Test that erroring a stream does not release a BYOB reader automatically` | FAIL |
| `ReadableStream with byte source: read(view) with passing undefined as view must fail` | FAIL |
| `ReadableStream with byte source: read(view) on an errored stream` | FAIL |
| `ReadableStream with byte source: enqueue(), read(view) partially, then read()` | FAIL |
| `ReadableStream with byte source: No automatic pull call if start doesn't finish` | FAIL |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4589/streams/piping/multiple-propagation.html">/streams/piping/multiple-propagation.html</a></summary>
| Subtest | Results |
|---------------------------------------------------------------------------------------------|---------|
| | OK |
| `Piping from an errored readable stream to a closed writable stream` | FAIL |
| `Piping from a closed readable stream to a closed writable stream` | FAIL |
| `Piping from a closed readable stream to an errored writable stream` | FAIL |
| `Piping from an errored readable stream to an errored writable stream` | FAIL |
| `Piping from an errored readable stream to an errored writable stream; preventAbort = true` | FAIL |
</details>
View on GitHub: https://github.com/w3c/web-platform-tests/pull/4589#issuecomment-274172459
Received on Friday, 20 January 2017 20:31:39 UTC