Closed Bug 1881996 Opened 2 years ago Closed 2 years ago

[wpt-sync] Sync PR 44779 - WebSocketStream: Use one WebSocketError object to error everything

Tracking

()

Status:

RESOLVED FIXED

Milestone:

125 Branch

Tracking Flags:

Tracking

Status

firefox125

---

fixed

People

(Reporter: wpt-sync, Unassigned)

References

(
URL
)

Details

(Whiteboard: [wptsync downstream])

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Description

•

2 years ago

Sync web-platform-tests PR 44779 into mozilla-central (this bug is closed when the sync is complete).

PR: https://github.com/web-platform-tests/wpt/pull/44779
Details from upstream follow.

Adam Rice <ricea@chromium.org> wrote:

WebSocketStream: Use one WebSocketError object to error everything

Error readable, writable and wss.closed with the same WebSocketError
object.

Also add wpts for this and other close error scenarios.

Bug: 41470216
Change-Id: I0c68390ba4e7bef9db6a19516ac4afc77ed290e2
Reviewed-on: https://chromium-review.googlesource.com/5321157
WPT-Export-Revision: 338811f3b396d5d27d526caf5b25be595bab0abb

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Updated

•

2 years ago

Component: web-platform-tests → Networking: WebSockets

Product: Testing → Core

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 1

•

2 years ago

Pushed to try (stability) https://treeherder.mozilla.org/#/jobs?repo=try&revision=23b3b97f4afd24f8899967ee922c287d8a6faccd

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 2

•

2 years ago

CI Results

Ran 9 Firefox configurations based on mozilla-central, and Firefox, Chrome, and Safari on GitHub CI

Total 24 tests and 7 subtests

Status Summary

Firefox

OK : 24
FAIL : 408

Chrome

OK : 15
PASS : 298
FAIL : 27
TIMEOUT: 17
NOTRUN : 48

Safari

OK : 24
FAIL : 408

Links

Gecko CI (Treeherder)
GitHub PR Head
GitHub PR Base

Details

New Tests That Don't Pass

/websockets/stream/tentative/close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Safari: FAIL)
- close during handshake should work: FAIL (Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 3

•

2 years ago

CI Results

Ran 9 Firefox configurations based on mozilla-central, and Firefox, Chrome, and Safari on GitHub CI

Total 24 tests and 7 subtests

Status Summary

Firefox

OK : 24
FAIL : 408

Chrome

OK : 15
PASS : 298
FAIL : 27
TIMEOUT: 17
NOTRUN : 48

Safari

OK : 24
FAIL : 408

Links

Gecko CI (Treeherder)
GitHub PR Head
GitHub PR Base

Details

New Tests That Don't Pass

/websockets/stream/tentative/close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Safari: FAIL)
- close during handshake should work: FAIL (Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Updated

•

2 years ago

Depends on: 1883218

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 4

•

2 years ago

CI Results

Ran 9 Firefox configurations based on mozilla-central, and Firefox, Chrome, and Safari on GitHub CI

Total 24 tests and 7 subtests

Status Summary

Firefox

OK : 24
FAIL : 408

Chrome

OK : 15
PASS : 298
FAIL : 27
TIMEOUT: 17
NOTRUN : 48

Safari

OK : 24
FAIL : 408

Links

Gecko CI (Treeherder)
GitHub PR Head
GitHub PR Base

Details

New Tests That Don't Pass

/websockets/stream/tentative/close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Safari: FAIL)
- close during handshake should work: FAIL (Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 5

•

2 years ago

CI Results

Ran 9 Firefox configurations based on mozilla-central, and Firefox, Chrome, and Safari on GitHub CI

Total 24 tests and 7 subtests

Status Summary

Firefox

OK : 24
FAIL : 408

Chrome

OK : 15
PASS : 298
FAIL : 27
TIMEOUT: 17
NOTRUN : 48

Safari

OK : 24
FAIL : 408

Links

Gecko CI (Treeherder)
GitHub PR Head
GitHub PR Base

Details

New Tests That Don't Pass

/websockets/stream/tentative/close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Safari: FAIL)
- close during handshake should work: FAIL (Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 6

•

2 years ago

CI Results

Ran 9 Firefox configurations based on mozilla-central, and Firefox, Chrome, and Safari on GitHub CI

Total 24 tests and 7 subtests

Status Summary

Firefox

OK : 24
FAIL : 408

Chrome

OK : 15
PASS : 298
FAIL : 27
TIMEOUT: 17
NOTRUN : 48

Safari

OK : 24
FAIL : 408

Links

Gecko CI (Treeherder)
GitHub PR Head
GitHub PR Base

Details

New Tests That Don't Pass

/websockets/stream/tentative/close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Safari: FAIL)
- close during handshake should work: FAIL (Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 7

•

2 years ago

CI Results

Ran 9 Firefox configurations based on mozilla-central, and Firefox, Chrome, and Safari on GitHub CI

Total 24 tests and 7 subtests

Status Summary

Firefox

OK : 24
FAIL : 408

Chrome

OK : 15
PASS : 298
FAIL : 27
TIMEOUT: 17
NOTRUN : 48

Safari

OK : 24
FAIL : 408

Links

Gecko CI (Treeherder)
GitHub PR Head
GitHub PR Base

Details

New Tests That Don't Pass

/websockets/stream/tentative/close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Safari: FAIL)
- close during handshake should work: FAIL (Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)

Pulsebot

Comment 8

•

2 years ago

Pushed by wptsync@mozilla.com: https://hg.mozilla.org/integration/autoland/rev/dfdf3752a9c9 [wpt PR 44779] - WebSocketStream: Use one WebSocketError object to error everything, a=testonly https://hg.mozilla.org/integration/autoland/rev/736e46218651 [wpt PR 44779] - Update wpt metadata, a=testonly

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 9

•

2 years ago

CI Results

Ran 9 Firefox configurations based on mozilla-central, and Firefox, Chrome, and Safari on GitHub CI

Total 24 tests and 7 subtests

Status Summary

Firefox

OK : 24
FAIL : 408

Chrome

OK : 15
PASS : 298
FAIL : 27
TIMEOUT: 17
NOTRUN : 48

Safari

OK : 24
FAIL : 408

Links

Gecko CI (Treeherder)
GitHub PR Head
GitHub PR Base

Details

New Tests That Don't Pass

/websockets/stream/tentative/close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?wss [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Safari: FAIL)
- close during handshake should work: FAIL (Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Safari: FAIL)
/websockets/stream/tentative/close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: TIMEOUT, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: NOTRUN, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: NOTRUN, Safari: FAIL)
/websockets/stream/tentative/close.any.serviceworker.html?default [wpt.fyi]
- close code should be sent to server and reflected back: FAIL (Chrome: PASS, Safari: FAIL)
- no close argument should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with empty reason should send empty Close frame: FAIL (Chrome: PASS, Safari: FAIL)
- unspecified close code with non-empty reason should set code to 1000: FAIL (Chrome: PASS, Safari: FAIL)
- close(true) should throw a TypeError: FAIL (Chrome: PASS, Safari: FAIL)
- close() with an overlong reason should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close during handshake should work: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 1001 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 2999 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- close() with invalid code 5000 should throw: FAIL (Chrome: PASS, Safari: FAIL)
- closing the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- writer close() promise should not resolve until handshake completes: FAIL (Chrome: PASS, Safari: FAIL)
- incomplete closing handshake should be considered unclean close: FAIL (Chrome: FAIL, Safari: FAIL)
- aborting the writable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- aborting the writable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable should result in a clean close: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with attributes not wrapped in a WebSocketError should be ignored: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code should send that code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a code and reason should use them: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a reason but no code should default the close code: FAIL (Chrome: PASS, Safari: FAIL)
- canceling the readable with a DOMException not set code or reason: FAIL (Chrome: PASS, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.sharedworker.html?default [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.worker.html?wss [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: FAIL, Safari: FAIL)
/websockets/stream/tentative/remote-close.any.serviceworker.html?wpt_flags=h2 [wpt.fyi]
- clean close should be clean: FAIL (Chrome: PASS, Safari: FAIL)
- close frame with no body should result in status code 1005: FAIL (Chrome: PASS, Safari: FAIL)
- reason should be passed through: FAIL (Chrome: PASS, Safari: FAIL)
- UTF-8 reason should work: FAIL (Chrome: PASS, Safari: FAIL)
- close with unwritten data should not be considered clean: FAIL (Chrome: FAIL, Safari: FAIL)
- remote code and reason should be used: FAIL (Chrome: PASS, Safari: FAIL)
- abrupt close should give an error: FAIL (Chrome: TIMEOUT, Safari: FAIL)

Web Platform Test Sync Bot [:wpt-sync] (Matrix: #interop:mozilla.org)

Assignee

Comment 10

•

2 years ago

Test result changes from PR not available.

Sandor Molnar[:smolnar]

Comment 11

•

2 years ago

bugherder

https://hg.mozilla.org/mozilla-central/rev/dfdf3752a9c9
https://hg.mozilla.org/mozilla-central/rev/736e46218651

Status: NEW → RESOLVED

Closed: 2 years ago

status-firefox125: --- → fixed

Resolution: --- → FIXED

Target Milestone: --- → 125 Branch

You need to log in before you can comment on or make changes to this bug.