- From: W3C commit bot <web-platform-tests-notifications@w3.org>
- Date: Tue, 28 Mar 2017 09:06:29 GMT
- To: public-web-platform-tests-notifications@w3.org
*This report has been truncated because the total content is 89281 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/215857442)
# Firefox (nightly channel) #
Testing web-platform-tests at revision 3e7e4f01b5a40ac585f6039555b76b26b09b1dec
Using browser at version BuildID 20170327110256; SourceStamp 9577ddeaafd85554c2a855f385a87472a089d5c0
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary>16 tests ran</summary>
<details>
<summary><a href="http://w3c-test.org/submissions/5240/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 ignore the abort attempt` | 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` |
| `sink abort() should not be called until sink start() is done` | FAIL | `WritableStream is not defined` |
| `abort() promise should reject if start() errors the controller` | FAIL | `WritableStream is not defined` |
| `stream abort() promise should reject if sink start() rejects` | FAIL | `WritableStream is not defined` |
| `writer abort() during sink start() should replace the writer.ready promise synchronously` | FAIL | `WritableStream is not defined` |
| `promises returned from other writer methods should be rejected when writer abort() happens during sink start()` | 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/5240/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 ignore the abort attempt` | 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` |
| `sink abort() should not be called until sink start() is done` | FAIL | `WritableStream is not defined` |
| `abort() promise should reject if start() errors the controller` | FAIL | `WritableStream is not defined` |
| `stream abort() promise should reject if sink start() rejects` | FAIL | `WritableStream is not defined` |
| `writer abort() during sink start() should replace the writer.ready promise synchronously` | FAIL | `WritableStream is not defined` |
| `promises returned from other writer methods should be rejected when writer abort() happens during sink start()` | 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/5240/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 ignore the abort attempt` | 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` |
| `sink abort() should not be called until sink start() is done` | FAIL | `WritableStream is not defined` |
| `abort() promise should reject if start() errors the controller` | FAIL | `WritableStream is not defined` |
| `stream abort() promise should reject if sink start() rejects` | FAIL | `WritableStream is not defined` |
| `writer abort() during sink start() should replace the writer.ready promise synchronously` | FAIL | `WritableStream is not defined` |
| `promises returned from other writer methods should be rejected when writer abort() happens during sink start()` | 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/5240/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 ignore the abort attempt` | 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` |
| `sink abort() should not be called until sink start() is done` | FAIL | `WritableStream is not defined` |
| `abort() promise should reject if start() errors the controller` | FAIL | `WritableStream is not defined` |
| `stream abort() promise should reject if sink start() rejects` | FAIL | `WritableStream is not defined` |
| `writer abort() during sink start() should replace the writer.ready promise synchronously` | FAIL | `WritableStream is not defined` |
| `promises returned from other writer methods should be rejected when writer abort() happens during sink start()` | 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/5240/streams/writable-streams/bad-strategies.dedicatedworker.html">/streams/writable-streams/bad-strategies.dedicatedworker.html</a></summary>
| Subtest | Results | Messages |
|-----------------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| | OK | |
| `Writable stream: throwing strategy.size getter` | FAIL | `assert_throws: construction should re-throw the error function "() => {\n new WritableStream({}, {\n get size() {\n throw error1;\n },\n highWaterMark: 5\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "error1: a unique string" ("error1")` |
| `reject any non-function value for strategy.size` | FAIL | `assert_throws: function "() => {\n new WritableStream({}, { size: 'a string' });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")` |
| `Writable stream: throwing strategy.highWaterMark getter` | FAIL | `assert_throws: construction should re-throw the error function "() => {\n new WritableStream({}, {\n size() {\n return 1;\n },\n get highWaterMark() {\n throw error1;\n }\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "error1: a unique string" ("error1")` |
| `Writable stream: invalid strategy.highWaterMark` | FAIL | `assert_throws: construction should throw a RangeError for -1 function "() => {\n new WritableStream({}, {\n size() {\n return 1;\n },\n highWaterMark\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "RangeError" ("RangeError")` |
| `Writable stream: throwing strategy.size method` | FAIL | `WritableStream is not defined` |
| `Writable stream: invalid strategy.size return value` | FAIL | `WritableStream is not defined` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5240/streams/writable-streams/bad-strategies.html">/streams/writable-streams/bad-strategies.html</a></summary>
| Subtest | Results | Messages |
|-----------------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| | OK | |
| `Writable stream: throwing strategy.size getter` | FAIL | `assert_throws: construction should re-throw the error function "() => {\n new WritableStream({}, {\n get size() {\n throw error1;\n },\n highWaterMark: 5\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "error1: a unique string" ("error1")` |
| `reject any non-function value for strategy.size` | FAIL | `assert_throws: function "() => {\n new WritableStream({}, { size: 'a string' });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")` |
| `Writable stream: throwing strategy.highWaterMark getter` | FAIL | `assert_throws: construction should re-throw the error function "() => {\n new WritableStream({}, {\n size() {\n return 1;\n },\n get highWaterMark() {\n throw error1;\n }\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "error1: a unique string" ("error1")` |
| `Writable stream: invalid strategy.highWaterMark` | FAIL | `assert_throws: construction should throw a RangeError for -1 function "() => {\n new WritableStream({}, {\n size() {\n return 1;\n },\n highWaterMark\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "RangeError" ("RangeError")` |
| `Writable stream: throwing strategy.size method` | FAIL | `WritableStream is not defined` |
| `Writable stream: invalid strategy.size return value` | FAIL | `WritableStream is not defined` |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/5240/streams/writable-streams/bad-strategies.serviceworker.https.html">/streams/writable-streams/bad-strategies.serviceworker.https.html</a></summary>
| Subtest | Results | Messages |
|-----------------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| | OK | |
| `Service worker test setup` | PASS | |
| `Writable stream: throwing strategy.size getter` | FAIL | `assert_throws: construction should re-throw the error function "() => {\n new WritableStream({}, {\n get size() {\n throw error1;\n },\n highWaterMark: 5\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "error1: a unique string" ("error1")` |
| `reject any non-function value for strategy.size` | FAIL | `assert_throws: function "() => {\n new WritableStream({}, { size: 'a string' });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")` |
| `Writable stream: throwing strategy.highWaterMark getter` | FAIL | `assert_throws: construction should re-throw the error function "() => {\n new WritableStream({}, {\n size() {\n return 1;\n },\n get highWaterMark() {\n throw error1;\n }\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "error1: a unique string" ("error1")` |
| `Writable stream: invalid strategy.highWaterMark` | FAIL | `assert_throws: construction should throw a RangeError for -1 function "() => {\n new WritableStream({}, {\n size() {\n return 1;\n },\n highWaterMark\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "RangeError" ("RangeError")` |
| `Writable stream: throwing strategy.size method` | FAIL | `WritableStream is not defined` |
| `Writable stream: invalid strategy.size return value` | FAIL | `WritableStream is not defined` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5240/streams/writable-streams/bad-strategies.sharedworker.html">/streams/writable-streams/bad-strategies.sharedworker.html</a></summary>
| Subtest | Results | Messages |
|-----------------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| | OK | |
| `Writable stream: throwing strategy.size getter` | FAIL | `assert_throws: construction should re-throw the error function "() => {\n new WritableStream({}, {\n get size() {\n throw error1;\n },\n highWaterMark: 5\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "error1: a unique string" ("error1")` |
| `reject any non-function value for strategy.size` | FAIL | `assert_throws: function "() => {\n new WritableStream({}, { size: 'a string' });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")` |
| `Writable stream: throwing strategy.highWaterMark getter` | FAIL | `assert_throws: construction should re-throw the error function "() => {\n new WritableStream({}, {\n size() {\n return 1;\n },\n get highWaterMark() {\n throw error1;\n }\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "error1: a unique string" ("error1")` |
| `Writable stream: invalid strategy.highWaterMark` | FAIL | `assert_throws: construction should throw a RangeError for -1 function "() => {\n new WritableStream({}, {\n size() {\n return 1;\n },\n highWaterMark\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "RangeError" ("RangeError")` |
| `Writable stream: throwing strategy.size method` | FAIL | `WritableStream is not defined` |
| `Writable stream: invalid strategy.size return value` | FAIL | `WritableStream is not defined` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5240/streams/writable-streams/reentrant-strategy.dedicatedworker.html">/streams/writable-streams/reentrant-strategy.dedicatedworker.html</a></summary>
| Subtest | Results | Messages |
|----------------------------------------------------------------------------------|---------|---------------------------------|
| | OK | |
| `writes should be written in the standard order` | FAIL | `WritableStream is not defined` |
| `writer.write() promises should resolve in the standard order` | FAIL | `WritableStream is not defined` |
| `controller.error() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `close() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `abort() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `releaseLock() should abort the write() when called within strategy.size()` | FAIL | `WritableStream is not defined` |
| `original reader should error when new reader is created within strategy.size()` | FAIL | `WritableStream is not defined` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5240/streams/writable-streams/reentrant-strategy.html">/streams/writable-streams/reentrant-strategy.html</a></summary>
| Subtest | Results | Messages |
|----------------------------------------------------------------------------------|---------|---------------------------------|
| | OK | |
| `writes should be written in the standard order` | FAIL | `WritableStream is not defined` |
| `writer.write() promises should resolve in the standard order` | FAIL | `WritableStream is not defined` |
| `controller.error() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `close() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `abort() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `releaseLock() should abort the write() when called within strategy.size()` | FAIL | `WritableStream is not defined` |
| `original reader should error when new reader is created within strategy.size()` | FAIL | `WritableStream is not defined` |
</details>
<details>
<summary><a href="https://w3c-test.org/submissions/5240/streams/writable-streams/reentrant-strategy.serviceworker.https.html">/streams/writable-streams/reentrant-strategy.serviceworker.https.html</a></summary>
| Subtest | Results | Messages |
|----------------------------------------------------------------------------------|---------|---------------------------------|
| | OK | |
| `Service worker test setup` | PASS | |
| `writes should be written in the standard order` | FAIL | `WritableStream is not defined` |
| `writer.write() promises should resolve in the standard order` | FAIL | `WritableStream is not defined` |
| `controller.error() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `close() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `abort() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `releaseLock() should abort the write() when called within strategy.size()` | FAIL | `WritableStream is not defined` |
| `original reader should error when new reader is created within strategy.size()` | FAIL | `WritableStream is not defined` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5240/streams/writable-streams/reentrant-strategy.sharedworker.html">/streams/writable-streams/reentrant-strategy.sharedworker.html</a></summary>
| Subtest | Results | Messages |
|----------------------------------------------------------------------------------|---------|---------------------------------|
| | OK | |
| `writes should be written in the standard order` | FAIL | `WritableStream is not defined` |
| `writer.write() promises should resolve in the standard order` | FAIL | `WritableStream is not defined` |
| `controller.error() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `close() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `abort() should work when called from within strategy.size()` | FAIL | `WritableStream is not defined` |
| `releaseLock() should abort the write() when called within strategy.size()` | FAIL | `WritableStream is not defined` |
| `original reader should error when new reader is created within strategy.size()` | FAIL | `WritableStream is not defined` |
</details>
<details>
<summary><a href="http://w3c-test.org/submissions/5240/streams/writable-streams/start.dedicatedworker.html">/streams/writable-streams/start.dedicatedworker.html</a></summary>
| Subtest | Results | Messages |
|-------------------------------------------------------------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| | OK | |
| `underlying sink's write should not be called until start finishes` | FAIL | `WritableStream is not defined` |
| `underlying sink's close should not be called until start finishes` | FAIL | `WritableStream is not defined` |
| `underlying sink's write or close should not be called if start throws` | FAIL | `assert_throws: constructor should throw passedError function "() => {\n // recordingWritableStream cannot be used here because the exception in the\n // constructor prevents assigning the object to a variable.\n new WritableStream({\n start() {\n throw passedError;\n },\n write() {\n writeCalled = true;\n },\n close() {\n closeCalled = true;\n }\n });\n }" threw object "ReferenceError: WritableStream is not defined" ("ReferenceError") expected object "Error: horrible things" ("Error")` |
| `underlying sink's write or close should not be invoked if the promise returned by start is rejected` | FAIL | `WritableStream is not defined` |
| `returning a thenable from start() should work` | FAIL | `WritableStream is not defined` |
| `controller.error() during start should cause writes to fail` | FAIL | `WritableStream is not defined` |
| `controller.error() during async start should cause existing writes to fail` | FAIL | `WritableStream is not defined` |
| `when start() rejects, writer promises should reject in standard order` | FAIL | `WritableStream is not defined`
View on GitHub: https://github.com/w3c/web-platform-tests/pull/5240#issuecomment-289709036
Received on Tuesday, 28 March 2017 09:06:42 UTC