Re: [streams-tests] Streams: test changes to the queue size calculation (#4568)

# Chrome (unstable channel) #
Testing web-platform-tests at revision bd9fd789311b447f398643abf410963f6baff10c
Using browser at version 58.0.3004.3 dev
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary><a href="http://w3c-test.org/submissions/4568/streams/writable-streams/floating-point-total-queue-size.dedicatedworker.html">/streams/writable-streams/floating-point-total-queue-size.dedicatedworker.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | TIMEOUT |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | FAIL    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | FAIL    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | FAIL    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4568/streams/readable-streams/floating-point-total-queue-size.html">/streams/readable-streams/floating-point-total-queue-size.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | OK      |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4568/streams/readable-streams/general.serviceworker.https.html">/streams/readable-streams/general.serviceworker.https.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `ReadableStream can be constructed with no errors`                                                                           | 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: desiredSize when closed`                                                                                    | FAIL    |
| `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    |
| `ReadableStream: desiredSize when errored`                                                                                   | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4568/streams/writable-streams/floating-point-total-queue-size.serviceworker.https.html">/streams/writable-streams/floating-point-total-queue-size.serviceworker.https.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | OK      |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | FAIL    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | FAIL    |
| `Service worker test setup`                                                                     | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | FAIL    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4568/streams/readable-byte-streams/general.serviceworker.https.html">/streams/readable-byte-streams/general.serviceworker.https.html</a></summary>


|                                                           Subtest                                                            | Results |
|------------------------------------------------------------------------------------------------------------------------------|---------|
|                                                                                                                              | OK      |
| `ReadableStream with byte source: Multiple read(view), close() and respond()`                                                | FAIL    |
| `ReadableStream with byte source: Throwing in pull function must error the stream`                                           | FAIL    |
| `ReadableStream with byte source: Automatic pull() after start()`                                                            | FAIL    |
| `ReadableStream with byte source: Multiple enqueue(), getReader(), then read(view)`                                          | FAIL    |
| `ReadableStream with byte source: read(view), then respond() and close() in pull()`                                          | FAIL    |
| `ReadableStream with byte source: Test that closing a stream does not release a reader automatically`                        | FAIL    |
| `ReadableStream with byte source: A stream must be errored if close()-d before fulfilling read(view) with Uint16Array`       | FAIL    |
| `ReadableStream with byte source: read(view), then respond() with a transferred ArrayBuffer`                                 | FAIL    |
| `ReadableStream with byte source: enqueue() with Uint16Array, getReader(), then read()`                                      | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view) with a smaller views`                              | FAIL    |
| `ReadableStream with byte source: enqueue(), getReader(), then read(view)`                                                   | FAIL    |
| `Service worker test setup`                                                                                                  | PASS    |
| `ReadableStream with byte source: Test that erroring a stream does not release a reader automatically`                       | FAIL    |
| `ReadableStream with byte source: Respond to pull() by enqueue()`                                                            | FAIL    |
| `ReadableStream with byte source: read() twice, then enqueue() twice`                                                        | FAIL    |
| `ReadableStreamBYOBReader constructor requires a ReadableStream with type "bytes"`                                           | FAIL    |
| `ReadableStream with byte source: releaseLock() on ReadableStreamReader with pending read() must throw`                      | FAIL    |
| `ReadableStreamBYOBReader constructor requires a ReadableStream argument`                                                    | FAIL    |
| `ReadableStream with byte source: Mix of auto allocate and BYOB`                                                             | FAIL    |
| `ReadableStream with byte source: read(view) with Uint16Array on close()-d stream with 1 byte enqueue()-d must fail`         | FAIL    |
| `ReadableStream with byte source: read(view), then respond() with too big value`                                             | FAIL    |
| `ReadableStream with byte source: read(view) with Uint32Array, then fill it by multiple respond() calls`                     | FAIL    |
| `ReadableStream with byte source: autoAllocateChunkSize`                                                                     | FAIL    |
| `ReadableStream with byte source: cancel() with partially filled pending pull() request`                                     | FAIL    |
| `ReadableStream with byte source: Construct and expect start and pull being called`                                          | FAIL    |
| `ReadableStream with byte source: read(view), then respond()`                                                                | FAIL    |
| `ReadableStream with byte source: read(view), then error()`                                                                  | FAIL    |
| `ReadableStream with byte source: read(view), but pull() function is not callable`                                           | FAIL    |
| `ReadableStream with byte source: Automatic pull() after start() and read(view)`                                             | FAIL    |
| `ReadableStreamBYOBReader can be constructed directly`                                                                       | FAIL    |
| `ReadableStream with byte source: Throwing in pull in response to read(view) must be ignored if the stream is errored in it` | 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`                                                                      | PASS    |
| `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: desiredSize when closed`                                                                   | 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(view) with passing undefined as view must fail`                                       | FAIL    |
| `ReadableStream with byte source: read() on an errored stream`                                                               | FAIL    |
| `ReadableStream with byte source: desiredSize when errored`                                                                  | 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: Push source that doesn't understand pull signal`                                           | 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: Respond to pull() by enqueue() asynchronously`                                             | 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/4568/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    |
| `desiredSize on a writer for an errored stream`                   | 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/4568/streams/readable-streams/floating-point-total-queue-size.sharedworker.html">/streams/readable-streams/floating-point-total-queue-size.sharedworker.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | TIMEOUT |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4568/streams/readable-streams/floating-point-total-queue-size.https.html">/streams/readable-streams/floating-point-total-queue-size.https.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | OK      |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | PASS    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4568/streams/readable-streams/general.sharedworker.html">/streams/readable-streams/general.sharedworker.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: desiredSize when closed`                                                                                    | FAIL    |
| `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    |
| `ReadableStream: desiredSize when errored`                                                                                   | FAIL    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4568/streams/readable-streams/floating-point-total-queue-size.dedicatedworker.html">/streams/readable-streams/floating-point-total-queue-size.dedicatedworker.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | TIMEOUT |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4568/streams/readable-streams/floating-point-total-queue-size.serviceworker.https.html">/streams/readable-streams/floating-point-total-queue-size.serviceworker.https.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | OK      |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | PASS    |
| `Service worker test setup`                                                                     | PASS    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | PASS    |

</details>
<details>
<summary><a href="https://w3c-test.org/submissions/4568/streams/writable-streams/general.serviceworker.https.html">/streams/writable-streams/general.serviceworker.https.html</a></summary>


|                              Subtest                              | Results |
|-------------------------------------------------------------------|---------|
|                                                                   | OK      |
| `closed and ready on a released writer`                           | FAIL    |
| `ws.getWriter() on an errored WritableStream`                     | FAIL    |
| `ws.getWriter() on an aborted WritableStream`                     | FAIL    |
| `WritableStream's strategy.size should not be called as a method` | FAIL    |
| `desiredSize on a writer for an errored stream`                   | 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/4568/streams/readable-streams/floating-point-total-queue-size.serviceworker.html">/streams/readable-streams/floating-point-total-queue-size.serviceworker.html</a></summary>


|           Subtest           | Results |
|-----------------------------|---------|
|                             | OK      |
| `Service worker test setup` | FAIL    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4568/streams/readable-byte-streams/general.sharedworker.html">/streams/readable-byte-streams/general.sharedworker.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(view) must be ignored if the stream is errored in it` | 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`                                                                      | PASS    |
| `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: desiredSize when closed`                                                                   | 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(view) with passing undefined as view must fail`                                       | FAIL    |
| `ReadableStream with byte source: read() on an errored stream`                                                               | FAIL    |
| `ReadableStream with byte source: desiredSize when errored`                                                                  | 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: Push source that doesn't understand pull signal`                                           | 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: Respond to pull() by enqueue() asynchronously`                                             | 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/4568/streams/readable-byte-streams/general.dedicatedworker.html">/streams/readable-byte-streams/general.dedicatedworker.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(view) must be ignored if the stream is errored in it` | 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`                                                                      | PASS    |
| `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: desiredSize when closed`                                                                   | 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(view) with passing undefined as view must fail`                                       | FAIL    |
| `ReadableStream with byte source: read() on an errored stream`                                                               | FAIL    |
| `ReadableStream with byte source: desiredSize when errored`                                                                  | 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: Push source that doesn't understand pull signal`                                           | 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: Respond to pull() by enqueue() asynchronously`                                             | 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/4568/streams/writable-streams/general.sharedworker.html">/streams/writable-streams/general.sharedworker.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    |
| `desiredSize on a writer for an errored stream`                   | 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/4568/streams/readable-streams/general.dedicatedworker.html">/streams/readable-streams/general.dedicatedworker.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: desiredSize when closed`                                                                                    | FAIL    |
| `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    |
| `ReadableStream: desiredSize when errored`                                                                                   | FAIL    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4568/streams/writable-streams/floating-point-total-queue-size.html">/streams/writable-streams/floating-point-total-queue-size.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | OK      |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | FAIL    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | FAIL    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | FAIL    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4568/streams/writable-streams/general.dedicatedworker.html">/streams/writable-streams/general.dedicatedworker.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    |
| `desiredSize on a writer for an errored stream`                   | 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/4568/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: desiredSize when closed`                                                                                    | FAIL    |
| `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    |
| `ReadableStream: desiredSize when errored`                                                                                   | FAIL    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4568/streams/writable-streams/floating-point-total-queue-size.sharedworker.html">/streams/writable-streams/floating-point-total-queue-size.sharedworker.html</a></summary>


|                                             Subtest                                             | Results |
|-------------------------------------------------------------------------------------------------|---------|
|                                                                                                 | TIMEOUT |
| `Floating point arithmetic must manifest near NUMBER.MAX_SAFE_INTEGER (total ends up positive)` | FAIL    |
| `Floating point arithmetic must manifest near 0 (total ends up positive)`                       | FAIL    |
| `Floating point arithmetic must manifest near 0 (total ends up zero)`                           | FAIL    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/4568/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(view) must be ignored if the stream is errored in it` | 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`                                                                      | PASS    |
| `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: desiredSize when closed`                                                                   | 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(view) with passing undefined as view must fail`                                       | FAIL    |
| `ReadableStream with byte source: read() on an errored stream`                                                               | FAIL    |
| `ReadableStream with byte source: desiredSize when errored`                                                                  | 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: Push source that doesn't understand pull signal`                                           | 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: Respond to pull() by enqueue() asynchronously`                                             | 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>

View on GitHub: https://github.com/w3c/web-platform-tests/pull/4568#issuecomment-279072820

Received on Friday, 10 February 2017 21:37:22 UTC