From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../websockets/stream/tentative/abort.any.js.ini | 139 +++ .../tentative/backpressure-receive.any.js.ini | 74 ++ .../stream/tentative/backpressure-send.any.js.ini | 74 ++ .../websockets/stream/tentative/close.any.js.ini | 982 +++++++++++++++++++++ .../stream/tentative/constructor.any.js.ini | 310 +++++++ .../stream/tentative/websocket-error.any.js.ini | 126 +++ 6 files changed, 1705 insertions(+) create mode 100644 testing/web-platform/meta/websockets/stream/tentative/abort.any.js.ini create mode 100644 testing/web-platform/meta/websockets/stream/tentative/backpressure-receive.any.js.ini create mode 100644 testing/web-platform/meta/websockets/stream/tentative/backpressure-send.any.js.ini create mode 100644 testing/web-platform/meta/websockets/stream/tentative/close.any.js.ini create mode 100644 testing/web-platform/meta/websockets/stream/tentative/constructor.any.js.ini create mode 100644 testing/web-platform/meta/websockets/stream/tentative/websocket-error.any.js.ini (limited to 'testing/web-platform/meta/websockets/stream') diff --git a/testing/web-platform/meta/websockets/stream/tentative/abort.any.js.ini b/testing/web-platform/meta/websockets/stream/tentative/abort.any.js.ini new file mode 100644 index 0000000000..ce4ddc4552 --- /dev/null +++ b/testing/web-platform/meta/websockets/stream/tentative/abort.any.js.ini @@ -0,0 +1,139 @@ +[DEFAULT] + disabled: + if tsan: https://bugzilla.mozilla.org/show_bug.cgi?1682723 + +[abort.any.serviceworker.html] + [abort after connect should do nothing] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort before constructing should prevent connection] + expected: FAIL + + +[abort.any.sharedworker.html] + [abort after connect should do nothing] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort before constructing should prevent connection] + expected: FAIL + + +[abort.any.html] + [abort after connect should do nothing] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort before constructing should prevent connection] + expected: FAIL + + +[abort.any.worker.html] + [abort after connect should do nothing] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort before constructing should prevent connection] + expected: FAIL + + +[abort.any.worker.html?wpt_flags=h2] + [abort before constructing should prevent connection] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort after connect should do nothing] + expected: FAIL + + +[abort.any.sharedworker.html?wpt_flags=h2] + [abort before constructing should prevent connection] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort after connect should do nothing] + expected: FAIL + + +[abort.any.html?wpt_flags=h2] + [abort before constructing should prevent connection] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort after connect should do nothing] + expected: FAIL + + +[abort.any.worker.html?wss] + [abort before constructing should prevent connection] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort after connect should do nothing] + expected: FAIL + + +[abort.any.html?wss] + [abort before constructing should prevent connection] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort after connect should do nothing] + expected: FAIL + + +[abort.any.sharedworker.html?wss] + [abort before constructing should prevent connection] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort after connect should do nothing] + expected: FAIL + + +[abort.any.serviceworker.html?wpt_flags=h2] + expected: + if swgl and (os == "win"): [OK, TIMEOUT] + [abort before constructing should prevent connection] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort after connect should do nothing] + expected: FAIL + + +[abort.any.serviceworker.html?wss] + expected: + if (os == "win") and not swgl and not debug and (processor == "x86_64"): [OK, TIMEOUT] + if (os == "win") and swgl: [OK, TIMEOUT] + [abort before constructing should prevent connection] + expected: FAIL + + [abort during handshake should work] + expected: FAIL + + [abort after connect should do nothing] + expected: FAIL diff --git a/testing/web-platform/meta/websockets/stream/tentative/backpressure-receive.any.js.ini b/testing/web-platform/meta/websockets/stream/tentative/backpressure-receive.any.js.ini new file mode 100644 index 0000000000..3fd2633da1 --- /dev/null +++ b/testing/web-platform/meta/websockets/stream/tentative/backpressure-receive.any.js.ini @@ -0,0 +1,74 @@ +[backpressure-receive.any.worker.html] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.sharedworker.html] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.serviceworker.html] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.html] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.serviceworker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.sharedworker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.worker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.serviceworker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.sharedworker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to received messages] + expected: FAIL + + +[backpressure-receive.any.worker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to received messages] + expected: FAIL diff --git a/testing/web-platform/meta/websockets/stream/tentative/backpressure-send.any.js.ini b/testing/web-platform/meta/websockets/stream/tentative/backpressure-send.any.js.ini new file mode 100644 index 0000000000..c2b5550083 --- /dev/null +++ b/testing/web-platform/meta/websockets/stream/tentative/backpressure-send.any.js.ini @@ -0,0 +1,74 @@ +[backpressure-send.any.worker.html] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.serviceworker.html] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.html] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.sharedworker.html] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.sharedworker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.sharedworker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.serviceworker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.worker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.serviceworker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.worker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to sent messages] + expected: FAIL + + +[backpressure-send.any.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [backpressure should be applied to sent messages] + expected: FAIL diff --git a/testing/web-platform/meta/websockets/stream/tentative/close.any.js.ini b/testing/web-platform/meta/websockets/stream/tentative/close.any.js.ini new file mode 100644 index 0000000000..c1f0ba7f85 --- /dev/null +++ b/testing/web-platform/meta/websockets/stream/tentative/close.any.js.ini @@ -0,0 +1,982 @@ +[close.any.worker.html] + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + +[close.any.sharedworker.html] + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + +[close.any.html] + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + +[close.any.serviceworker.html] + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + +[close.any.serviceworker.html?wpt_flags=h2] + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [aborting the writable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [aborting the writable with a reason but no code should default the close code] + expected: FAIL + + [aborting the writable with a DOMException not set code or reason] + expected: FAIL + + [canceling the readable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [canceling the readable with a reason but no code should default the close code] + expected: FAIL + + [canceling the readable with a DOMException not set code or reason] + expected: FAIL + + +[close.any.sharedworker.html?wpt_flags=h2] + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [aborting the writable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [aborting the writable with a reason but no code should default the close code] + expected: FAIL + + [aborting the writable with a DOMException not set code or reason] + expected: FAIL + + [canceling the readable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [canceling the readable with a reason but no code should default the close code] + expected: FAIL + + [canceling the readable with a DOMException not set code or reason] + expected: FAIL + + +[close.any.html?wss] + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [aborting the writable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [aborting the writable with a reason but no code should default the close code] + expected: FAIL + + [aborting the writable with a DOMException not set code or reason] + expected: FAIL + + [canceling the readable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [canceling the readable with a reason but no code should default the close code] + expected: FAIL + + [canceling the readable with a DOMException not set code or reason] + expected: FAIL + + +[close.any.serviceworker.html?wss] + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [aborting the writable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [aborting the writable with a reason but no code should default the close code] + expected: FAIL + + [aborting the writable with a DOMException not set code or reason] + expected: FAIL + + [canceling the readable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [canceling the readable with a reason but no code should default the close code] + expected: FAIL + + [canceling the readable with a DOMException not set code or reason] + expected: FAIL + + +[close.any.worker.html?wpt_flags=h2] + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [aborting the writable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [aborting the writable with a reason but no code should default the close code] + expected: FAIL + + [aborting the writable with a DOMException not set code or reason] + expected: FAIL + + [canceling the readable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [canceling the readable with a reason but no code should default the close code] + expected: FAIL + + [canceling the readable with a DOMException not set code or reason] + expected: FAIL + + +[close.any.html?wpt_flags=h2] + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [aborting the writable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [aborting the writable with a reason but no code should default the close code] + expected: FAIL + + [aborting the writable with a DOMException not set code or reason] + expected: FAIL + + [canceling the readable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [canceling the readable with a reason but no code should default the close code] + expected: FAIL + + [canceling the readable with a DOMException not set code or reason] + expected: FAIL + + +[close.any.worker.html?wss] + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [aborting the writable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [aborting the writable with a reason but no code should default the close code] + expected: FAIL + + [aborting the writable with a DOMException not set code or reason] + expected: FAIL + + [canceling the readable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [canceling the readable with a reason but no code should default the close code] + expected: FAIL + + [canceling the readable with a DOMException not set code or reason] + expected: FAIL + + +[close.any.sharedworker.html?wss] + [close code should be sent to server and reflected back] + expected: FAIL + + [no close argument should send empty Close frame] + expected: FAIL + + [unspecified close code should send empty Close frame] + expected: FAIL + + [unspecified close code with empty reason should send empty Close frame] + expected: FAIL + + [unspecified close code with non-empty reason should set code to 1000] + expected: FAIL + + [close(true) should throw a TypeError] + expected: FAIL + + [close() with an overlong reason should throw] + expected: FAIL + + [close during handshake should work] + expected: FAIL + + [close() with invalid code 999 should throw] + expected: FAIL + + [close() with invalid code 1001 should throw] + expected: FAIL + + [close() with invalid code 2999 should throw] + expected: FAIL + + [close() with invalid code 5000 should throw] + expected: FAIL + + [closing the writable should result in a clean close] + expected: FAIL + + [writer close() promise should not resolve until handshake completes] + expected: FAIL + + [aborting the writable should result in a clean close] + expected: FAIL + + [aborting the writable with a code should send that code] + expected: FAIL + + [aborting the writable with a code and reason should use them] + expected: FAIL + + [canceling the readable should result in a clean close] + expected: FAIL + + [canceling the readable with a code should send that code] + expected: FAIL + + [canceling the readable with a code and reason should use them] + expected: FAIL + + [aborting the writable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [aborting the writable with a reason but no code should default the close code] + expected: FAIL + + [aborting the writable with a DOMException not set code or reason] + expected: FAIL + + [canceling the readable with attributes not wrapped in a WebSocketError should be ignored] + expected: FAIL + + [canceling the readable with a reason but no code should default the close code] + expected: FAIL + + [canceling the readable with a DOMException not set code or reason] + expected: FAIL diff --git a/testing/web-platform/meta/websockets/stream/tentative/constructor.any.js.ini b/testing/web-platform/meta/websockets/stream/tentative/constructor.any.js.ini new file mode 100644 index 0000000000..cf06bc352c --- /dev/null +++ b/testing/web-platform/meta/websockets/stream/tentative/constructor.any.js.ini @@ -0,0 +1,310 @@ +[constructor.any.serviceworker.html] + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [wss.connection should resolve to the right types] + expected: FAIL + + [constructing with no URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + +[constructor.any.sharedworker.html] + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [wss.connection should resolve to the right types] + expected: FAIL + + [constructing with no URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + +[constructor.any.html] + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [wss.connection should resolve to the right types] + expected: FAIL + + [constructing with no URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + +[constructor.any.worker.html] + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [wss.connection should resolve to the right types] + expected: FAIL + + [constructing with no URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + +[constructor.any.serviceworker.html?wpt_flags=h2] + [constructing with no URL should throw] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [wss.opened should resolve to the right types] + expected: FAIL + + +[constructor.any.html?wss] + [constructing with no URL should throw] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [wss.opened should resolve to the right types] + expected: FAIL + + +[constructor.any.serviceworker.html?wss] + [constructing with no URL should throw] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [wss.opened should resolve to the right types] + expected: FAIL + + +[constructor.any.sharedworker.html?wss] + [constructing with no URL should throw] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [wss.opened should resolve to the right types] + expected: FAIL + + +[constructor.any.worker.html?wss] + [constructing with no URL should throw] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [wss.opened should resolve to the right types] + expected: FAIL + + +[constructor.any.html?wpt_flags=h2] + [constructing with no URL should throw] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [wss.opened should resolve to the right types] + expected: FAIL + + +[constructor.any.worker.html?wpt_flags=h2] + [constructing with no URL should throw] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [wss.opened should resolve to the right types] + expected: FAIL + + +[constructor.any.sharedworker.html?wpt_flags=h2] + [constructing with no URL should throw] + expected: FAIL + + [constructing with an invalid URL should throw] + expected: FAIL + + [constructing with invalid options should throw] + expected: FAIL + + [protocols should be required to be a list] + expected: FAIL + + [constructing with a valid URL should work] + expected: FAIL + + [setting a protocol in the constructor should work] + expected: FAIL + + [connection failure should reject the promises] + expected: FAIL + + [wss.opened should resolve to the right types] + expected: FAIL diff --git a/testing/web-platform/meta/websockets/stream/tentative/websocket-error.any.js.ini b/testing/web-platform/meta/websockets/stream/tentative/websocket-error.any.js.ini new file mode 100644 index 0000000000..08cf37e349 --- /dev/null +++ b/testing/web-platform/meta/websockets/stream/tentative/websocket-error.any.js.ini @@ -0,0 +1,126 @@ +[websocket-error.any.serviceworker.html] + [WebSocketError defaults should be correct] + expected: FAIL + + [WebSocketError should be initialised from arguments] + expected: FAIL + + [new WebSocketError with invalid code 999 should throw] + expected: FAIL + + [new WebSocketError with invalid code 1001 should throw] + expected: FAIL + + [new WebSocketError with invalid code 2999 should throw] + expected: FAIL + + [new WebSocketError with invalid code 5000 should throw] + expected: FAIL + + [passing only close code to WebSocketError should work] + expected: FAIL + + [passing a non-empty reason should cause the close code to be set to 1000] + expected: FAIL + + [overlong reason should throw] + expected: FAIL + + [reason should be rejected based on utf-8 bytes, not character count] + expected: FAIL + + +[websocket-error.any.sharedworker.html] + [WebSocketError defaults should be correct] + expected: FAIL + + [WebSocketError should be initialised from arguments] + expected: FAIL + + [new WebSocketError with invalid code 999 should throw] + expected: FAIL + + [new WebSocketError with invalid code 1001 should throw] + expected: FAIL + + [new WebSocketError with invalid code 2999 should throw] + expected: FAIL + + [new WebSocketError with invalid code 5000 should throw] + expected: FAIL + + [passing only close code to WebSocketError should work] + expected: FAIL + + [passing a non-empty reason should cause the close code to be set to 1000] + expected: FAIL + + [overlong reason should throw] + expected: FAIL + + [reason should be rejected based on utf-8 bytes, not character count] + expected: FAIL + + +[websocket-error.any.html] + [WebSocketError defaults should be correct] + expected: FAIL + + [WebSocketError should be initialised from arguments] + expected: FAIL + + [new WebSocketError with invalid code 999 should throw] + expected: FAIL + + [new WebSocketError with invalid code 1001 should throw] + expected: FAIL + + [new WebSocketError with invalid code 2999 should throw] + expected: FAIL + + [new WebSocketError with invalid code 5000 should throw] + expected: FAIL + + [passing only close code to WebSocketError should work] + expected: FAIL + + [passing a non-empty reason should cause the close code to be set to 1000] + expected: FAIL + + [overlong reason should throw] + expected: FAIL + + [reason should be rejected based on utf-8 bytes, not character count] + expected: FAIL + + +[websocket-error.any.worker.html] + [WebSocketError defaults should be correct] + expected: FAIL + + [WebSocketError should be initialised from arguments] + expected: FAIL + + [new WebSocketError with invalid code 999 should throw] + expected: FAIL + + [new WebSocketError with invalid code 1001 should throw] + expected: FAIL + + [new WebSocketError with invalid code 2999 should throw] + expected: FAIL + + [new WebSocketError with invalid code 5000 should throw] + expected: FAIL + + [passing only close code to WebSocketError should work] + expected: FAIL + + [passing a non-empty reason should cause the close code to be set to 1000] + expected: FAIL + + [overlong reason should throw] + expected: FAIL + + [reason should be rejected based on utf-8 bytes, not character count] + expected: FAIL -- cgit v1.2.3