- From: W3C commit bot <web-platform-tests-notifications@w3.org>
- Date: Fri, 07 Apr 2017 11:30:28 GMT
- To: public-web-platform-tests-notifications@w3.org
*This report has been truncated because the total content is 203364 characters in length, which is in excess of GitHub.com's limit for comments (65536 characters).
[View the complete job log.](https://travis-ci.org/w3c/web-platform-tests/jobs/219642491)
# Chrome (unstable channel) #
Testing web-platform-tests at revision 9980a0dd08b15e3b8b9a1ddaa9fe13e82864dec7
Using browser at version 59.0.3063.4 dev
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary>34 tests ran</summary>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/piping/close-propagation-backward.html">/streams/piping/close-propagation-backward.html</a></summary>
| Subtest | Results | Messages |
|----------------------------------------------------------------------------------------------------------------------|---------|-------------------------------|
| | OK | |
| `Closing must be propagated backward: starts closed; preventCancel omitted; fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel omitted; rejected cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = undefined (falsy); fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = null (falsy); fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = false (falsy); fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = 0 (falsy); fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = -0 (falsy); fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = NaN (falsy); fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = (falsy); fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = true (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = a (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = 1 (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = Symbol() (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = [object Object] (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = true, preventAbort = true` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated backward: starts closed; preventCancel = true, preventAbort = true, preventClose = true` | FAIL | `rs.pipeTo is not a function` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/piping/close-propagation-forward.html">/streams/piping/close-propagation-forward.html</a></summary>
| Subtest | Results | Messages |
|-----------------------------------------------------------------------------------------------------------------------------------------------|---------|-------------------------------|
| | OK | |
| `Closing must be propagated forward: starts closed; preventClose omitted; fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose omitted; rejected close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = undefined (falsy); fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = null (falsy); fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = false (falsy); fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = 0 (falsy); fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = -0 (falsy); fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = NaN (falsy); fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = (falsy); fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = true (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = a (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = 1 (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = Symbol() (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = [object Object] (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = true, preventAbort = true` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: starts closed; preventClose = true, preventAbort = true, preventCancel = true` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose omitted; fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose omitted; rejected close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed asynchronously; preventClose = true` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose omitted; fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose omitted; rejected close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed asynchronously; dest never desires chunks; preventClose = true` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose omitted; fulfilled close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose omitted; rejected close promise` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: becomes closed after one chunk; preventClose = true` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: shutdown must not occur until the final write completes` | FAIL | `rs.pipeTo is not a function` |
| `Closing must be propagated forward: shutdown must not occur until the final write completes; preventClose = true` | FAIL | `rs.pipeTo is not a function` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/piping/error-propagation-backward.html">/streams/piping/error-propagation-backward.html</a></summary>
| Subtest | Results | Messages |
|------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-------------------------------------------------------------------------------------------------|
| | OK | |
| `Errors must be propagated backward: starts errored; preventCancel omitted; fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel omitted; fulfilled cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel omitted; rejected cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = undefined (falsy); fulfilled cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = null (falsy); fulfilled cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = false (falsy); fulfilled cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = 0 (falsy); fulfilled cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = -0 (falsy); fulfilled cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = NaN (falsy); fulfilled cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = (falsy); fulfilled cancel promise` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = true (truthy)` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = a (truthy)` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = 1 (truthy)` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = Symbol() (truthy)` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = [object Object] (truthy)` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write, preventCancel = true; preventAbort = true` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored before piping due to write; preventCancel = true, preventAbort = true, preventClose = true` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel omitted; fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel omitted; rejected cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored during piping due to write; preventCancel = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = false; fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = false; rejected cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored during piping due to write, but async; preventCancel = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored after piping; preventCancel omitted; fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored after piping; preventCancel omitted; rejected cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored after piping; preventCancel = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored after piping due to last write; source is closed; preventCancel omitted (but cancel is never called)` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored after piping due to last write; source is closed; preventCancel = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = false; fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = false; rejected cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored after piping; dest never desires chunks; preventCancel = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel omitted; fulfilled cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel omitted; rejected cancel promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: becomes errored before piping via abort; preventCancel = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated backward: erroring via the controller errors once pending write completes` | FAIL | `rs.pipeTo is not a function` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/piping/error-propagation-forward.html">/streams/piping/error-propagation-forward.html</a></summary>
| Subtest | Results | Messages |
|------------------------------------------------------------------------------------------------------------------------------------------------|---------|-------------------------------|
| | OK | |
| `Errors must be propagated forward: starts errored; preventAbort = false; fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = false; rejected abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = undefined (falsy); fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = null (falsy); fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = false (falsy); fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = 0 (falsy); fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = -0 (falsy); fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = NaN (falsy); fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = (falsy); fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = true (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = a (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = 1 (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = Symbol() (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = [object Object] (truthy)` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = true, preventCancel = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: starts errored; preventAbort = true, preventCancel = true, preventClose = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = false; fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = false; rejected abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored while empty; preventAbort = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = false; fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = false; rejected abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored while empty; dest never desires chunks; preventAbort = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = false; fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = false; rejected abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored after one chunk; preventAbort = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = false; fulfilled abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = false; rejected abort promise` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: becomes errored after one chunk; dest never desires chunks; preventAbort = true` | FAIL | `rs.pipeTo is not a function` |
| `Errors must be propagated forward: shutdown must not occur until the final write completes` | FAIL | `rs.pipeTo is not a function` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/piping/flow-control.html">/streams/piping/flow-control.html</a></summary>
| Subtest | Results | Messages |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-------------------------------------------------------------------------------------------------|
| | OK | |
| `Piping from a non-empty ReadableStream into a WritableStream that does not desire chunks` | FAIL | `rs.pipeTo is not a function` |
| `Piping from a non-empty ReadableStream into a WritableStream that does not desire chunks, but then does` | FAIL | `rs.pipeTo is not a function` |
| `Piping from an empty ReadableStream into a WritableStream that does not desire chunks, but then the readable stream becomes non-empty and the writable stream starts desiring chunks` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Piping from a ReadableStream to a WritableStream that desires more chunks before finishing with previous ones` | FAIL | `rs.pipeTo is not a function` |
| `Piping to a WritableStream that does not consume the writes fast enough exerts backpressure on the ReadableStream` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/piping/general.html">/streams/piping/general.html</a></summary>
| Subtest | Results | Messages |
|---------------------------------------------------------------------------------------------------|---------|---------------------------------------------|
| | OK | |
| `Piping must lock both the ReadableStream and WritableStream` | FAIL | `rs.pipeTo is not a function` |
| `Piping finishing must unlock both the ReadableStream and WritableStream` | FAIL | `rs.pipeTo is not a function` |
| `pipeTo must check the brand of its ReadableStream this value` | FAIL | `Cannot read property 'apply' of undefined` |
| `pipeTo must check the brand of its WritableStream argument` | FAIL | `Cannot read property 'apply' of undefined` |
| `pipeTo must fail if the ReadableStream is locked, and not lock the WritableStream` | FAIL | `rs.pipeTo is not a function` |
| `pipeTo must fail if the WritableStream is locked, and not lock the ReadableStream` | FAIL | `rs.pipeTo is not a function` |
| `Piping from a ReadableStream from which lots of chunks are synchronously readable` | FAIL | `rs.pipeTo is not a function` |
| `Piping from a ReadableStream for which a chunk becomes asynchronously readable after the pipeTo` | FAIL | `rs.pipeTo is not a function` |
| `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is true` | FAIL | `rs.pipeTo is not a function` |
| `an undefined rejection from pull should cause pipeTo() to reject when preventAbort is false` | FAIL | `rs.pipeTo is not a function` |
| `an undefined rejection from write should cause pipeTo() to reject when preventCancel is true` | FAIL | `rs.pipeTo is not a function` |
| `an undefined rejection from write should cause pipeTo() to reject when preventCancel is false` | FAIL | `rs.pipeTo is not a function` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/piping/multiple-propagation.html">/streams/piping/multiple-propagation.html</a></summary>
| Subtest | Results | Messages |
|---------------------------------------------------------------------------------------------|---------|-------------------------------------------------------------------------------------------------|
| | OK | |
| `Piping from an errored readable stream to an errored writable stream` | FAIL | `rs.pipeTo is not a function` |
| `Piping from an errored readable stream to an errored writable stream; preventAbort = true` | FAIL | `rs.pipeTo is not a function` |
| `Piping from an errored readable stream to a closing writable stream` | FAIL | `rs.pipeTo is not a function` |
| `Piping from an errored readable stream to a closed writable stream` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: rs.pipeTo is not a function"` |
| `Piping from a closed readable stream to an errored writable stream` | FAIL | `rs.pipeTo is not a function` |
| `Piping from a closed readable stream to a closed writable stream` | FAIL | `rs.pipeTo is not a function` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/writable-streams/aborting.dedicatedworker.html">/streams/writable-streams/aborting.dedicatedworker.html</a></summary>
| Subtest | Results | Messages |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| | ERROR | |
| `Aborting a WritableStream before it starts should cause the writer's unsettled ready promise to reject` | PASS | `{}` |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one` | PASS | `{}` |
| `abort() on a released writer rejects` | PASS | `{}` |
| `Aborting a WritableStream immediately prevents future writes` | PASS | `{}` |
| `Aborting a WritableStream prevents further writes after any that are in progress` | PASS | `{}` |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value` | PASS | `{}` |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects` | PASS | `{}` |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects` | PASS | `{}` |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects` | PASS | `{}` |
| `Aborting a WritableStream passes through the given reason` | PASS | `{}` |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error` | PASS | `{}` |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError` | PASS | `{}` |
| `Closing but then immediately aborting a WritableStream causes the stream to error` | PASS | `{}` |
| `Closing a WritableStream and aborting it while it closes causes the stream to ignore the abort attempt` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: The stream has been aborted"` |
| `Aborting a WritableStream after it is closed is a no-op` | PASS | `{}` |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)` | PASS | `{}` |
| `returning a thenable from abort() should work` | PASS | `{}` |
| `.closed should not resolve before fulfilled write()` | PASS | `{}` |
| `.closed should not resolve before rejected write(); write() error should not overwrite abort() error` | FAIL | `promise_test: Unhandled rejection with value: object "error1: error1"` |
| `writes should be satisfied in order when aborting` | PASS | `{}` |
| `writes should be satisfied in order after rejected write when aborting` | FAIL | `promise_test: Unhandled rejection with value: object "error1: error1"` |
| `close() should reject with TypeError when abort() is first error` | FAIL | `promise_test: Unhandled rejection with value: object "error1: error1"` |
| `underlying abort() should not be called until underlying write() completes` | PASS | `{}` |
| `underlying abort() should not be called if underlying close() has started` | PASS | `{}` |
| `if underlying close() has started and then rejects, the abort() and close() promises should reject with the underlying close rejection reason` | PASS | `{}` |
| `an abort() that happens during a write() should trigger the underlying abort() even with a close() queued` | PASS | `{}` |
| `if a writer is created for a stream with a pending abort, its ready should be rejected with a TypeError` | FAIL | `assert_unreached: Should have rejected: ready of the second writer should be rejected with a TypeError Reached unreachable code` |
| `writer close() promise should resolve before abort() promise` | PASS | `{}` |
| `writer.ready should reject on controller error without waiting for underlying write` | PASS | `{}` |
| `writer.abort() while there is an in-flight write, and then finish the write with rejection` | FAIL | `promise_test: Unhandled rejection with value: object "error2: error2"` |
| `writer.abort(), controller.error() while there is an in-flight write, and then finish the write` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: Cannot error a errored writable stream"` |
| `writer.abort(), controller.error() while there is an in-flight close, and then finish the close` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: Cannot error a errored writable stream"` |
| `controller.error(), writer.abort() while there is an in-flight write, and then finish the write` | FAIL | `assert_throws: writePromise2 must reject with the error passed to the controller's error method function "function () { throw e }" threw object "TypeError: Cannot write to a errored writable stream" ("TypeError") expected object "error2: error2" ("error2")` |
| `controller.error(), writer.abort() while there is an in-flight close, and then finish the close` | FAIL | `promise_test: Unhandled rejection with value: object "error2: error2"` |
| `releaseLock() while aborting should reject the original closed promise` | PASS | `{}` |
| `releaseLock() during delayed async abort() should reject the writer.closed promise` | FAIL | `assert_equals: closed promise should not have changed expected object "[object Promise]" but got object "[object Promise]"` |
| `sink abort() should not be called until sink start() is done` | FAIL | `assert_array_equals: abort() should not be called during start() lengths differ, expected 0 got 2` |
| `if start attempts to error the controller after abort() has been called, then it should lose` | FAIL | `Cannot error a errored writable stream` |
| `stream abort() promise should still resolve if sink start() rejects` | PASS | `{}` |
| `writer abort() during sink start() should replace the writer.ready promise synchronously` | PASS | `{}` |
| `promises returned from other writer methods should be rejected when writer abort() happens during sink start()` | FAIL | `assert_array_equals: promises should resolve in the standard order property 0, expected "write2" but got "write1"` |
| `abort() should succeed despite rejection from write` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: Cannot error a errored writable stream"` |
| `abort() should be rejected with the rejection returned from close()` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: Cannot error a errored writable stream"` |
| `a rejecting sink.write() should not prevent sink.abort() from being called` | FAIL | `promise_test: Unhandled rejection with value: object "error1: error1"` |
| `when start errors after stream abort(), underlying sink abort() should be called anyway` | PASS | `{}` |
| `when calling abort() twice on the same stream, the second call should reject` | PASS | `{}` |
| `sink abort() should not be called if stream was erroring due to controller.error() before abort() was called` | PASS | `{}` |
| `sink abort() should not be called if stream was erroring due to bad strategy before abort() was called` | PASS | `{}` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5421/streams/writable-streams/aborting.html">/streams/writable-streams/aborting.html</a></summary>
| Subtest | Results | Messages |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| | ERROR | |
| `Aborting a WritableStream before it starts should cause the writer's unsettled ready promise to reject` | PASS | |
| `Aborting a WritableStream should cause the writer's fulfilled ready promise to reset to a rejected one` | PASS | |
| `abort() on a released writer rejects` | PASS | |
| `Aborting a WritableStream immediately prevents future writes` | PASS | |
| `Aborting a WritableStream prevents further writes after any that are in progress` | PASS | |
| `Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value` | PASS | |
| `WritableStream if sink's abort throws, the promise returned by writer.abort() rejects` | PASS | |
| `WritableStream if sink's abort throws, the promise returned by ws.abort() rejects` | PASS | |
| `WritableStream if sink's abort throws, for an abort performed during a write, the promise returned by ws.abort() rejects` | PASS | |
| `Aborting a WritableStream passes through the given reason` | PASS | |
| `Aborting a WritableStream puts it in an errored state, with a TypeError as the stored error` | PASS | |
| `Aborting a WritableStream causes any outstanding write() promises to be rejected with a TypeError` | PASS | |
| `Closing but then immediately aborting a WritableStream causes the stream to error` | PASS | |
| `Closing a WritableStream and aborting it while it closes causes the stream to ignore the abort attempt` | FAIL | `promise_test: Unhandled rejection with value: object "TypeError: The stream has been aborted"` |
| `Aborting a WritableStream after it is closed is a no-op` | PASS | |
| `WritableStream should NOT call underlying sink's close if no abort is supplied (historical)` | PASS | |
| `returning a thenable from abort() should work` | PASS | |
| `.closed should not resolve before fulfilled write()` | PASS | |
| `.closed should not resolve before rejected write(); write() error should not overwrite abort() error` | FAIL | `promise_test: Unhandled rejection with value: object "error1: error1"` |
| `writes should be satisfied in order when aborting` | PASS | |
| `writes should be satisfied in order after rejected write when aborting` | FAIL | `promise_test: Unhandled rejection with value: object "error1: error1"` |
| `close() should reject with TypeError when abort() is first error` | FAIL | `promise_test: Unhandled rejection with value: object "error1: error1"` |
| `underlying abort() should not be called until underlying write()
View on GitHub: https://github.com/w3c/web-platform-tests/pull/5421#issuecomment-292513314
Received on Friday, 7 April 2017 11:30:43 UTC