Re: [streams-tests] Require HTTPS for the correct streams tests (#4589)

# Chrome (unstable channel) #
Testing web-platform-tests at revision 54e8054f0b00c35a92468c281027855958dd664b
Using browser at version 55.0.2883.75
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 |
|-----------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                               | ERROR   |
| `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 |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | ERROR   |
| `ReadableStream can be constructed with no errors`                                                                           | PASS    |
| `ReadableStream: enqueue should throw when the stream is readable but draining`                                              | PASS    |
| `ReadableStream: should not call pull until the previous pull call's promise fulfills`                                       | PASS    |
| `ReadableStream: should not call pull after start if the stream is now closed`                                               | PASS    |
| `ReadableStream pull should be able to close a stream.`                                                                      | PASS    |
| `ReadableStream start controller parameter should be extensible`                                                             | PASS    |
| `ReadableStream should be able to enqueue different objects.`                                                                | PASS    |
| `Service worker test setup`                                                                                                  | PASS    |
| `ReadableStream constructor should throw for non-function start arguments`                                                   | PASS    |
| `ReadableStream constructor can get initial garbage as cancel argument`                                                      | PASS    |
| `ReadableStream: should not call pull() in reaction to read()ing the last chunk, if draining`                                | PASS    |
| `ReadableStream constructor can get initial garbage as pull argument`                                                        | PASS    |
| `ReadableStream: should call underlying source methods as methods`                                                           | PASS    |
| `ReadableStream pull should be able to error a stream and throw.`                                                            | PASS    |
| `ReadableStream: should only call pull once on a non-empty stream read from before start fulfills`                           | PASS    |
| `ReadableStream: should only call pull once upon starting the stream`                                                        | PASS    |
| `ReadableStream: should call pull in reaction to read()ing the last chunk, if not draining`                                  | PASS    |
| `ReadableStream start should be called with the proper parameters`                                                           | FAIL    |
| `ReadableStream can't be constructed with an invalid type`                                                                   | PASS    |
| `ReadableStream: should pull after start, and after every read`                                                              | PASS    |
| `ReadableStream strategies: the default strategy should give desiredSize of 1 to start, decreasing by 1 per enqueue`         | PASS    |
| `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` | PASS    |
| `ReadableStream pull should be able to error a stream.`                                                                      | PASS    |
| `ReadableStream should be able to call start method within prototype chain of its source`                                    | PASS    |
| `ReadableStream: should only call pull once on a non-empty stream read from after start fulfills`                            | PASS    |
| `ReadableStream: if pull rejects, it should error the stream`                                                                | PASS    |
| `ReadableStream integration test: adapting a random push source`                                                             | PASS    |
| `ReadableStream: enqueue should throw when the stream is closed`                                                             | PASS    |
| `ReadableStream can't be constructed with garbage`                                                                           | PASS    |
| `ReadableStream integration test: adapting an async pull source`                                                             | PASS    |
| `ReadableStream: should call pull when trying to read from a started, empty stream`                                          | PASS    |
| `ReadableStream integration test: adapting a sync pull source`                                                               | PASS    |
| `ReadableStream: should call pull after enqueueing from inside pull (with no read requests), if strategy allows`             | PASS    |
| `ReadableStream start should be able to return a promise and reject it`                                                      | PASS    |
| `ReadableStream start should be able to return a promise`                                                                    | PASS    |

</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`                        | PASS    |
| `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` | PASS    |
| `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 |
|------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                            | ERROR   |
| `ReadableStream teeing: values should be equal across each branch`                                         | PASS    |
| `ReadableStream teeing: canceling branch1 should not impact branch2`                                       | PASS    |
| `ReadableStream teeing: closing the original should immediately close the branches`                        | PASS    |
| `ReadableStream teeing: rs.tee() returns an array of two ReadableStreams`                                  | PASS    |
| `ReadableStream teeing: errors in the source should propagate to both branches`                            | PASS    |
| `ReadableStream teeing: canceling branch2 should not impact branch2`                                       | PASS    |
| `ReadableStream teeing: failing to cancel the original stream should cause cancel() to reject on branches` | PASS    |
| `Service worker test setup`                                                                                | PASS    |
| `ReadableStream teeing: canceling both branches should aggregate the cancel reasons into an array`         | PASS    |
| `ReadableStream teeing: should be able to read one branch to the end without affecting the other`          | PASS    |
| `ReadableStream teeing: erroring the original should immediately error the branches`                       | PASS    |

</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 |
|-----------------------------------------------------------|---------|
|                                                           | ERROR   |
| `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 |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | ERROR   |
| `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`                         | PASS    |
| `ByteLengthQueuingStrategy constructor behaves as expected with strange arguments`               | PASS    |
| `ByteLengthQueuingStrategy instances have the correct properties`                                | PASS    |
| `Can construct a ByteLengthQueuingStrategy with any value as its high water mark`                | PASS    |
| `ByteLengthQueuingStrategy size behaves as expected with strange arguments`                      | PASS    |
| `ByteLengthQueuingStrategy.prototype.size should work generically on its this and its arguments` | PASS    |
| `ByteLengthQueuingStrategy's highWaterMark property can be set to anything`                      | PASS    |

</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`             | PASS    |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 1)` | PASS    |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 0)` | PASS    |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 4)` | PASS    |

</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`            | PASS    |
| `ReadableStreamReader.prototype.closed enforces a brand check`               | PASS    |
| `ReadableStreamReader.prototype.read enforces a brand check`                 | PASS    |
| `ReadableStreamReader.prototype.cancel enforces a brand check`               | PASS    |
| `Can get the ReadableStreamController constructor indirectly`                | PASS    |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | PASS    |
| `ReadableStream.prototype.cancel enforces a brand check`                     | PASS    |
| `ReadableStreamReader.prototype.releaseLock enforces a brand check`          | PASS    |
| `ReadableStream.prototype.tee enforces a brand check`                        | PASS    |
| `ReadableStream.prototype.getReader enforces a brand check`                  | PASS    |
| `ReadableStreamReader enforces a brand check on its argument`                | PASS    |
| `ReadableStreamController enforces a brand check on its argument`            | PASS    |
| `Can get the ReadableStreamReader constructor indirectly`                    | PASS    |
| `ReadableStreamController.prototype.error enforces a brand check`            | PASS    |
| `ReadableStreamController.prototype.enqueue enforces a brand check`          | PASS    |

</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 |
|---------------------------------------------------------------------------------------------------|---------|
|                                                                                                   | ERROR   |
| `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 |
|---------------------------------------------------------------------------------------------|---------|
|                                                                                             | ERROR   |
| `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 |
|-------------------------------------------------------------------|---------|
|                                                                   | ERROR   |
| `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`                         | PASS    |
| `CountQueuingStrategy constructor behaves as expected with strange arguments`               | PASS    |
| `CountQueuingStrategy.prototype.size should work generically on its this and its arguments` | PASS    |
| `CountQueuingStrategy size behaves as expected with strange arguments`                      | PASS    |
| `Can construct a CountQueuingStrategy with any value as its high water mark`                | PASS    |
| `CountQueuingStrategy instances have the correct properties`                                | PASS    |
| `CountQueuingStrategy's highWaterMark property can be set to anything`                      | PASS    |

</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 |
|---------------------------------------------------------------------------------|---------|
|                                                                                 | ERROR   |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 4)` | PASS    |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 1)` | PASS    |
| `Correctly governs a ReadableStreamController's desiredSize property (HWM = 0)` | PASS    |
| `Service worker test setup`                                                     | PASS    |
| `Can construct a readable stream with a valid CountQueuingStrategy`             | PASS    |

</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 |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                 | ERROR   |
| `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 |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                                                        | ERROR   |
| `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 |
|-------------------------------------------------------------------------------------------------------|---------|
|                                                                                                       | ERROR   |
| `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 |
|------------------------------------------------------------------------------|---------|
|                                                                              | ERROR   |
| `Readable stream: throwing strategy.highWaterMark getter`                    | PASS    |
| `Readable stream: strategy.size errors the stream and then throws`           | PASS    |
| `Readable stream: throwing strategy.size method`                             | PASS    |
| `Readable stream: throwing strategy.size getter`                             | PASS    |
| `Service worker test setup`                                                  | PASS    |
| `Readable stream: invalid strategy.highWaterMark`                            | FAIL    |
| `Readable stream: invalid strategy.size return value`                        | PASS    |
| `Readable stream: strategy.size errors the stream and then returns Infinity` | PASS    |

</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`                          | PASS    |
| `Garbage-collecting a ReadableStreamReader should not unlock its stream`                                                     | PASS    |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost`                               | PASS    |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | PASS    |

</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 |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | ERROR   |
| `Garbage-collecting a ReadableStreamReader should not unlock its stream`                                                     | PASS    |
| `ReadableStream closed promise should reject even if stream and reader JS references are lost`                               | PASS    |
| `Service worker test setup`                                                                                                  | PASS    |
| `ReadableStream closed promise should fulfill even if the stream and reader JS references are lost`                          | PASS    |
| `ReadableStreamController methods should continue working properly when scripts lose their reference to the readable stream` | PASS    |

</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 |
|-----------------------------|---------|
|                             | ERROR   |
| `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`                                                                      | PASS    |
| `ReadableStream cancellation: cancel(reason) should pass through the given reason to the underlying source`                                                                  | PASS    |
| `ReadableStream cancellation: cancelling before start finishes should prevent pull() from being called`                                                                      | PASS    |
| `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`  | PASS    |
| `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`      | PASS    |
| `ReadableStream cancellation: cancel() on a locked stream should fail and not call the underlying source cancel`                                                             | PASS    |
| `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)` | PASS    |
| `ReadableStream cancellation: should fulfill promise when cancel callback went fine`                                                                                         | PASS    |
| `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)` | PASS    |
| `ReadableStream cancellation: should reject promise when cancel callback raises an exception`                                                                                | PASS    |

</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 |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                                              | ERROR   |
| `ReadableStream cancellation: integration test on an infinite stream derived from a random push source`                                                                      | PASS    |
| `ReadableStream cancellation: cancel(reason) should pass through the given reason to the underlying source`                                                                  | PASS    |
| `ReadableStream cancellation: cancelling before start finishes should prevent pull() from being called`                                                                      | PASS    |
| `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`  | PASS    |
| `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`      | PASS    |
| `ReadableStream cancellation: cancel() on a locked stream should fail and not call the underlying source cancel`                                                             | PASS    |
| `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)` | PASS    |
| `Service worker test setup`                                                                                                                                                  | PASS    |
| `ReadableStream cancellation: should fulfill promise when cancel callback went fine`                                                                                         | PASS    |
| `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)` | PASS    |
| `ReadableStream cancellation: should reject promise when cancel callback raises an exception`                                                                                | PASS    |

</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 |
|----------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                      | ERROR   |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamReader closed promise`                 | PASS    |
| `Service worker test setup`                                                                                          | PASS    |
| `Reading twice on a closed stream`                                                                                   | PASS    |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via direct construction)` | PASS    |
| `Multiple readers can access the stream in sequence`                                                                 | PASS    |
| `cancel() on a reader does not release the reader`                                                                   | PASS    |
| `Getting a second reader after erroring the stream and releasing the reader should succeed`                          | PASS    |
| `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`       | PASS    |
| `ReadableStreamReader closed promise should be rejected with undefined if that is the error`                         | PASS    |
| `closed should be rejected after reader releases its lock (multiple stream locks)`                                   | PASS    |
| `Cannot use an already-released reader to unlock a stream again`                                                     | PASS    |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)`                                | PASS    |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via getReader)`           | PASS    |
| `Constructing a ReadableStreamReader directly should be OK if the stream is errored`                                 | PASS    |
| `Reading twice on a stream that gets closed`                                                                         | PASS    |
| `Can get the ReadableStreamReader constructor indirectly`                                                            | PASS    |
| `ReadableStreamReader instances should have the correct list of properties`                                          | PASS    |
| `Constructing a ReadableStreamReader directly should be OK if the stream is closed`                                  | PASS    |
| `Reading from a reader for an empty stream will wait until a chunk is available`                                     | PASS    |
| `Reading twice on a stream that gets errored`                                                                        | PASS    |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamReader closed promise`                  | PASS    |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via getReader)`           | PASS    |
| `cancel() on a released reader is a no-op and does not pass through`                                                 | PASS    |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via direct construction)` | PASS    |
| `ReadableStreamReader closed should always return the same promise object`                                           | PASS    |
| `Reading twice on an errored stream`                                                                                 | PASS    |

</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 |
|------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                            | ERROR   |
| `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`                    | PASS    |
| `Readable stream: invalid strategy.highWaterMark`                            | FAIL    |
| `Readable stream: throwing strategy.size method`                             | PASS    |
| `Readable stream: throwing strategy.size getter`                             | PASS    |
| `Readable stream: strategy.size errors the stream and then throws`           | PASS    |
| `Readable stream: invalid strategy.size return value`                        | PASS    |
| `Readable stream: strategy.size errors the stream and then returns Infinity` | PASS    |

</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 |
|------------------------------------------------------------------------------|---------|
|                                                                              | ERROR   |
| `ReadableStreamController.prototype.close enforces a brand check`            | PASS    |
| `ReadableStreamReader.prototype.closed enforces a brand check`               | PASS    |
| `ReadableStreamReader.prototype.read enforces a brand check`                 | PASS    |
| `ReadableStreamReader.prototype.cancel enforces a brand check`               | PASS    |
| `Can get the ReadableStreamController constructor indirectly`                | PASS    |
| `ReadableStreamController.prototype.enqueue enforces a brand check`          | PASS    |
| `ReadableStreamController can't be given a fully-constructed ReadableStream` | PASS    |
| `ReadableStream.prototype.cancel enforces a brand check`                     | PASS    |
| `ReadableStreamReader.prototype.releaseLock enforces a brand check`          | PASS    |
| `ReadableStream.prototype.tee enforces a brand check`                        | PASS    |
| `ReadableStream.prototype.getReader enforces a brand check`                  | PASS    |
| `Service worker test setup`                                                  | PASS    |
| `ReadableStreamController enforces a brand check on its argument`            | PASS    |
| `Can get the ReadableStreamReader constructor indirectly`                    | PASS    |
| `ReadableStreamController.prototype.error enforces a brand check`            | PASS    |
| `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 |
|-----------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                             | ERROR   |
| `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 |
|----------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                      | ERROR   |
| `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 |
|------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                | ERROR   |
| `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 |
|----------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                      | ERROR   |
| `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 |
|---------------------------------------------------------------------------------------------|---------|
|                                                                                             | ERROR   |
| `Can construct a CountQueuingStrategy with a valid high water mark`                         | PASS    |
| `CountQueuingStrategy constructor behaves as expected with strange arguments`               | PASS    |
| `CountQueuingStrategy.prototype.size should work generically on its this and its arguments` | PASS    |
| `CountQueuingStrategy size behaves as expected with strange arguments`                      | PASS    |
| `Can construct a CountQueuingStrategy with any value as its high water mark`                | PASS    |
| `CountQueuingStrategy instances have the correct properties`                                | PASS    |
| `Service worker test setup`                                                                 | PASS    |
| `CountQueuingStrategy's highWaterMark property can be set to anything`                      | PASS    |

</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 |
|--------------------------------------------------------------------------------------------------------|---------|
|                                                                                                        | ERROR   |
| `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 |
|------------------------------------------------------------------------------|---------|
|                                                                              | ERROR   |
| `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 |
|--------------------------------------------------------------------------------------------------|---------|
|                                                                                                  | ERROR   |
| `Can construct a ByteLengthQueuingStrategy with a valid high water mark`                         | PASS    |
| `ByteLengthQueuingStrategy constructor behaves as expected with strange arguments`               | PASS    |
| `ByteLengthQueuingStrategy instances have the correct properties`                                | PASS    |
| `Can construct a ByteLengthQueuingStrategy with any value as its high water mark`                | PASS    |
| `ByteLengthQueuingStrategy's highWaterMark property can be set to anything`                      | PASS    |
| `ByteLengthQueuingStrategy size behaves as expected with strange arguments`                      | PASS    |
| `ByteLengthQueuingStrategy.prototype.size should work generically on its this and its arguments` | PASS    |
| `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 |
|------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                    | ERROR   |
| `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 |
|-------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                             | ERROR   |
| `ReadableStream.prototype.pipeThrough should throw when "this" has no pipeTo method`                        | PASS    |
| `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` | PASS    |
| `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`                                         | PASS    |
| `ReadableStream teeing: canceling branch1 should not impact branch2`                                       | PASS    |
| `ReadableStream teeing: closing the original should immediately close the branches`                        | PASS    |
| `ReadableStream teeing: rs.tee() returns an array of two ReadableStreams`                                  | PASS    |
| `ReadableStream teeing: errors in the source should propagate to both branches`                            | PASS    |
| `ReadableStream teeing: canceling branch2 should not impact branch2`                                       | PASS    |
| `ReadableStream teeing: failing to cancel the original stream should cause cancel() to reject on branches` | PASS    |
| `ReadableStream teeing: canceling both branches should aggregate the cancel reasons into an array`         | PASS    |
| `ReadableStream teeing: should be able to read one branch to the end without affecting the other`          | PASS    |
| `ReadableStream teeing: erroring the original should immediately error the branches`                       | PASS    |

</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 |
|----------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                      | ERROR   |
| `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 |
|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                                                     | ERROR   |
| `Running templatedRSClosed with ReadableStream (closed via cancel)`                                                                                                 | PASS    |
| `ReadableStream (errored via call in start): getReader() should return a reader that acts errored`                                                                  | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock should cause further read() calls to reject with a TypeError`                         | PASS    |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (sequential)`                       | PASS    |
| `ReadableStream reader (errored before getting reader): read() should reject with the error`                                                                        | PASS    |
| `ReadableStream (empty) reader: instances have the correct methods and properties`                                                                                  | PASS    |
| `ReadableStream (closed via call in start): should be able to acquire multiple readers if they are released in succession`                                          | PASS    |
| `ReadableStream (empty) reader: releasing the lock should cause locked to become false`                                                                             | PASS    |
| `Running templatedRSErrored with ReadableStream (errored via call in start)`                                                                                        | PASS    |
| `ReadableStream (errored via call in start): locked should be false`                                                                                                | PASS    |
| `ReadableStream (empty) reader: getReader() again on the stream should fail`                                                                                        | PASS    |
| `Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader)`                                                               | PASS    |
| `ReadableStream (empty) reader: two read()s should both never settle`                                                                                               | PASS    |
| `ReadableStream reader (closed after getting reader): read() should work when used within another read() fulfill callback`                                          | PASS    |
| `ReadableStream (two chunks enqueued, still open) reader: read() should return distinct promises each time`                                                         | PASS    |
| `ReadableStream (empty): calling getReader with invalid arguments should throw appropriate errors`                                                                  | PASS    |
| `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`                              | PASS    |
| `ReadableStream (closed via cancel): cancel() should return a distinct fulfilled promise each time`                                                                 | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: reader's closed property always returns the same promise`                                                | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): read() multiple times should fulfill with { value: undefined, done: true }`                        | PASS    |
| `ReadableStream (errored via returning a rejected promise in start): getReader() should return a reader that acts errored`                                          | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): closed should fulfill with undefined`                                                              | PASS    |
| `ReadableStream (closed via cancel): should be able to acquire multiple readers if they are released in succession`                                                 | PASS    |
| `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 }`                                   | PASS    |
| `ReadableStream (errored via returning a rejected promise in start): locked should be false`                                                                        | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): read() should work when used within another read() fulfill callback`                               | PASS    |
| `ReadableStream (errored via returning a rejected promise in start) reader: closed should reject with the error`                                                    | PASS    |
| `ReadableStream (empty) reader: locked should be true`                                                                                                              | PASS    |
| `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`                                       | PASS    |
| `ReadableStream (closed via call in start): locked should be false`                                                                                                 | PASS    |
| `ReadableStream (errored via call in start): reader cancel() should return a distinct rejected promise each time`                                                   | PASS    |
| `ReadableStream (two chunks enqueued, still open) reader: cancel() after a read() should still give that single read result`                                        | PASS    |
| `ReadableStream reader (closed before getting reader): read() multiple times should fulfill with { value: undefined, done: true }`                                  | PASS    |
| `ReadableStream reader (closed after getting reader): releasing the lock should cause closed to reject and change identity`                                         | PASS    |
| `ReadableStream reader (closed after getting reader): cancel() should return a distinct fulfilled promise each time`                                                | PASS    |
| `ReadableStream (empty) reader: releasing the lock should cause further read() calls to reject with a TypeError`                                                    | PASS    |
| `Running templatedRSEmpty with ReadableStream (empty)`                                                                                                              | PASS    |
| `ReadableStream reader (closed before getting reader): releasing the lock should cause closed to reject and change identity`                                        | PASS    |
| `ReadableStream reader (errored after getting reader): read() should reject with the error`                                                                         | PASS    |
| `ReadableStream reader (closed before getting reader): closed should fulfill with undefined`                                                                        | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true` | PASS    |
| `ReadableStream (closed via call in start): cancel() should return a distinct fulfilled promise each time`                                                          | PASS    |
| `ReadableStream (errored via returning a rejected promise in start) reader: read() should reject with the error`                                                    | PASS    |
| `ReadableStream (empty): instances have the correct methods and properties`                                                                                         | FAIL    |
| `ReadableStream (closed via call in start): getReader() should be OK`                                                                                               | PASS    |
| `ReadableStream reader (errored after getting reader): closed should reject with the error`                                                                         | PASS    |
| `ReadableStream (empty) reader: releasing the lock with pending read requests should throw but the read requests should stay pending`                               | PASS    |
| `Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start)`                                                                                | PASS    |
| `ReadableStream (closed via cancel): locked should be false`                                                                                                        | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (sequential)`                | PASS    |
| `Running templatedRSErroredReader with ReadableStream reader (errored after getting reader)`                                                                        | PASS    |
| `ReadableStream reader (closed after getting reader): closed should fulfill with undefined`                                                                         | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (nested)`                    | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): read() should fulfill with { value: undefined, done: true }`                                       | PASS    |
| `ReadableStream reader (closed before getting reader): cancel() should return a distinct fulfilled promise each time`                                               | PASS    |
| `ReadableStream reader (errored after getting reader): releasing the lock should cause closed to reject and change identity`                                        | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock after the stream is closed should cause locked to become false`                       | PASS    |
| `ReadableStream (closed via cancel): getReader() should be OK`                                                                                                      | PASS    |
| `ReadableStream reader (closed before getting reader): read() should fulfill with { value: undefined, done: true }`                                                 | PASS    |
| `ReadableStream (empty) reader: releasing the lock should cause closed calls to reject with a TypeError`                                                            | PASS    |
| `ReadableStream (errored via call in start): should be able to obtain a second reader, with the correct closed promise`                                             | PASS    |
| `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`                                         | PASS    |
| `ReadableStream (closed via cancel): should not be able to acquire a second reader if we don't release the first one`                                               | PASS    |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (nested)`                           | PASS    |
| `ReadableStream (empty) reader: canceling via the stream should fail`                                                                                               | PASS    |
| `ReadableStream (empty) reader: read() should never settle`                                                                                                         | PASS    |
| `Service worker test setup`                                                                                                                                         | PASS    |
| `ReadableStream reader (errored before getting reader): closed should reject with the error`                                                                        | PASS    |
| `ReadableStream (errored via returning a rejected promise in start): read() twice should give the error each time`                                                  | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): cancel() should return a distinct fulfilled promise each time`                                     | PASS    |
| `ReadableStream reader (closed after getting reader): read() should fulfill with { value: undefined, done: true }`                                                  | PASS    |
| `ReadableStream (empty) reader: canceling via the reader should cause the reader to act closed`                                                                     | PASS    |
| `ReadableStream (errored via call in start): cancel() should return a distinct rejected promise each time`                                                          | PASS    |
| `ReadableStream (errored via call in start): should not be able to obtain additional readers if we don't release the first lock`                                    | PASS    |
| `ReadableStream (errored via returning a rejected promise in start) reader: releasing the lock should cause closed to reject and change identity`                   | PASS    |
| `ReadableStream (errored via call in start): read() twice should give the error each time`                                                                          | PASS    |
| `ReadableStream (closed via call in start): should not be able to acquire a second reader if we don't release the first one`                                        | PASS    |
| `Running templatedRSClosedReader with ReadableStream reader (closed before getting reader)`                                                                         | PASS    |
| `ReadableStream (empty) reader: read() should return distinct promises each time`                                                                                   | PASS    |
| `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 |
|--------------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                                      | ERROR   |
| `Underlying source pull: throwing getter (second pull)`                                                                              | PASS    |
| `Underlying source start: throwing method`                                                                                           | PASS    |
| `Underlying source cancel: throwing getter`                                                                                          | PASS    |
| `Underlying source cancel: throwing method`                                                                                          | PASS    |
| `Underlying source: calling close after error should throw`                                                                          | PASS    |
| `Service worker test setup`                                                                                                          | PASS    |
| `Underlying source: calling close on a non-empty canceled stream should throw`                                                       | PASS    |
| `Underlying source pull: throwing method (second pull)`                                                                              | PASS    |
| `Underlying source: calling error and returning a rejected promise from pull should cause the stream to error with the first error`  | PASS    |
| `Underlying source start: throwing getter`                                                                                           | PASS    |
| `Underlying source: calling enqueue on an empty canceled stream should throw`                                                        | PASS    |
| `Underlying source: calling enqueue on a closed stream should throw`                                                                 | PASS    |
| `Underlying source: calling enqueue on an errored stream should throw`                                                               | PASS    |
| `Underlying source: calling enqueue on a non-empty canceled stream should throw`                                                     | PASS    |
| `Underlying source: throwing pull method (initial pull)`                                                                             | PASS    |
| `Underlying source: throwing pull getter (initial pull)`                                                                             | PASS    |
| `Underlying source: calling close twice on an empty stream should throw the second time`                                             | PASS    |
| `Underlying source: calling error and returning a rejected promise from start should cause the stream to error with the first error` | PASS    |
| `Underlying source: calling close on an empty canceled stream should throw`                                                          | PASS    |
| `Underlying source: calling close twice on a non-empty stream should throw the second time`                                          | PASS    |
| `Underlying source: calling error after close should throw`                                                                          | PASS    |
| `Underlying source: calling error twice should throw the second time`                                                                | PASS    |

</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 |
|------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                            | ERROR   |
| `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)`                                                                              | PASS    |
| `Underlying source start: throwing method`                                                                                           | PASS    |
| `Underlying source cancel: throwing getter`                                                                                          | PASS    |
| `Underlying source cancel: throwing method`                                                                                          | PASS    |
| `Underlying source: calling close after error should throw`                                                                          | PASS    |
| `Underlying source: calling close on a non-empty canceled stream should throw`                                                       | PASS    |
| `Underlying source pull: throwing method (second pull)`                                                                              | PASS    |
| `Underlying source: calling error and returning a rejected promise from pull should cause the stream to error with the first error`  | PASS    |
| `Underlying source start: throwing getter`                                                                                           | PASS    |
| `Underlying source: calling enqueue on an empty canceled stream should throw`                                                        | PASS    |
| `Underlying source: calling enqueue on a closed stream should throw`                                                                 | PASS    |
| `Underlying source: calling enqueue on an errored stream should throw`                                                               | PASS    |
| `Underlying source: calling enqueue on a non-empty canceled stream should throw`                                                     | PASS    |
| `Underlying source: throwing pull method (initial pull)`                                                                             | PASS    |
| `Underlying source: throwing pull getter (initial pull)`                                                                             | PASS    |
| `Underlying source: calling close twice on an empty stream should throw the second time`                                             | PASS    |
| `Underlying source: calling error and returning a rejected promise from start should cause the stream to error with the first error` | PASS    |
| `Underlying source: calling close on an empty canceled stream should throw`                                                          | PASS    |
| `Underlying source: calling close twice on a non-empty stream should throw the second time`                                          | PASS    |
| `Underlying source: calling error after close should throw`                                                                          | PASS    |
| `Underlying source: calling error twice should throw the second time`                                                                | PASS    |

</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`                                                     | PASS    |
| `Reading twice on a closed stream`                                                                                   | PASS    |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via direct construction)` | PASS    |
| `Multiple readers can access the stream in sequence`                                                                 | PASS    |
| `cancel() on a reader does not release the reader`                                                                   | PASS    |
| `Getting a second reader after erroring the stream and releasing the reader should succeed`                          | PASS    |
| `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`       | PASS    |
| `ReadableStreamReader closed promise should be rejected with undefined if that is the error`                         | PASS    |
| `closed should be rejected after reader releases its lock (multiple stream locks)`                                   | PASS    |
| `Erroring a ReadableStream before checking closed should reject ReadableStreamReader closed promise`                 | PASS    |
| `closed should be fulfilled after stream is closed (.closed access before acquiring)`                                | PASS    |
| `Getting a ReadableStreamReader via getReader should fail if the stream is already locked (via getReader)`           | PASS    |
| `Constructing a ReadableStreamReader directly should be OK if the stream is errored`                                 | PASS    |
| `Reading twice on a stream that gets closed`                                                                         | PASS    |
| `Can get the ReadableStreamReader constructor indirectly`                                                            | PASS    |
| `ReadableStreamReader instances should have the correct list of properties`                                          | PASS    |
| `Constructing a ReadableStreamReader directly should be OK if the stream is closed`                                  | PASS    |
| `Reading from a reader for an empty stream will wait until a chunk is available`                                     | PASS    |
| `Reading twice on a stream that gets errored`                                                                        | PASS    |
| `Erroring a ReadableStream after checking closed should reject ReadableStreamReader closed promise`                  | PASS    |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via getReader)`           | PASS    |
| `cancel() on a released reader is a no-op and does not pass through`                                                 | PASS    |
| `Constructing a ReadableStreamReader directly should fail if the stream is already locked (via direct construction)` | PASS    |
| `ReadableStreamReader closed should always return the same promise object`                                           | PASS    |
| `Reading twice on an errored stream`                                                                                 | PASS    |

</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`                                                                           | PASS    |
| `ReadableStream: enqueue should throw when the stream is readable but draining`                                              | PASS    |
| `ReadableStream: should not call pull until the previous pull call's promise fulfills`                                       | PASS    |
| `ReadableStream: should not call pull after start if the stream is now closed`                                               | PASS    |
| `ReadableStream pull should be able to close a stream.`                                                                      | PASS    |
| `ReadableStream start controller parameter should be extensible`                                                             | PASS    |
| `ReadableStream should be able to enqueue different objects.`                                                                | PASS    |
| `ReadableStream constructor should throw for non-function start arguments`                                                   | PASS    |
| `ReadableStream constructor can get initial garbage as cancel argument`                                                      | PASS    |
| `ReadableStream: should not call pull() in reaction to read()ing the last chunk, if draining`                                | PASS    |
| `ReadableStream constructor can get initial garbage as pull argument`                                                        | PASS    |
| `ReadableStream: should call underlying source methods as methods`                                                           | PASS    |
| `ReadableStream pull should be able to error a stream and throw.`                                                            | PASS    |
| `ReadableStream: should only call pull once on a non-empty stream read from before start fulfills`                           | PASS    |
| `ReadableStream: should only call pull once upon starting the stream`                                                        | PASS    |
| `ReadableStream: should call pull in reaction to read()ing the last chunk, if not draining`                                  | PASS    |
| `ReadableStream start should be called with the proper parameters`                                                           | FAIL    |
| `ReadableStream can't be constructed with an invalid type`                                                                   | PASS    |
| `ReadableStream: should pull after start, and after every read`                                                              | PASS    |
| `ReadableStream strategies: the default strategy should give desiredSize of 1 to start, decreasing by 1 per enqueue`         | PASS    |
| `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` | PASS    |
| `ReadableStream pull should be able to error a stream.`                                                                      | PASS    |
| `ReadableStream should be able to call start method within prototype chain of its source`                                    | PASS    |
| `ReadableStream: should only call pull once on a non-empty stream read from after start fulfills`                            | PASS    |
| `ReadableStream: if pull rejects, it should error the stream`                                                                | PASS    |
| `ReadableStream integration test: adapting a random push source`                                                             | PASS    |
| `ReadableStream: enqueue should throw when the stream is closed`                                                             | PASS    |
| `ReadableStream can't be constructed with garbage`                                                                           | PASS    |
| `ReadableStream integration test: adapting an async pull source`                                                             | PASS    |
| `ReadableStream: should call pull when trying to read from a started, empty stream`                                          | PASS    |
| `ReadableStream integration test: adapting a sync pull source`                                                               | PASS    |
| `ReadableStream: should call pull after enqueueing from inside pull (with no read requests), if strategy allows`             | PASS    |
| `ReadableStream start should be able to return a promise and reject it`                                                      | PASS    |
| `ReadableStream start should be able to return a promise`                                                                    | PASS    |

</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 |
|---------------------------------------------------------------------------------------------------|---------|
|                                                                                                   | ERROR   |
| `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`                                                                  | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock should cause further read() calls to reject with a TypeError`                         | PASS    |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (sequential)`                       | PASS    |
| `ReadableStream reader (errored before getting reader): read() should reject with the error`                                                                        | PASS    |
| `ReadableStream (empty) reader: instances have the correct methods and properties`                                                                                  | PASS    |
| `ReadableStream (closed via call in start): should be able to acquire multiple readers if they are released in succession`                                          | PASS    |
| `ReadableStream (empty) reader: releasing the lock should cause locked to become false`                                                                             | PASS    |
| `Running templatedRSErrored with ReadableStream (errored via call in start)`                                                                                        | PASS    |
| `ReadableStream (errored via call in start): locked should be false`                                                                                                | PASS    |
| `ReadableStream (empty) reader: getReader() again on the stream should fail`                                                                                        | PASS    |
| `Running templatedRSClosedReader with ReadableStream reader (closed via cancel after getting reader)`                                                               | PASS    |
| `ReadableStream (empty) reader: two read()s should both never settle`                                                                                               | PASS    |
| `ReadableStream reader (closed after getting reader): read() should work when used within another read() fulfill callback`                                          | PASS    |
| `ReadableStream (two chunks enqueued, still open) reader: read() should return distinct promises each time`                                                         | PASS    |
| `ReadableStream (empty): calling getReader with invalid arguments should throw appropriate errors`                                                                  | PASS    |
| `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`                              | PASS    |
| `ReadableStream (closed via cancel): cancel() should return a distinct fulfilled promise each time`                                                                 | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: reader's closed property always returns the same promise`                                                | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): read() multiple times should fulfill with { value: undefined, done: true }`                        | PASS    |
| `ReadableStream (errored via returning a rejected promise in start): getReader() should return a reader that acts errored`                                          | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): closed should fulfill with undefined`                                                              | PASS    |
| `ReadableStream (closed via cancel): should be able to acquire multiple readers if they are released in succession`                                                 | PASS    |
| `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 }`                                   | PASS    |
| `ReadableStream (errored via returning a rejected promise in start): locked should be false`                                                                        | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): read() should work when used within another read() fulfill callback`                               | PASS    |
| `ReadableStream (errored via returning a rejected promise in start) reader: closed should reject with the error`                                                    | PASS    |
| `ReadableStream (empty) reader: locked should be true`                                                                                                              | PASS    |
| `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`                                       | PASS    |
| `ReadableStream (closed via call in start): locked should be false`                                                                                                 | PASS    |
| `ReadableStream (errored via call in start): reader cancel() should return a distinct rejected promise each time`                                                   | PASS    |
| `ReadableStream (two chunks enqueued, still open) reader: cancel() after a read() should still give that single read result`                                        | PASS    |
| `ReadableStream reader (closed before getting reader): read() multiple times should fulfill with { value: undefined, done: true }`                                  | PASS    |
| `ReadableStream reader (closed after getting reader): releasing the lock should cause closed to reject and change identity`                                         | PASS    |
| `ReadableStream reader (closed after getting reader): cancel() should return a distinct fulfilled promise each time`                                                | PASS    |
| `ReadableStream (empty) reader: releasing the lock should cause further read() calls to reject with a TypeError`                                                    | PASS    |
| `Running templatedRSEmpty with ReadableStream (empty)`                                                                                                              | PASS    |
| `ReadableStream reader (closed before getting reader): releasing the lock should cause closed to reject and change identity`                                        | PASS    |
| `ReadableStream reader (errored after getting reader): read() should reject with the error`                                                                         | PASS    |
| `ReadableStream reader (closed before getting reader): closed should fulfill with undefined`                                                                        | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: draining the stream via read() should cause the reader closed promise to fulfill, but locked stays true` | PASS    |
| `ReadableStream (closed via call in start): cancel() should return a distinct fulfilled promise each time`                                                          | PASS    |
| `ReadableStream (errored via returning a rejected promise in start) reader: read() should reject with the error`                                                    | PASS    |
| `ReadableStream (empty): instances have the correct methods and properties`                                                                                         | FAIL    |
| `ReadableStream (closed via call in start): getReader() should be OK`                                                                                               | PASS    |
| `ReadableStream reader (errored after getting reader): closed should reject with the error`                                                                         | PASS    |
| `ReadableStream (empty) reader: releasing the lock with pending read requests should throw but the read requests should stay pending`                               | PASS    |
| `Running templatedRSErroredSyncOnly with ReadableStream (errored via call in start)`                                                                                | PASS    |
| `ReadableStream (closed via cancel): locked should be false`                                                                                                        | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (sequential)`                | PASS    |
| `Running templatedRSErroredReader with ReadableStream reader (errored after getting reader)`                                                                        | PASS    |
| `ReadableStream reader (closed after getting reader): closed should fulfill with undefined`                                                                         | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: third read(), without waiting, should give { value: undefined, done: true } (nested)`                    | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): read() should fulfill with { value: undefined, done: true }`                                       | PASS    |
| `ReadableStream reader (closed before getting reader): cancel() should return a distinct fulfilled promise each time`                                               | PASS    |
| `ReadableStream reader (errored after getting reader): releasing the lock should cause closed to reject and change identity`                                        | PASS    |
| `ReadableStream (two chunks enqueued, then closed) reader: releasing the lock after the stream is closed should cause locked to become false`                       | PASS    |
| `ReadableStream (closed via cancel): getReader() should be OK`                                                                                                      | PASS    |
| `ReadableStream reader (closed before getting reader): read() should fulfill with { value: undefined, done: true }`                                                 | PASS    |
| `ReadableStream (empty) reader: releasing the lock should cause closed calls to reject with a TypeError`                                                            | PASS    |
| `ReadableStream (errored via call in start): should be able to obtain a second reader, with the correct closed promise`                                             | PASS    |
| `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`                                         | PASS    |
| `ReadableStream (closed via cancel): should not be able to acquire a second reader if we don't release the first one`                                               | PASS    |
| `ReadableStream (two chunks enqueued, still open) reader: calling read() twice without waiting will eventually give both chunks (nested)`                           | PASS    |
| `ReadableStream (empty) reader: canceling via the stream should fail`                                                                                               | PASS    |
| `ReadableStream (empty) reader: read() should never settle`                                                                                                         | PASS    |
| `ReadableStream reader (errored before getting reader): closed should reject with the error`                                                                        | PASS    |
| `ReadableStream (errored via returning a rejected promise in start): read() twice should give the error each time`                                                  | PASS    |
| `ReadableStream reader (closed via cancel after getting reader): cancel() should return a distinct fulfilled promise each time`                                     | PASS    |
| `ReadableStream reader (closed after getting reader): read() should fulfill with { value: undefined, done: true }`                                                  | PASS    |
| `ReadableStream (empty) reader: canceling via the reader should cause the reader to act closed`                                                                     | PASS    |
| `ReadableStream (errored via call in start): cancel() should return a distinct rejected promise each time`                                                          | PASS    |
| `ReadableStream (errored via call in start): should not be able to obtain additional readers if we don't release the first lock`                                    | PASS    |
| `ReadableStream (errored via returning a rejected promise in start) reader: releasing the lock should cause closed to reject and change identity`                   | PASS    |
| `ReadableStream (errored via call in start): read() twice should give the error each time`                                                                          | PASS    |
| `ReadableStream (closed via call in start): should not be able to acquire a second reader if we don't release the first one`                                        | PASS    |
| `Running templatedRSClosedReader with ReadableStream reader (closed before getting reader)`                                                                         | PASS    |
| `ReadableStream (empty) reader: read() should return distinct promises each time`                                                                                   | PASS    |
| `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-274174164

Received on Friday, 20 January 2017 20:39:40 UTC