- From: W3C commit bot <web-platform-tests-notifications@w3.org>
- Date: Fri, 14 Apr 2017 08:02:13 GMT
- To: public-web-platform-tests-notifications@w3.org
*This report has been truncated because the total content is 65780 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/221998916)
# Chrome (unstable channel) #
Testing web-platform-tests at revision f6220649970e75730ab8c34223eeb9d7193c7bc3
Using browser at version 59.0.3067.0 dev
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary>4 tests ran</summary>
<details>
<summary><a href="http://w3c-test.org/submissions/5564/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/5564/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() 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="https://w3c-test.org/submissions/5564/streams/writable-streams/aborting.serviceworker.https.html">/streams/writable-streams/aborting.serviceworker.https.html</a></summary>
| Subtest | Results | Messages |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| | ERROR | |
| `Service worker test setup` | PASS | |
| `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 | `{}`
View on GitHub: https://github.com/w3c/web-platform-tests/pull/5564#issuecomment-294111785
Received on Friday, 14 April 2017 08:02:26 UTC