[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 not debug: [OK, CRASH]
  [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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL


[close.any.sharedworker.html?wpt_flags=h2]
  expected:
    if (os == "android") and not debug: [OK, ERROR]
  [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

  [incomplete closing handshake should be considered unclean close]
    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

  [incomplete closing handshake should be considered unclean close]
    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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL


[close.any.worker.html?wpt_flags=h2]
  expected:
    if (os == "android") and not debug: [OK, ERROR, CRASH]
  [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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL


[close.any.html?wpt_flags=h2]
  expected:
    if (os == "mac") and not debug: [OK, ERROR]
    if (os == "android") and not debug: [OK, ERROR]
  [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

  [incomplete closing handshake should be considered unclean close]
    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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL


[close.any.sharedworker.html?wss]
  expected:
    if (os == "mac") and not debug: [OK, ERROR]
    if (os == "android") and not debug: [OK, ERROR]
  [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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL


[close.any.html?default]
  expected:
    if (os == "android") and not debug: [OK, CRASH]
  [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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL

  [aborting the writable should result in a clean close]
    expected: FAIL

  [aborting the writable with attributes not wrapped in a WebSocketError should be ignored]
    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 default the close code]
    expected: FAIL

  [aborting the writable with a DOMException not set code or reason]
    expected: FAIL

  [canceling the readable should result in a clean close]
    expected: FAIL

  [canceling the readable with attributes not wrapped in a WebSocketError should be ignored]
    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 default the close code]
    expected: FAIL

  [canceling the readable with a DOMException not set code or reason]
    expected: FAIL


[close.any.serviceworker.html?default]
  expected:
    if (os == "mac") and not debug: [OK, ERROR]
    if (os == "android") and not debug: [OK, ERROR]
  [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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL

  [aborting the writable should result in a clean close]
    expected: FAIL

  [aborting the writable with attributes not wrapped in a WebSocketError should be ignored]
    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 default the close code]
    expected: FAIL

  [aborting the writable with a DOMException not set code or reason]
    expected: FAIL

  [canceling the readable should result in a clean close]
    expected: FAIL

  [canceling the readable with attributes not wrapped in a WebSocketError should be ignored]
    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 default the close code]
    expected: FAIL

  [canceling the readable with a DOMException not set code or reason]
    expected: FAIL


[close.any.worker.html?default]
  [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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL

  [aborting the writable should result in a clean close]
    expected: FAIL

  [aborting the writable with attributes not wrapped in a WebSocketError should be ignored]
    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 default the close code]
    expected: FAIL

  [aborting the writable with a DOMException not set code or reason]
    expected: FAIL

  [canceling the readable should result in a clean close]
    expected: FAIL

  [canceling the readable with attributes not wrapped in a WebSocketError should be ignored]
    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 default the close code]
    expected: FAIL

  [canceling the readable with a DOMException not set code or reason]
    expected: FAIL


[close.any.sharedworker.html?default]
  [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

  [incomplete closing handshake should be considered unclean close]
    expected: FAIL

  [aborting the writable should result in a clean close]
    expected: FAIL

  [aborting the writable with attributes not wrapped in a WebSocketError should be ignored]
    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 default the close code]
    expected: FAIL

  [aborting the writable with a DOMException not set code or reason]
    expected: FAIL

  [canceling the readable should result in a clean close]
    expected: FAIL

  [canceling the readable with attributes not wrapped in a WebSocketError should be ignored]
    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 default the close code]
    expected: FAIL

  [canceling the readable with a DOMException not set code or reason]
    expected: FAIL
