diff options
Diffstat (limited to 'testing/web-platform/meta/websockets/stream')
5 files changed, 1659 insertions, 0 deletions
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..524b3b1b8a --- /dev/null +++ b/testing/web-platform/meta/websockets/stream/tentative/close.any.js.ini @@ -0,0 +1,1046 @@ +[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] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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 + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + 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 + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + +[close.any.sharedworker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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 + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + 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 + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + +[close.any.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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 + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + 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 + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + +[close.any.serviceworker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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 + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + 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 + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + +[close.any.worker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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 + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + 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 + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + +[close.any.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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 + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + 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 + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + +[close.any.worker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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 + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + 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 + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + expected: FAIL + + +[close.any.sharedworker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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 + + [aborting the writable with a reason but no code should be ignored] + expected: FAIL + + [aborting the writable with an invalid code should be ignored] + expected: FAIL + + [aborting the writable with an invalid reason should be ignored] + expected: FAIL + + [aborting the writable with a DOMException should be ignored] + 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 + + [canceling the readable with a reason but no code should be ignored] + expected: FAIL + + [canceling the readable with an invalid code should be ignored] + expected: FAIL + + [canceling the readable with an invalid reason should be ignored] + expected: FAIL + + [canceling the readable with a DOMException should be ignored] + 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..ef1467ebcf --- /dev/null +++ b/testing/web-platform/meta/websockets/stream/tentative/constructor.any.js.ini @@ -0,0 +1,326 @@ +[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] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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.connection should resolve to the right types] + expected: FAIL + + +[constructor.any.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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.connection should resolve to the right types] + expected: FAIL + + +[constructor.any.serviceworker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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.connection should resolve to the right types] + expected: FAIL + + +[constructor.any.sharedworker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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.connection should resolve to the right types] + expected: FAIL + + +[constructor.any.worker.html?wss] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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.connection should resolve to the right types] + expected: FAIL + + +[constructor.any.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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.connection should resolve to the right types] + expected: FAIL + + +[constructor.any.worker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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.connection should resolve to the right types] + expected: FAIL + + +[constructor.any.sharedworker.html?wpt_flags=h2] + expected: + if (os == "android") and fission: [OK, TIMEOUT] + [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.connection should resolve to the right types] + expected: FAIL |