Re: [streams-tests] WritableStream: Add tests for changes in whatwg/streams#672 (#5136)

 [View the complete job log.](https://travis-ci.org/w3c/web-platform-tests/jobs/210873423)

# Chrome (unstable channel) #
Testing web-platform-tests at revision e3484233765f25134f7179c24979cd6e21d3c67e
Using browser at version 58.0.3029.14 dev
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary>8 tests ran</summary>
<details>
<summary><a href="http://w3c-test.org/submissions/5136/streams/writable-streams/aborting.dedicatedworker.html">/streams/writable-streams/aborting.dedicatedworker.html</a></summary>


|                                                                     Subtest                                                                     | Results |             Messages            |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|---------------------------------|
|                                                                                                                                                 | OK      |                                 |
| `Aborting a WritableStream before it starts should cause the writer's unsettled ready promise to reject`                                        | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one`                                        | FAIL    | `WritableStream is not defined` |
| `abort() on a released writer rejects`                                                                                                          | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream immediately prevents future writes`                                                                                  | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream prevents further writes after any that are in progress`                                                              | FAIL    | `WritableStream is not defined` |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value`                              | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects`                                                         | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects`                                                             | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects`                      | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream passes through the given reason`                                                                                     | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error`                                                   | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError`                                             | FAIL    | `WritableStream is not defined` |
| `Closing but then immediately aborting a WritableStream causes the stream to error`                                                             | FAIL    | `WritableStream is not defined` |
| `Closing a WritableStream and aborting it while it closes causes the stream to error`                                                           | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream after it is closed is a no-op`                                                                                       | FAIL    | `WritableStream is not defined` |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)`                                                   | FAIL    | `WritableStream is not defined` |
| `returning a thenable from abort() should work`                                                                                                 | FAIL    | `WritableStream is not defined` |
| `.closed should not resolve before fulfilled write()`                                                                                           | FAIL    | `WritableStream is not defined` |
| `.closed should not resolve before rejected write(); write() error should overwrite abort() error`                                              | FAIL    | `WritableStream is not defined` |
| `writes should be satisfied in order when aborting`                                                                                             | FAIL    | `WritableStream is not defined` |
| `writes should be satisfied in order after rejected write when aborting`                                                                        | FAIL    | `WritableStream is not defined` |
| `close() should use error from underlying write() on abort`                                                                                     | FAIL    | `WritableStream is not defined` |
| `underlying abort() should not be called until underlying write() completes`                                                                    | FAIL    | `WritableStream is not defined` |
| `underlying abort() should not be called if underlying close() has started`                                                                     | FAIL    | `WritableStream is not defined` |
| `if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason` | FAIL    | `WritableStream is not defined` |
| `underlying abort() should be called while closing if underlying close() has not started yet`                                                   | FAIL    | `WritableStream is not defined` |
| `if a writer is created for a stream with a pending abort, its ready should be rejected with a TypeError`                                       | FAIL    | `WritableStream is not defined` |
| `writer close() promise should resolve before abort() promise`                                                                                  | FAIL    | `WritableStream is not defined` |
| `writer.ready should reject on controller error without waiting for underlying write`                                                           | FAIL    | `WritableStream is not defined` |
| `writer.abort() while there is an in-flight write, and then finish the write with rejection`                                                    | FAIL    | `WritableStream is not defined` |
| `writer.abort(), controller.error() while there is an in-flight write, and then finish the write`                                               | FAIL    | `WritableStream is not defined` |
| `controller.error(), writer.abort() while there is an in-flight write, and then finish the write`                                               | FAIL    | `WritableStream is not defined` |
| `releaseLock() while aborting should reject the original closed promise`                                                                        | FAIL    | `WritableStream is not defined` |
| `releaseLock() during delayed async abort() should create a new rejected closed promise`                                                        | FAIL    | `WritableStream is not defined` |
| `abort() should be rejected with the error passed to controller.error() during pending write()`                                                 | FAIL    | `WritableStream is not defined` |
| `abort() should be rejected with the error passed to controller.error() during pending close()`                                                 | FAIL    | `WritableStream is not defined` |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5136/streams/writable-streams/aborting.html">/streams/writable-streams/aborting.html</a></summary>


|                                                                     Subtest                                                                     | Results |             Messages            |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|---------------------------------|
|                                                                                                                                                 | OK      |                                 |
| `Aborting a WritableStream before it starts should cause the writer's unsettled ready promise to reject`                                        | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one`                                        | FAIL    | `WritableStream is not defined` |
| `abort() on a released writer rejects`                                                                                                          | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream immediately prevents future writes`                                                                                  | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream prevents further writes after any that are in progress`                                                              | FAIL    | `WritableStream is not defined` |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value`                              | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects`                                                         | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects`                                                             | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects`                      | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream passes through the given reason`                                                                                     | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error`                                                   | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError`                                             | FAIL    | `WritableStream is not defined` |
| `Closing but then immediately aborting a WritableStream causes the stream to error`                                                             | FAIL    | `WritableStream is not defined` |
| `Closing a WritableStream and aborting it while it closes causes the stream to error`                                                           | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream after it is closed is a no-op`                                                                                       | FAIL    | `WritableStream is not defined` |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)`                                                   | FAIL    | `WritableStream is not defined` |
| `returning a thenable from abort() should work`                                                                                                 | FAIL    | `WritableStream is not defined` |
| `.closed should not resolve before fulfilled write()`                                                                                           | FAIL    | `WritableStream is not defined` |
| `.closed should not resolve before rejected write(); write() error should overwrite abort() error`                                              | FAIL    | `WritableStream is not defined` |
| `writes should be satisfied in order when aborting`                                                                                             | FAIL    | `WritableStream is not defined` |
| `writes should be satisfied in order after rejected write when aborting`                                                                        | FAIL    | `WritableStream is not defined` |
| `close() should use error from underlying write() on abort`                                                                                     | FAIL    | `WritableStream is not defined` |
| `underlying abort() should not be called until underlying write() completes`                                                                    | FAIL    | `WritableStream is not defined` |
| `underlying abort() should not be called if underlying close() has started`                                                                     | FAIL    | `WritableStream is not defined` |
| `if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason` | FAIL    | `WritableStream is not defined` |
| `underlying abort() should be called while closing if underlying close() has not started yet`                                                   | FAIL    | `WritableStream is not defined` |
| `if a writer is created for a stream with a pending abort, its ready should be rejected with a TypeError`                                       | FAIL    | `WritableStream is not defined` |
| `writer close() promise should resolve before abort() promise`                                                                                  | FAIL    | `WritableStream is not defined` |
| `writer.ready should reject on controller error without waiting for underlying write`                                                           | FAIL    | `WritableStream is not defined` |
| `writer.abort() while there is an in-flight write, and then finish the write with rejection`                                                    | FAIL    | `WritableStream is not defined` |
| `writer.abort(), controller.error() while there is an in-flight write, and then finish the write`                                               | FAIL    | `WritableStream is not defined` |
| `controller.error(), writer.abort() while there is an in-flight write, and then finish the write`                                               | FAIL    | `WritableStream is not defined` |
| `releaseLock() while aborting should reject the original closed promise`                                                                        | FAIL    | `WritableStream is not defined` |
| `releaseLock() during delayed async abort() should create a new rejected closed promise`                                                        | FAIL    | `WritableStream is not defined` |
| `abort() should be rejected with the error passed to controller.error() during pending write()`                                                 | FAIL    | `WritableStream is not defined` |
| `abort() should be rejected with the error passed to controller.error() during pending close()`                                                 | FAIL    | `WritableStream is not defined` |

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


|                                                                     Subtest                                                                     | Results |             Messages            |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|---------------------------------|
|                                                                                                                                                 | OK      |                                 |
| `Service worker test setup`                                                                                                                     | PASS    |                                 |
| `Aborting a WritableStream before it starts should cause the writer's unsettled ready promise to reject`                                        | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one`                                        | FAIL    | `WritableStream is not defined` |
| `abort() on a released writer rejects`                                                                                                          | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream immediately prevents future writes`                                                                                  | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream prevents further writes after any that are in progress`                                                              | FAIL    | `WritableStream is not defined` |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value`                              | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects`                                                         | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects`                                                             | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects`                      | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream passes through the given reason`                                                                                     | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error`                                                   | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError`                                             | FAIL    | `WritableStream is not defined` |
| `Closing but then immediately aborting a WritableStream causes the stream to error`                                                             | FAIL    | `WritableStream is not defined` |
| `Closing a WritableStream and aborting it while it closes causes the stream to error`                                                           | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream after it is closed is a no-op`                                                                                       | FAIL    | `WritableStream is not defined` |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)`                                                   | FAIL    | `WritableStream is not defined` |
| `returning a thenable from abort() should work`                                                                                                 | FAIL    | `WritableStream is not defined` |
| `.closed should not resolve before fulfilled write()`                                                                                           | FAIL    | `WritableStream is not defined` |
| `.closed should not resolve before rejected write(); write() error should overwrite abort() error`                                              | FAIL    | `WritableStream is not defined` |
| `writes should be satisfied in order when aborting`                                                                                             | FAIL    | `WritableStream is not defined` |
| `writes should be satisfied in order after rejected write when aborting`                                                                        | FAIL    | `WritableStream is not defined` |
| `close() should use error from underlying write() on abort`                                                                                     | FAIL    | `WritableStream is not defined` |
| `underlying abort() should not be called until underlying write() completes`                                                                    | FAIL    | `WritableStream is not defined` |
| `underlying abort() should not be called if underlying close() has started`                                                                     | FAIL    | `WritableStream is not defined` |
| `if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason` | FAIL    | `WritableStream is not defined` |
| `underlying abort() should be called while closing if underlying close() has not started yet`                                                   | FAIL    | `WritableStream is not defined` |
| `if a writer is created for a stream with a pending abort, its ready should be rejected with a TypeError`                                       | FAIL    | `WritableStream is not defined` |
| `writer close() promise should resolve before abort() promise`                                                                                  | FAIL    | `WritableStream is not defined` |
| `writer.ready should reject on controller error without waiting for underlying write`                                                           | FAIL    | `WritableStream is not defined` |
| `writer.abort() while there is an in-flight write, and then finish the write with rejection`                                                    | FAIL    | `WritableStream is not defined` |
| `writer.abort(), controller.error() while there is an in-flight write, and then finish the write`                                               | FAIL    | `WritableStream is not defined` |
| `controller.error(), writer.abort() while there is an in-flight write, and then finish the write`                                               | FAIL    | `WritableStream is not defined` |
| `releaseLock() while aborting should reject the original closed promise`                                                                        | FAIL    | `WritableStream is not defined` |
| `releaseLock() during delayed async abort() should create a new rejected closed promise`                                                        | FAIL    | `WritableStream is not defined` |
| `abort() should be rejected with the error passed to controller.error() during pending write()`                                                 | FAIL    | `WritableStream is not defined` |
| `abort() should be rejected with the error passed to controller.error() during pending close()`                                                 | FAIL    | `WritableStream is not defined` |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5136/streams/writable-streams/aborting.sharedworker.html">/streams/writable-streams/aborting.sharedworker.html</a></summary>


|                                                                     Subtest                                                                     | Results |             Messages            |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|---------------------------------|
|                                                                                                                                                 | OK      |                                 |
| `Aborting a WritableStream before it starts should cause the writer's unsettled ready promise to reject`                                        | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one`                                        | FAIL    | `WritableStream is not defined` |
| `abort() on a released writer rejects`                                                                                                          | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream immediately prevents future writes`                                                                                  | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream prevents further writes after any that are in progress`                                                              | FAIL    | `WritableStream is not defined` |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value`                              | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects`                                                         | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects`                                                             | FAIL    | `WritableStream is not defined` |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects`                      | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream passes through the given reason`                                                                                     | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error`                                                   | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError`                                             | FAIL    | `WritableStream is not defined` |
| `Closing but then immediately aborting a WritableStream causes the stream to error`                                                             | FAIL    | `WritableStream is not defined` |
| `Closing a WritableStream and aborting it while it closes causes the stream to error`                                                           | FAIL    | `WritableStream is not defined` |
| `Aborting a WritableStream after it is closed is a no-op`                                                                                       | FAIL    | `WritableStream is not defined` |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)`                                                   | FAIL    | `WritableStream is not defined` |
| `returning a thenable from abort() should work`                                                                                                 | FAIL    | `WritableStream is not defined` |
| `.closed should not resolve before fulfilled write()`                                                                                           | FAIL    | `WritableStream is not defined` |
| `.closed should not resolve before rejected write(); write() error should overwrite abort() error`                                              | FAIL    | `WritableStream is not defined` |
| `writes should be satisfied in order when aborting`                                                                                             | FAIL    | `WritableStream is not defined` |
| `writes should be satisfied in order after rejected write when aborting`                                                                        | FAIL    | `WritableStream is not defined` |
| `close() should use error from underlying write() on abort`                                                                                     | FAIL    | `WritableStream is not defined` |
| `underlying abort() should not be called until underlying write() completes`                                                                    | FAIL    | `WritableStream is not defined` |
| `underlying abort() should not be called if underlying close() has started`                                                                     | FAIL    | `WritableStream is not defined` |
| `if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason` | FAIL    | `WritableStream is not defined` |
| `underlying abort() should be called while closing if underlying close() has not started yet`                                                   | FAIL    | `WritableStream is not defined` |
| `if a writer is created for a stream with a pending abort, its ready should be rejected with a TypeError`                                       | FAIL    | `WritableStream is not defined` |
| `writer close() promise should resolve before abort() promise`                                                                                  | FAIL    | `WritableStream is not defined` |
| `writer.ready should reject on controller error without waiting for underlying write`                                                           | FAIL    | `WritableStream is not defined` |
| `writer.abort() while there is an in-flight write, and then finish the write with rejection`                                                    | FAIL    | `WritableStream is not defined` |
| `writer.abort(), controller.error() while there is an in-flight write, and then finish the write`                                               | FAIL    | `WritableStream is not defined` |
| `controller.error(), writer.abort() while there is an in-flight write, and then finish the write`                                               | FAIL    | `WritableStream is not defined` |
| `releaseLock() while aborting should reject the original closed promise`                                                                        | FAIL    | `WritableStream is not defined` |
| `releaseLock() during delayed async abort() should create a new rejected closed promise`                                                        | FAIL    | `WritableStream is not defined` |
| `abort() should be rejected with the error passed to controller.error() during pending write()`                                                 | FAIL    | `WritableStream is not defined` |
| `abort() should be rejected with the error passed to controller.error() during pending close()`                                                 | FAIL    | `WritableStream is not defined` |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5136/streams/writable-streams/general.dedicatedworker.html">/streams/writable-streams/general.dedicatedworker.html</a></summary>


|                              Subtest                              | Results |             Messages            |
|-------------------------------------------------------------------|---------|---------------------------------|
|                                                                   | OK      |                                 |
| `desiredSize on a released writer`                                | FAIL    | `WritableStream is not defined` |
| `desiredSize initial value`                                       | FAIL    | `WritableStream is not defined` |
| `desiredSize on a writer for a closed stream`                     | FAIL    | `WritableStream is not defined` |
| `desiredSize on a writer for an errored stream`                   | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on a closing WritableStream`                      | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on a closed WritableStream`                       | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on an aborted WritableStream`                     | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on an errored WritableStream`                     | FAIL    | `WritableStream is not defined` |
| `closed and ready on a released writer`                           | FAIL    | `WritableStream is not defined` |
| `WritableStream should call underlying sink methods as methods`   | FAIL    | `WritableStream is not defined` |
| `methods should not not have .apply() or .call() called`          | FAIL    | `WritableStream is not defined` |
| `WritableStream's strategy.size should not be called as a method` | FAIL    | `WritableStream is not defined` |
| `redundant releaseLock() is no-op`                                | FAIL    | `WritableStream is not defined` |
| `ready promise should fire before closed on releaseLock`          | FAIL    | `WritableStream is not defined` |

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


|                              Subtest                              | Results |             Messages            |
|-------------------------------------------------------------------|---------|---------------------------------|
|                                                                   | OK      |                                 |
| `desiredSize on a released writer`                                | FAIL    | `WritableStream is not defined` |
| `desiredSize initial value`                                       | FAIL    | `WritableStream is not defined` |
| `desiredSize on a writer for a closed stream`                     | FAIL    | `WritableStream is not defined` |
| `desiredSize on a writer for an errored stream`                   | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on a closing WritableStream`                      | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on a closed WritableStream`                       | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on an aborted WritableStream`                     | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on an errored WritableStream`                     | FAIL    | `WritableStream is not defined` |
| `closed and ready on a released writer`                           | FAIL    | `WritableStream is not defined` |
| `WritableStream should call underlying sink methods as methods`   | FAIL    | `WritableStream is not defined` |
| `methods should not not have .apply() or .call() called`          | FAIL    | `WritableStream is not defined` |
| `WritableStream's strategy.size should not be called as a method` | FAIL    | `WritableStream is not defined` |
| `redundant releaseLock() is no-op`                                | FAIL    | `WritableStream is not defined` |
| `ready promise should fire before closed on releaseLock`          | FAIL    | `WritableStream is not defined` |

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


|                              Subtest                              | Results |             Messages            |
|-------------------------------------------------------------------|---------|---------------------------------|
|                                                                   | OK      |                                 |
| `Service worker test setup`                                       | PASS    |                                 |
| `desiredSize on a released writer`                                | FAIL    | `WritableStream is not defined` |
| `desiredSize initial value`                                       | FAIL    | `WritableStream is not defined` |
| `desiredSize on a writer for a closed stream`                     | FAIL    | `WritableStream is not defined` |
| `desiredSize on a writer for an errored stream`                   | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on a closing WritableStream`                      | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on a closed WritableStream`                       | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on an aborted WritableStream`                     | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on an errored WritableStream`                     | FAIL    | `WritableStream is not defined` |
| `closed and ready on a released writer`                           | FAIL    | `WritableStream is not defined` |
| `WritableStream should call underlying sink methods as methods`   | FAIL    | `WritableStream is not defined` |
| `methods should not not have .apply() or .call() called`          | FAIL    | `WritableStream is not defined` |
| `WritableStream's strategy.size should not be called as a method` | FAIL    | `WritableStream is not defined` |
| `redundant releaseLock() is no-op`                                | FAIL    | `WritableStream is not defined` |
| `ready promise should fire before closed on releaseLock`          | FAIL    | `WritableStream is not defined` |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5136/streams/writable-streams/general.sharedworker.html">/streams/writable-streams/general.sharedworker.html</a></summary>


|                              Subtest                              | Results |             Messages            |
|-------------------------------------------------------------------|---------|---------------------------------|
|                                                                   | OK      |                                 |
| `desiredSize on a released writer`                                | FAIL    | `WritableStream is not defined` |
| `desiredSize initial value`                                       | FAIL    | `WritableStream is not defined` |
| `desiredSize on a writer for a closed stream`                     | FAIL    | `WritableStream is not defined` |
| `desiredSize on a writer for an errored stream`                   | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on a closing WritableStream`                      | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on a closed WritableStream`                       | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on an aborted WritableStream`                     | FAIL    | `WritableStream is not defined` |
| `ws.getWriter() on an errored WritableStream`                     | FAIL    | `WritableStream is not defined` |
| `closed and ready on a released writer`                           | FAIL    | `WritableStream is not defined` |
| `WritableStream should call underlying sink methods as methods`   | FAIL    | `WritableStream is not defined` |
| `methods should not not have .apply() or .call() called`          | FAIL    | `WritableStream is not defined` |
| `WritableStream's strategy.size should not be called as a method` | FAIL    | `WritableStream is not defined` |
| `redundant releaseLock() is no-op`                                | FAIL    | `WritableStream is not defined` |
| `ready promise should fire before closed on releaseLock`          | FAIL    | `WritableStream is not defined` |

</details>
</details>

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

Received on Tuesday, 14 March 2017 09:26:17 UTC