denoland-deno/cli/tests/wpt.jsonc

{
  "streams": [
    // "piping/abort",
    // "piping/close-propagation-backward",
    // "piping/close-propagation-forward",
    // "piping/error-propagation-backward",
    // "piping/error-propagation-forward",
    "piping/flow-control",
    // "piping/general",
    "piping/multiple-propagation",
    // "piping/pipe-through",
    "piping/then-interception",
    // "piping/throwing-options",
    // "piping/transform-streams",
    "queuing-strategies.any",
    // "readable-byte-streams",
    // "readable-streams/async-iterator",
    // "readable-streams/bad-strategies",
    // "readable-streams/bad-underlying-source",
    // "readable-streams/cancel",
    // "readable-streams/constructor",
    "readable-streams/count-queuing-strategy-integration",
    "readable-streams/default-reader",
    "readable-streams/floating-point-total-queue-size",
    "readable-streams/garbage-collection",
    "readable-streams/general",
    {
      "name": "readable-streams/patched-global",
      "expectFail": [
        "ReadableStream async iterator should use the original values of getReader() and ReadableStreamDefaultReader methods"
      ]
    },
    "readable-streams/reentrant-strategies",
    "readable-streams/tee",
    // "readable-streams/templated",
    "transform-streams/backpressure",
    "transform-streams/errors",
    "transform-streams/flush",
    "transform-streams/general",
    "transform-streams/lipfuzz",
    // "transform-streams/patched-global",
    "transform-streams/properties",
    "transform-streams/reentrant-strategies",
    "transform-streams/strategies",
    // "transform-streams/terminate",
    // "writable-streams/aborting",
    // "writable-streams/bad-strategies",
    "writable-streams/bad-underlying-sinks",
    "writable-streams/byte-length-queuing-strategy",
    // "writable-streams/close",
    // "writable-streams/constructor",
    "writable-streams/count-queuing-strategy",
    "writable-streams/error",
    "writable-streams/floating-point-total-queue-size",
    "writable-streams/general",
    "writable-streams/properties",
    "writable-streams/reentrant-strategy",
    "writable-streams/start",
    "writable-streams/write"
  ],
  "encoding": [
    "api-basics",
    "api-invalid-label",
    "api-replacement-encodings",
    "api-surrogates-utf8",
    // TODO(lucacasonato): enable encodeInto. We have a bug in implementaiton.
    // {
    //   "name": "encodeInto",
    //   "expectFail": [
    //     "encodeInto() and a detached output buffer"
    //   ]
    // },
    // "encodeInto",
    // TODO(lucacasonato): enable when we support iso-2022-jp
    // "iso-2022-jp-decoder",
    // TODO(lucacasonato): uses XMLHttpRequest unnecessarily. should be fixed upstream before enabling
    // "replacement-encodings",
    "textdecoder-byte-order-marks",
    {
      "name": "textdecoder-copy",
      "expectFail": [
        // TODO(lucacasonato): enable when we have stream support
        "Modify buffer after passing it in (ArrayBuffer)",
        "Modify buffer after passing it in (SharedArrayBuffer)"
      ]
    },
    "textdecoder-fatal-single-byte",
    "textdecoder-fatal.",
    "textdecoder-ignorebom",
    {
      "name": "textdecoder-labels",
      "expectFail": [
        "cseucpkdfmtjapanese => EUC-JP",
        "euc-jp => EUC-JP",
        "x-euc-jp => EUC-JP",
        "csiso2022jp => ISO-2022-JP",
        "iso-2022-jp => ISO-2022-JP",
        "csshiftjis => Shift_JIS",
        "ms932 => Shift_JIS",
        "ms_kanji => Shift_JIS",
        "shift-jis => Shift_JIS",
        "shift_jis => Shift_JIS",
        "sjis => Shift_JIS",
        "windows-31j => Shift_JIS",
        "x-sjis => Shift_JIS",
        "cseuckr => EUC-KR",
        "csksc56011987 => EUC-KR",
        "euc-kr => EUC-KR",
        "iso-ir-149 => EUC-KR",
        "korean => EUC-KR",
        "ks_c_5601-1987 => EUC-KR",
        "ks_c_5601-1989 => EUC-KR",
        "ksc5601 => EUC-KR",
        "ksc_5601 => EUC-KR",
        "windows-949 => EUC-KR",
        "x-user-defined => x-user-defined"
      ]
    },
    // TODO(lucacasonato): enable when we have stream support
    // "textdecoder-streaming",
    "textdecoder-utf16-surrogates",
    {
      "name": "textencoder-constructor-non-utf",
      "expectFail": [
        "Encoding argument supported for decode: EUC-JP",
        "Encoding argument supported for decode: ISO-2022-JP",
        "Encoding argument supported for decode: Shift_JIS",
        "Encoding argument supported for decode: EUC-KR",
        "Encoding argument supported for decode: x-user-defined"
      ]
    },
    "textencoder-utf16-surrogates",
    "legacy-mb-schinese"
    // TODO(lucacasonato): uses XMLHttpRequest unnecessarily. should be fixed upstream before enabling
    // "unsupported-encodings",
  ],
  "dom": ["abort/event"],
  "hr-time": ["monotonic-clock"],
  "html": [
    "webappapis/microtask-queuing/queue-microtask-exceptions.any",
    "webappapis/microtask-queuing/queue-microtask.any",
    "webappapis/timers"
  ],
  "user-timing": [
    "clear_all_marks",
    "clear_all_measures",
    "clear_non_existent_mark",
    "clear_non_existent_measure",
    "clear_one_mark",
    "clear_one_measure",
    "entry_type",
    "mark-entry-constructor",
    "mark-errors",
    "mark-measure-return-objects",
    "mark.any",
    "measure_syntax_err",
    "measure-l3",
    "structured-serialize-detail",
    "user_timing_exists"
  ],
  "wasm": [
    "jsapi/constructor/compile",
    "jsapi/constructor/multi-value",
    "jsapi/constructor/toStringTag",
    "jsapi/constructor/validate",
    "jsapi/global/constructor",
    "jsapi/global/toString",
    "jsapi/global/value-get-set",
    "jsapi/global/valueOf",
    "jsapi/instance/toString",
    "jsapi/instance/constructor-caching",
    "jsapi/memory/toString",
    "jsapi/module/constructor",
    "jsapi/module/customSections",
    "jsapi/module/exports",
    "jsapi/module/imports",
    "jsapi/module/toString",
    "jsapi/table/get-set",
    "jsapi/table/toString",
    "webapi/body",
    "webapi/invalid-args",
    "webapi/rejected-arg",
    "webapi/status",
    "webapi/create_multiple_memory",
    "create_multiple_memory"

    //FAILING TESTS
    // "jsapi/constructor/instantiate-bad-imports",
    // "jsapi/constructor/instantiate",
    // "jsapi/global/type",
    // "jsapi/instance/constructor-bad-imports",
    // "jsapi/instance/constructor",
    // "jsapi/instance/exports",
    // "jsapi/memory/buffer",
    // "jsapi/memory/constructor-shared",
    // "jsapi/memory/constructor-types",
    // "jsapi/memory/constructor",
    // "jsapi/memory/grow",
    // "jsapi/memory/type",
    // "jsapi/table/constructor-types",
    // "jsapi/table/constructor",
    // "jsapi/table/grow-reftypes",
    // "jsapi/table/grow",
    // "jsapi/table/length",
    // "jsapi/idlharness",
    // "jsapi/instance",
    // "jsapi/prototypes",
    // "serialization/arraybuffer/transfer"
    // "serialization/module/nested-worker-success",
    // "serialization/module/serialization-via-idb",
    // "serialization/module/serialization-via-notifications-api",
    // "webapi/abort",
    // "webapi/contenttype",
    // "webapi/empty-body",
    // "webapi/historical",
    // "webapi/idlharness",
    // "webapi/instantiateStreaming-bad-imports",
    // "webapi/instantiateStreaming",
    // "webapi/invalid-code",
    // "webapi/origin",
  ],
  "console": [
    "console-is-a-namespace",
    "console-label-conversion",
    "console-namespace-object-class-string",
    "console-tests-historical"
  ],
  "WebCryptoApi": ["getRandomValues"],
  "WebIDL": [
    "ecmascript-binding/es-exceptions/DOMException-constants",
    "ecmascript-binding/es-exceptions/DOMException-constructor-and-prototype",
    "ecmascript-binding/es-exceptions/DOMException-constructor-behavior",
    {
      "name": "ecmascript-binding/es-exceptions/DOMException-custom-bindings",
      "expectFail": [
        // TODO(kt3k): Enable this test.
        // We can pass this test by using Object.setPrototypeOf(...) instead of
        // class...extends, but that causes a problem in printing of uncaught
        // DOMException. We might need to modify how to print uncaught error in
        // `//core/error.rs`.
        "does not inherit from Error: class-side"
      ]
    }
  ],
  "url": [
    "historical",
    {
      "name": "url-constructor",
      "expectFail": [
        "Parsing: <http://example\t.\norg> against <http://example.org/foo/bar>",
        "Parsing: <a:\t foo.com> against <http://example.org/foo/bar>",
        "Parsing: <lolscheme:x x#x x> against <about:blank>",
        "Parsing: <http://f:00000000000000/c> against <http://example.org/foo/bar>",
        "Parsing: <http://f:00000000000000000000080/c> against <http://example.org/foo/bar>",
        "Parsing: <http://f: /c> against <http://example.org/foo/bar>",
        "Parsing: <http://f: 21 / b ? d # e > against <http://example.org/foo/bar>",
        "Parsing: <:#> against <http://example.org/foo/bar>",
        "Parsing: <#> against <http://example.org/foo/bar>",
        "Parsing: <?> against <http://example.org/foo/bar>",
        "Parsing: <http://[::127.0.0.1]> against <http://example.org/foo/bar>",
        "Parsing: <http://[0:0:0:0:0:0:13.1.68.3]> against <http://example.org/foo/bar>",
        "Parsing: <file:c:\\foo\\bar.html> against <file:///tmp/mock/path>",
        "Parsing: <  File:c|////foo\\bar.html> against <file:///tmp/mock/path>",
        "Parsing: <C|/foo/bar> against <file:///tmp/mock/path>",
        "Parsing: </C|\\foo\\bar> against <file:///tmp/mock/path>",
        "Parsing: <//C|/foo/bar> against <file:///tmp/mock/path>",
        "Parsing: <file://localhost> against <file:///tmp/mock/path>",
        "Parsing: <file://localhost/> against <file:///tmp/mock/path>",
        "Parsing: <file://localhost/test> against <file:///tmp/mock/path>",
        "Parsing: <http://example.com/foo/%2e> against <about:blank>",
        "Parsing: <http://example.com/foo/%2e./%2e%2e/.%2e/%2e.bar> against <about:blank>",
        "Parsing: <http://example.com////../..> against <about:blank>",
        "Parsing: <http://example.com/foo\t\u0091%91> against <about:blank>",
        "Parsing: <http://example.com/foo\tbar> against <about:blank>",
        "Parsing: <http://www.google.com/foo?bar=baz#> against <about:blank>",
        "Parsing: <http://www/foo/%2E/html> against <about:blank>",
        "Parsing: <file:..> against <http://www.example.com/test>",
        "Parsing: <\u0000\u001b\u0004\u0012 http://example.com/\u001f \r > against <about:blank>",
        "Parsing: <https://%EF%BF%BD> against <about:blank>",
        "Parsing: <http://[::1.2.3.]> against <http://other.com/>",
        "Parsing: <http://[::1.2.]> against <http://other.com/>",
        "Parsing: <http://[::1.]> against <http://other.com/>",
        "Parsing: <#> against <test:test>",
        "Parsing: <#> against <test:test?test>",
        "Parsing: <i> against <sc:sd>",
        "Parsing: <i> against <sc:sd/sd>",
        "Parsing: <../i> against <sc:sd>",
        "Parsing: <../i> against <sc:sd/sd>",
        "Parsing: </i> against <sc:sd>",
        "Parsing: </i> against <sc:sd/sd>",
        "Parsing: <?i> against <sc:sd>",
        "Parsing: <?i> against <sc:sd/sd>",
        "Parsing: <sc://@/> against <about:blank>",
        "Parsing: <sc://te@s:t@/> against <about:blank>",
        "Parsing: <sc://:/> against <about:blank>",
        "Parsing: <sc://:12/> against <about:blank>",
        "Parsing: <sc://\\/> against <about:blank>",
        "Parsing: <sc:\\../> against <about:blank>",
        "Parsing: <ftp://%e2%98%83> against <about:blank>",
        "Parsing: <https://%e2%98%83> against <about:blank>",
        "Parsing: <h\tt\nt\rp://h\to\ns\rt:9\t0\n0\r0/p\ta\nt\rh?q\tu\ne\rry#f\tr\na\rg> against <about:blank>",
        "Parsing: <https://0x.0x.0> against <about:blank>",
        "Parsing: </> against <file://h/C:/a/b>",
        "Parsing: <//d:> against <file:///C:/a/b>",
        "Parsing: <//d:/..> against <file:///C:/a/b>",
        "Parsing: <file:\\\\//> against <about:blank>",
        "Parsing: <file:\\\\\\\\> against <about:blank>",
        "Parsing: <file:\\\\\\\\?fox> against <about:blank>",
        "Parsing: <file:\\\\\\\\#guppy> against <about:blank>",
        "Parsing: <file://spider///> against <about:blank>",
        "Parsing: <file:\\\\localhost//> against <about:blank>",
        "Parsing: <file://\\/localhost//cat> against <about:blank>",
        "Parsing: <file://localhost//a//../..//> against <about:blank>",
        "Parsing: </////mouse> against <file:///elephant>",
        "Parsing: <\\/localhost//pig> against <file://lion/>",
        "Parsing: <//localhost//pig> against <file://lion/>",
        "Parsing: <C|> against <file://host/dir/file>",
        "Parsing: <C|> against <file://host/D:/dir1/dir2/file>",
        "Parsing: <C|#> against <file://host/dir/file>",
        "Parsing: <C|?> against <file://host/dir/file>",
        "Parsing: <C|/> against <file://host/dir/file>",
        "Parsing: <C|\n/> against <file://host/dir/file>",
        "Parsing: <C|\\> against <file://host/dir/file>",
        "Parsing: </c|/foo/bar> against <file:///c:/baz/qux>",
        "Parsing: </c:/foo/bar> against <file://host/path>",
        "Parsing: <file://example.net/C:/> against <about:blank>",
        "Parsing: <file://1.2.3.4/C:/> against <about:blank>",
        "Parsing: <file://[1::8]/C:/> against <about:blank>",
        "Parsing: <file:/C|/> against <about:blank>",
        "Parsing: <file://C|/> against <about:blank>",
        "Parsing: <\\\\\\.\\Y:> against <about:blank>",
        "Parsing: <\\\\\\.\\y:> against <about:blank>",
        "Parsing: <file://localhost//a//../..//foo> against <about:blank>",
        "Parsing: <file://localhost////foo> against <about:blank>",
        "Parsing: <file:////foo> against <about:blank>",
        "Parsing: <file:////one/two> against <file:///>",
        "Parsing: <////one/two> against <file:///>",
        "Parsing: <file:.//p> against <about:blank>",
        "Parsing: <http://[1:0::]> against <http://example.net/>",
        "Parsing: <http://[0:1:2:3:4:5:6:7:8]> against <http://example.net/>",
        "Parsing: <https://[0::0::0]> against <about:blank>",
        "Parsing: <https://[0:.0]> against <about:blank>",
        "Parsing: <https://[0:0:]> against <about:blank>",
        "Parsing: <https://[0:1:2:3:4:5:6:7.0.0.0.1]> against <about:blank>",
        "Parsing: <https://[0:1.00.0.0.0]> against <about:blank>",
        "Parsing: <https://[0:1.290.0.0.0]> against <about:blank>",
        "Parsing: <https://[0:1.23.23]> against <about:blank>",
        "Parsing: <#x> against <sc://ñ>",
        "Parsing: <?x> against <sc://ñ>",
        "Parsing: <sc://?> against <about:blank>",
        "Parsing: <sc://#> against <about:blank>",
        "Parsing: <non-spec:/.//> against <about:blank>",
        "Parsing: <non-spec:/..//> against <about:blank>",
        "Parsing: <non-spec:/a/..//> against <about:blank>",
        "Parsing: <non-spec:/.//path> against <about:blank>",
        "Parsing: <non-spec:/..//path> against <about:blank>",
        "Parsing: <non-spec:/a/..//path> against <about:blank>",
        "Parsing: </.//path> against <non-spec:/p>",
        "Parsing: </..//path> against <non-spec:/p>",
        "Parsing: <..//path> against <non-spec:/p>",
        "Parsing: <a/..//path> against <non-spec:/p>",
        "Parsing: <> against <non-spec:/..//p>",
        "Parsing: <path> against <non-spec:/..//p>",
        "Parsing: <non-special://[1:2:0:0:5:0:0:0]/> against <about:blank>",
        "Parsing: <http://[::127.0.0.0.1]> against <about:blank>",
        "Parsing: <http://example.org/test?#> against <about:blank>",
        "Parsing: <a> against <about:blank>",
        "Parsing: <a/> against <about:blank>",
        "Parsing: <a//> against <about:blank>",
        "Parsing: <test-a-colon.html> against <a:>",
        "Parsing: <test-a-colon-b.html> against <a:b>",
        "Parsing: <file://a%C2%ADb/p> against <about:blank>",
        "Parsing: <file://­/p> against <about:blank>",
        "Parsing: <file://%C2%AD/p> against <about:blank>",
        "Parsing: <file://xn--/p> against <about:blank>"
      ]
    },
    {
      "name": "url-origin",
      "expectFail": [
        "Origin parsing: <http://example\t.\norg> against <http://example.org/foo/bar>",
        "Origin parsing: <non-special://test:@test/x> against <about:blank>",
        "Origin parsing: <non-special://:@test/x> against <about:blank>",
        "Origin parsing: <http://f:00000000000000/c> against <http://example.org/foo/bar>",
        "Origin parsing: <http://f:00000000000000000000080/c> against <http://example.org/foo/bar>",
        "Origin parsing: <http://[::127.0.0.1]> against <http://example.org/foo/bar>",
        "Origin parsing: <http://[0:0:0:0:0:0:13.1.68.3]> against <http://example.org/foo/bar>",
        "Origin parsing: <ssh://example.com/foo/bar.git> against <http://example.org/>",
        "Origin parsing: <httpa://foo:80/> against <about:blank>",
        "Origin parsing: <gopher://foo:70/> against <about:blank>",
        "Origin parsing: <gopher://foo:443/> against <about:blank>",
        "Origin parsing: <\u0000\u001b\u0004\u0012 http://example.com/\u001f \r > against <about:blank>",
        "Origin parsing: <sc://faß.ExAmPlE/> against <about:blank>",
        "Origin parsing: <notspecial://host/?'> against <about:blank>",
        "Origin parsing: <i> against <sc://ho/pa>",
        "Origin parsing: <../i> against <sc://ho/pa>",
        "Origin parsing: </i> against <sc://ho/pa>",
        "Origin parsing: <?i> against <sc://ho/pa>",
        "Origin parsing: <#i> against <sc://ho/pa>",
        "Origin parsing: <sc://ñ.test/> against <about:blank>",
        "Origin parsing: <x> against <sc://ñ>",
        "Origin parsing: <sc://\u001f!\"$&'()*+,-.;=_`{|}~/> against <about:blank>",
        "Origin parsing: <ftp://%e2%98%83> against <about:blank>",
        "Origin parsing: <https://%e2%98%83> against <about:blank>",
        "Origin parsing: <h\tt\nt\rp://h\to\ns\rt:9\t0\n0\r0/p\ta\nt\rh?q\tu\ne\rry#f\tr\na\rg> against <about:blank>",
        "Origin parsing: <https://0x.0x.0> against <about:blank>",
        "Origin parsing: <http://[1:0::]> against <http://example.net/>",
        "Origin parsing: <sc://ñ> against <about:blank>",
        "Origin parsing: <sc://ñ?x> against <about:blank>",
        "Origin parsing: <sc://ñ#x> against <about:blank>",
        "Origin parsing: <#x> against <sc://ñ>",
        "Origin parsing: <?x> against <sc://ñ>",
        "Origin parsing: <tftp://foobar.com/someconfig;mode=netascii> against <about:blank>",
        "Origin parsing: <telnet://user:pass@foobar.com:23/> against <about:blank>",
        "Origin parsing: <ut2004://10.10.10.10:7777/Index.ut2> against <about:blank>",
        "Origin parsing: <redis://foo:bar@somehost:6379/0?baz=bam&qux=baz> against <about:blank>",
        "Origin parsing: <rsync://foo@host:911/sup> against <about:blank>",
        "Origin parsing: <git://github.com/foo/bar.git> against <about:blank>",
        "Origin parsing: <irc://myserver.com:6999/channel?passwd> against <about:blank>",
        "Origin parsing: <dns://fw.example.org:9999/foo.bar.org?type=TXT> against <about:blank>",
        "Origin parsing: <ldap://localhost:389/ou=People,o=JNDITutorial> against <about:blank>",
        "Origin parsing: <git+https://github.com/foo/bar> against <about:blank>"
      ]
    },
    {
      "name": "url-searchparams",
      "expectFail": [
        "URL.searchParams updating, clearing",
        "URL.searchParams and URL.search setters, update propagation"
      ]
    },
    {
      "name": "url-setters-stripping",
      "expectFail": [
        "Setting protocol with leading U+0000 (https:)",
        "Setting protocol with U+0000 before inserted colon (https:)",
        "Setting host with leading U+0000 (https:)",
        "Setting host with middle U+0000 (https:)",
        "Setting host with trailing U+0000 (https:)",
        "Setting port with middle U+0000 (https:)",
        "Setting port with trailing U+0000 (https:)",
        "Setting protocol with leading U+0009 (https:)",
        "Setting protocol with U+0009 before inserted colon (https:)",
        "Setting host with leading U+0009 (https:)",
        "Setting hostname with leading U+0009 (https:)",
        "Setting host with middle U+0009 (https:)",
        "Setting hostname with middle U+0009 (https:)",
        "Setting host with trailing U+0009 (https:)",
        "Setting hostname with trailing U+0009 (https:)",
        "Setting port with leading U+0009 (https:)",
        "Setting port with middle U+0009 (https:)",
        "Setting port with trailing U+0009 (https:)",
        "Setting pathname with leading U+0009 (https:)",
        "Setting pathname with middle U+0009 (https:)",
        "Setting pathname with trailing U+0009 (https:)",
        "Setting search with leading U+0009 (https:)",
        "Setting search with middle U+0009 (https:)",
        "Setting search with trailing U+0009 (https:)",
        "Setting hash with leading U+0009 (https:)",
        "Setting hash with middle U+0009 (https:)",
        "Setting hash with trailing U+0009 (https:)",
        "Setting protocol with leading U+000A (https:)",
        "Setting protocol with U+000A before inserted colon (https:)",
        "Setting host with leading U+000A (https:)",
        "Setting hostname with leading U+000A (https:)",
        "Setting host with middle U+000A (https:)",
        "Setting hostname with middle U+000A (https:)",
        "Setting host with trailing U+000A (https:)",
        "Setting hostname with trailing U+000A (https:)",
        "Setting port with leading U+000A (https:)",
        "Setting port with middle U+000A (https:)",
        "Setting port with trailing U+000A (https:)",
        "Setting pathname with leading U+000A (https:)",
        "Setting pathname with middle U+000A (https:)",
        "Setting pathname with trailing U+000A (https:)",
        "Setting search with leading U+000A (https:)",
        "Setting search with middle U+000A (https:)",
        "Setting search with trailing U+000A (https:)",
        "Setting hash with leading U+000A (https:)",
        "Setting hash with middle U+000A (https:)",
        "Setting hash with trailing U+000A (https:)",
        "Setting protocol with leading U+000D (https:)",
        "Setting protocol with U+000D before inserted colon (https:)",
        "Setting host with leading U+000D (https:)",
        "Setting hostname with leading U+000D (https:)",
        "Setting host with middle U+000D (https:)",
        "Setting hostname with middle U+000D (https:)",
        "Setting host with trailing U+000D (https:)",
        "Setting hostname with trailing U+000D (https:)",
        "Setting port with leading U+000D (https:)",
        "Setting port with middle U+000D (https:)",
        "Setting port with trailing U+000D (https:)",
        "Setting pathname with leading U+000D (https:)",
        "Setting pathname with middle U+000D (https:)",
        "Setting pathname with trailing U+000D (https:)",
        "Setting search with leading U+000D (https:)",
        "Setting search with middle U+000D (https:)",
        "Setting search with trailing U+000D (https:)",
        "Setting hash with leading U+000D (https:)",
        "Setting hash with middle U+000D (https:)",
        "Setting hash with trailing U+000D (https:)",
        "Setting protocol with leading U+001F (https:)",
        "Setting protocol with U+001F before inserted colon (https:)",
        "Setting host with leading U+001F (https:)",
        "Setting host with middle U+001F (https:)",
        "Setting host with trailing U+001F (https:)",
        "Setting port with middle U+001F (https:)",
        "Setting port with trailing U+001F (https:)",
        "Setting protocol with leading U+0000 (wpt++:)",
        "Setting protocol with U+0000 before inserted colon (wpt++:)",
        "Setting host with leading U+0000 (wpt++:)",
        "Setting host with middle U+0000 (wpt++:)",
        "Setting host with trailing U+0000 (wpt++:)",
        "Setting port with middle U+0000 (wpt++:)",
        "Setting port with trailing U+0000 (wpt++:)",
        "Setting pathname with leading U+0000 (wpt++:)",
        "Setting pathname with middle U+0000 (wpt++:)",
        "Setting pathname with trailing U+0000 (wpt++:)",
        "Setting protocol with leading U+0009 (wpt++:)",
        "Setting protocol with U+0009 before inserted colon (wpt++:)",
        "Setting host with leading U+0009 (wpt++:)",
        "Setting hostname with leading U+0009 (wpt++:)",
        "Setting host with middle U+0009 (wpt++:)",
        "Setting hostname with middle U+0009 (wpt++:)",
        "Setting host with trailing U+0009 (wpt++:)",
        "Setting hostname with trailing U+0009 (wpt++:)",
        "Setting port with leading U+0009 (wpt++:)",
        "Setting port with middle U+0009 (wpt++:)",
        "Setting port with trailing U+0009 (wpt++:)",
        "Setting pathname with leading U+0009 (wpt++:)",
        "Setting pathname with middle U+0009 (wpt++:)",
        "Setting pathname with trailing U+0009 (wpt++:)",
        "Setting search with leading U+0009 (wpt++:)",
        "Setting search with middle U+0009 (wpt++:)",
        "Setting search with trailing U+0009 (wpt++:)",
        "Setting hash with leading U+0009 (wpt++:)",
        "Setting hash with middle U+0009 (wpt++:)",
        "Setting hash with trailing U+0009 (wpt++:)",
        "Setting protocol with leading U+000A (wpt++:)",
        "Setting protocol with U+000A before inserted colon (wpt++:)",
        "Setting host with leading U+000A (wpt++:)",
        "Setting hostname with leading U+000A (wpt++:)",
        "Setting host with middle U+000A (wpt++:)",
        "Setting hostname with middle U+000A (wpt++:)",
        "Setting host with trailing U+000A (wpt++:)",
        "Setting hostname with trailing U+000A (wpt++:)",
        "Setting port with leading U+000A (wpt++:)",
        "Setting port with middle U+000A (wpt++:)",
        "Setting port with trailing U+000A (wpt++:)",
        "Setting pathname with leading U+000A (wpt++:)",
        "Setting pathname with middle U+000A (wpt++:)",
        "Setting pathname with trailing U+000A (wpt++:)",
        "Setting search with leading U+000A (wpt++:)",
        "Setting search with middle U+000A (wpt++:)",
        "Setting search with trailing U+000A (wpt++:)",
        "Setting hash with leading U+000A (wpt++:)",
        "Setting hash with middle U+000A (wpt++:)",
        "Setting hash with trailing U+000A (wpt++:)",
        "Setting protocol with leading U+000D (wpt++:)",
        "Setting protocol with U+000D before inserted colon (wpt++:)",
        "Setting host with leading U+000D (wpt++:)",
        "Setting hostname with leading U+000D (wpt++:)",
        "Setting host with middle U+000D (wpt++:)",
        "Setting hostname with middle U+000D (wpt++:)",
        "Setting host with trailing U+000D (wpt++:)",
        "Setting hostname with trailing U+000D (wpt++:)",
        "Setting port with leading U+000D (wpt++:)",
        "Setting port with middle U+000D (wpt++:)",
        "Setting port with trailing U+000D (wpt++:)",
        "Setting pathname with leading U+000D (wpt++:)",
        "Setting pathname with middle U+000D (wpt++:)",
        "Setting pathname with trailing U+000D (wpt++:)",
        "Setting search with leading U+000D (wpt++:)",
        "Setting search with middle U+000D (wpt++:)",
        "Setting search with trailing U+000D (wpt++:)",
        "Setting hash with leading U+000D (wpt++:)",
        "Setting hash with middle U+000D (wpt++:)",
        "Setting hash with trailing U+000D (wpt++:)",
        "Setting protocol with leading U+001F (wpt++:)",
        "Setting protocol with U+001F before inserted colon (wpt++:)",
        "Setting host with leading U+001F (wpt++:)",
        "Setting host with middle U+001F (wpt++:)",
        "Setting host with trailing U+001F (wpt++:)",
        "Setting port with middle U+001F (wpt++:)",
        "Setting port with trailing U+001F (wpt++:)",
        "Setting pathname with leading U+001F (wpt++:)",
        "Setting pathname with middle U+001F (wpt++:)",
        "Setting pathname with trailing U+001F (wpt++:)"
      ]
    },
    "url-tojson",
    {
      "name": "urlencoded-parser",
      "expectFail": [
        "URLSearchParams constructed with: %EF%BB%BFtest=%EF%BB%BF",
        "request.formData() with input: test=",
        "response.formData() with input: test=",
        "request.formData() with input: %FE%FF",
        "response.formData() with input: %FE%FF",
        "request.formData() with input: %FF%FE",
        "response.formData() with input: %FF%FE",
        "request.formData() with input: %C2",
        "response.formData() with input: %C2",
        "request.formData() with input: %C2x",
        "response.formData() with input: %C2x",
        "request.formData() with input: _charset_=windows-1252&test=%C2x",
        "response.formData() with input: _charset_=windows-1252&test=%C2x",
        "request.formData() with input: %=a",
        "response.formData() with input: %=a",
        "request.formData() with input: %a=a",
        "response.formData() with input: %a=a",
        "request.formData() with input: %a_=a",
        "response.formData() with input: %a_=a",
        "request.formData() with input: id=0&value=%",
        "response.formData() with input: id=0&value=%",
        "request.formData() with input: b=%2sf%2a",
        "response.formData() with input: b=%2sf%2a",
        "request.formData() with input: b=%2%2af%2a",
        "response.formData() with input: b=%2%2af%2a",
        "request.formData() with input: b=%%2a",
        "response.formData() with input: b=%%2a"
      ]
    },
    "urlsearchparams-append",
    {
      "name": "urlsearchparams-constructor",
      "expectFail": [
        "URLSearchParams constructor, empty string as argument",
        "Construct with 2 unpaired surrogates (no trailing)",
        "Construct with 3 unpaired surrogates (no leading)",
        "Construct with object with NULL, non-ASCII, and surrogate keys"
      ]
    },
    "urlsearchparams-delete",
    {
      "name": "urlsearchparams-foreach",
      "expectFail": [
        "For-of Check",
        "delete next param during iteration",
        "delete current param during iteration",
        "delete every param seen during iteration"
      ]
    },
    "urlsearchparams-get",
    "urlsearchparams-getall",
    "urlsearchparams-has",
    "urlsearchparams-set",
    "urlsearchparams-sort",
    "urlsearchparams-stringifier"
  ]
}