diff --git a/Makefile b/Makefile
index 4dfced1c8de07d..71f12062dd92e9 100644
--- a/Makefile
+++ b/Makefile
@@ -301,7 +301,6 @@ coverage-report-js: ## Report JavaScript coverage results.
 
 cctest: all ## Run the C++ tests using the built `cctest` executable.
 	@out/$(BUILDTYPE)/$@ --gtest_filter=$(GTEST_FILTER)
-	'$(OUT_NODE)' ./test/embedding/test-embedding.js
 
 .PHONY: list-gtests
 list-gtests: ## List all available C++ gtests.
@@ -571,7 +570,7 @@ test-all-suites: | clear-stalled test-build bench-addons-build doc-only ## Run a
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) --mode=$(BUILDTYPE_LOWER) test/*
 
 JS_SUITES ?= default
-NATIVE_SUITES ?= addons js-native-api node-api
+NATIVE_SUITES ?= addons js-native-api node-api embedding
 # CI_* variables should be kept synchronized with the ones in vcbuild.bat
 CI_NATIVE_SUITES ?= $(NATIVE_SUITES) benchmark
 CI_JS_SUITES ?= $(JS_SUITES) pummel
@@ -613,7 +612,6 @@ test-ci: | clear-stalled bench-addons-build build-addons build-js-native-api-tes
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) -p tap --logfile test.tap \
 		--mode=$(BUILDTYPE_LOWER) --flaky-tests=$(FLAKY_TESTS) \
 		$(TEST_CI_ARGS) $(CI_JS_SUITES) $(CI_NATIVE_SUITES) $(CI_DOC)
-	'$(OUT_NODE)' ./test/embedding/test-embedding.js
 	$(info Clean up any leftover processes, error if found.)
 	ps awwx | grep Release/node | grep -v grep | cat
 	@PS_OUT=`ps awwx | grep Release/node | grep -v grep | awk '{print $$1}'`; \
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 40dafb59687b28..0bff0763fcf58f 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -542,6 +542,12 @@ class ModuleLoader {
    */
   #getOrCreateModuleJobAfterResolve(parentURL, resolveResult, request, requestType) {
     const { url, format } = resolveResult;
+
+    if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
+      const type = requestType === kRequireInImportedCJS ? 'require' : 'import';
+      process.send({ [`watch:${type}`]: [url] });
+    }
+
     // TODO(joyeecheung): update the module requests to use importAttributes as property names.
     const importAttributes = resolveResult.importAttributes ?? request.attributes;
     let job = this.loadCache.get(url, importAttributes.type);
@@ -570,11 +576,6 @@ class ModuleLoader {
       assert(moduleOrModulePromise instanceof ModuleWrap, `Expected ModuleWrap for loading ${url}`);
     }
 
-    if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
-      const type = requestType === kRequireInImportedCJS ? 'require' : 'import';
-      process.send({ [`watch:${type}`]: [url] });
-    }
-
     const { ModuleJob, ModuleJobSync } = require('internal/modules/esm/module_job');
     // TODO(joyeecheung): use ModuleJobSync for kRequireInImportedCJS too.
     const ModuleJobCtor = (requestType === kImportInRequiredESM ? ModuleJobSync : ModuleJob);
diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index b9efc4c439dcf0..56a72c047d8d68 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -35,6 +35,7 @@ Last update:
 - wasm/webapi: https://github.com/web-platform-tests/wpt/tree/fd1b23eeaa/wasm/webapi
 - web-locks: https://github.com/web-platform-tests/wpt/tree/10a122a6bc/web-locks
 - WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/1e4933113d/WebCryptoAPI
+- webidl: https://github.com/web-platform-tests/wpt/tree/63ca529a02/webidl
 - webidl/ecmascript-binding/es-exceptions: https://github.com/web-platform-tests/wpt/tree/2f96fa1996/webidl/ecmascript-binding/es-exceptions
 - webmessaging/broadcastchannel: https://github.com/web-platform-tests/wpt/tree/6495c91853/webmessaging/broadcastchannel
 - webstorage: https://github.com/web-platform-tests/wpt/tree/1d2c5fb36a/webstorage
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index e23cf07cf49863..72ce782e262d21 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -99,6 +99,10 @@
     "commit": "1e4933113d2028e092d07a9e865db8f606b21026",
     "path": "WebCryptoAPI"
   },
+  "webidl": {
+    "commit": "63ca529a021fec15b2996db82fd7dd04c11abe85",
+    "path": "webidl"
+  },
   "webidl/ecmascript-binding/es-exceptions": {
     "commit": "2f96fa19966d6bc19e979a09479ac8a7aa337c54",
     "path": "webidl/ecmascript-binding/es-exceptions"
diff --git a/test/fixtures/wpt/webidl/META.yml b/test/fixtures/wpt/webidl/META.yml
new file mode 100644
index 00000000000000..9a1192f6704842
--- /dev/null
+++ b/test/fixtures/wpt/webidl/META.yml
@@ -0,0 +1,3 @@
+spec: https://webidl.spec.whatwg.org/
+suggested_reviewers:
+  - yuki3
diff --git a/test/fixtures/wpt/webidl/README.md b/test/fixtures/wpt/webidl/README.md
new file mode 100644
index 00000000000000..136a7649981ea4
--- /dev/null
+++ b/test/fixtures/wpt/webidl/README.md
@@ -0,0 +1 @@
+Tests for the [Web IDL Standard](https://webidl.spec.whatwg.org/).
diff --git a/test/fixtures/wpt/webidl/current-realm.html b/test/fixtures/wpt/webidl/current-realm.html
new file mode 100644
index 00000000000000..29e07d1f79edc0
--- /dev/null
+++ b/test/fixtures/wpt/webidl/current-realm.html
@@ -0,0 +1,168 @@
+<!-- This tests the agreed upon outcome for https://www.w3.org/Bugs/Public/show_bug.cgi?id=24652
+     that has not been reflected in the IDL standard yet due to lack of editing resources.
+
+     TODO: https://github.com/w3c/webcrypto/issues/85 -->
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Current Realm</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="log"></div>
+<iframe srcdoc="<body test>"></iframe>
+<script>
+ setup({explicit_done:true})
+
+ function isObjectFromGlobal(object, global) {
+   return object instanceof global.Object;
+ }
+ function assert_global(obj) {
+   assert_false(isObjectFromGlobal(obj, self), obj + " should not be from top-level Realm")
+   assert_true(isObjectFromGlobal(obj, self[0]), obj + " should be from <iframe> Realm")
+ }
+
+ onload = function() {
+   [["querySelectorAll", "test"],
+    ["createElement", "x"],
+    ["createElementNS", null, "x"],
+    ["createDocumentFragment"],
+    ["createTextNode", "test"],
+    ["createComment", "test"],
+    ["createProcessingInstruction", "x", "x"],
+    ["createAttribute", "x"],
+    ["createAttributeNS", "x", "x"],
+    ["createEvent", "Event"],
+    ["createRange"],
+    ["createNodeIterator", document.head],
+    ["createTreeWalker", document.head]].forEach(function(val) {
+     test(function() {
+       const method = val.shift();
+       let obj = self[0].document[method](...val);
+       assert_global(obj)
+
+       obj = Document.prototype[method].call(self[0].document, ...val);
+       assert_global(obj)
+     }, val[0])
+   })
+
+   ;["Request", "Response"].forEach(val => {
+     test(() => {
+       const obj = new self[0][val]("about:blank");
+       assert_global(obj);
+
+       const cloneObj = obj.clone();
+       assert_global(cloneObj);
+
+       const involvedCloneObj = self[val].prototype["clone"].call(cloneObj);
+       assert_global(cloneObj);
+     }, val)
+   })
+
+   // Note: these are not [NewObject] and can be cached. But across globals?
+   ;[["getElementsByTagName", "x"],
+     ["getElementsByTagNameNS", null, "x"],
+     ["getElementsByClassName", "x"]].forEach(function(val) {
+     test(function() {
+       const method = val.shift();
+       const obj = self[0].document[method](...val);
+       assert_global(obj)
+
+       const obj2 = Document.prototype[method].call(self[0].document, ...val);
+       assert_global(obj)
+
+       assert_equals(obj, obj2) // XXX this might be controversial
+     }, val[0])
+   })
+
+   ;[["createDocumentType", "x", "", ""],
+     ["createDocument", null, "", null],
+     ["createHTMLDocument", "x"]].forEach(function(val) {
+     test(function() {
+       const method = val.shift();
+       let obj = self[0].document.implementation[method](...val);
+       assert_global(obj)
+
+       obj = DOMImplementation.prototype[method].call(self[0].document.implementation, ...val);
+       assert_global(obj)
+     }, val[0])
+   })
+
+   ;[["item", 0],
+     ["getNamedItem", "test"],
+     ["getNamedItemNS", null, "test"]].forEach(function(val) {
+     test(function() {
+       const method = val.shift();
+       const obj = self[0].document.body.attributes[method](...val);
+       assert_global(obj)
+
+       const obj2 = NamedNodeMap.prototype[method].call(self[0].document.body.attributes, ...val);
+       assert_global(obj)
+
+       assert_equals(obj, obj2)
+     }, "NamedNodeMap " + val[0])
+   })
+
+   test(function() {
+     var c = self[0].document.createTextNode(""),
+         obj = c.splitText(0)
+     assert_global(obj)
+
+     obj = Text.prototype.splitText.call(c, "")
+     assert_global(obj)
+   }, "splitText")
+
+   ;["extractContents",
+     "cloneContents",
+     "cloneRange"].forEach(function(val) {
+     test(function() {
+       var c = self[0].document.createRange(),
+           obj = c[val]()
+       assert_global(obj)
+
+       obj = Range.prototype[val].call(c)
+       assert_global(obj)
+     }, val)
+   })
+
+   ;["2d", "webgl"].forEach(function(val) {
+     test(function() {
+       var c = self[0].document.createElement("canvas"),
+           obj = c.getContext(val)
+
+       // WebGL might not be enabled in this environment
+       if (!obj && val === "webgl") {
+         return;
+       }
+
+       assert_global(obj)
+       obj = HTMLCanvasElement.prototype.getContext.call(c, val)
+       assert_global(obj)
+     }, "getContext " + val)
+   })
+
+   ;[["createImageData", 5, 5],
+     ["getImageData", 5, 5, 5, 5]].forEach(function(val) {
+     test(function() {
+       const method = val.shift();
+       const c = self[0].document.createElement("canvas").getContext("2d");
+       let obj = c[method](...val);
+       assert_global(obj)
+       assert_global(obj.data)
+
+       obj = CanvasRenderingContext2D.prototype[method].call(c, ...val);
+       assert_global(obj)
+       assert_global(obj.data)
+     }, val[0])
+   })
+
+   test(function() {
+     var c = new self[0].FontFace("test", "about:blank"),
+         obj = c.load()
+     assert_global(obj)
+
+     obj = FontFace.prototype.load.call(c)
+     assert_global(obj)
+   }, "FontFace's load()")
+
+   done()
+ }
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/allow-resizable.html b/test/fixtures/wpt/webidl/ecmascript-binding/allow-resizable.html
new file mode 100644
index 00000000000000..54daa57bce676a
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/allow-resizable.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/sab.js"></script>
+<script type="module">
+test(t => {
+  // Fixed-length ABs should not throw
+  const ab = new ArrayBuffer(16);
+  new Response(new Uint8Array(ab));
+
+  const rab = new ArrayBuffer(16, { maxByteLength: 1024 });
+  // Response doesn't have [AllowResizable] or [AllowShared]
+  assert_throws_js(TypeError, () => {
+    new Response(new Uint8Array(rab));
+  });
+}, "APIs without [AllowResizable] throw when passed resizable ArrayBuffers");
+
+test(t => {
+  const enc = new TextEncoder();
+
+  // Fixed-length SABs should not throw
+  const sab = createBuffer('SharedArrayBuffer', 16);
+  enc.encodeInto("foobar", new Uint8Array(sab));
+
+  const gsab = createBuffer('SharedArrayBuffer', 16, { maxByteLength: 1024 });
+  // TextEncoder.encodeInto doesn't have [AllowResizable] but has [AllowShared]
+  assert_throws_js(TypeError, () => {
+    enc.encodeInto("foobar", new Uint8Array(gsab));
+  });
+}, "APIs with [AllowShared] but without [AllowResizable] throw when passed growable SharedArrayBuffers");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/attributes-accessors-unique-function-objects.html b/test/fixtures/wpt/webidl/ecmascript-binding/attributes-accessors-unique-function-objects.html
new file mode 100644
index 00000000000000..167f55bcef7ead
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/attributes-accessors-unique-function-objects.html
@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>All attributes accessors are unique function objects</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#idl-interface-mixins">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+"use strict";
+
+test(() => {
+  const seenPrototypes = new WeakSet([Function.prototype]);
+  const seenFunctions = new WeakMap();
+
+  for (const windowKey of Object.getOwnPropertyNames(window)) {
+    const windowValue = window[windowKey];
+    if (typeof windowValue !== "function") continue;
+
+    const {prototype} = windowValue;
+    if (!prototype || seenPrototypes.has(prototype)) continue;
+    seenPrototypes.add(prototype);
+
+    for (const key of Object.getOwnPropertyNames(prototype)) {
+      const assert_not_seen = (fn, field) => {
+        const fnInfo = `${windowKey}.${key}.${field}`;
+        assert_equals(seenFunctions.get(fn), undefined, fnInfo);
+        seenFunctions.set(fn, fnInfo);
+      };
+
+      const desc = Object.getOwnPropertyDescriptor(prototype, key);
+      if (desc.get) assert_not_seen(desc.get, "[[Get]]");
+      if (desc.set) assert_not_seen(desc.set, "[[Set]]");
+    }
+  }
+}, "For attributes, each copy of the accessor property has distinct built-in function objects for its getters and setters.");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/builtin-function-properties.any.js b/test/fixtures/wpt/webidl/ecmascript-binding/builtin-function-properties.any.js
new file mode 100644
index 00000000000000..885bb441ead442
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/builtin-function-properties.any.js
@@ -0,0 +1,23 @@
+"use strict";
+
+test(() => {
+  const ownPropKeys = Reflect.ownKeys(Blob).slice(0, 3);
+  assert_array_equals(ownPropKeys, ["length", "name", "prototype"]);
+}, 'Constructor property enumeration order of "length", "name", and "prototype"');
+
+test(() => {
+  assert_own_property(Blob.prototype, "slice");
+
+  const ownPropKeys = Reflect.ownKeys(Blob.prototype.slice).slice(0, 2);
+  assert_array_equals(ownPropKeys, ["length", "name"]);
+}, 'Method property enumeration order of "length" and "name"');
+
+test(() => {
+  assert_own_property(Blob.prototype, "size");
+
+  const desc = Reflect.getOwnPropertyDescriptor(Blob.prototype, "size");
+  assert_equals(typeof desc.get, "function");
+
+  const ownPropKeys = Reflect.ownKeys(desc.get).slice(0, 2);
+  assert_array_equals(ownPropKeys, ["length", "name"]);
+}, 'Getter property enumeration order of "length" and "name"');
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/class-string-interface.any.js b/test/fixtures/wpt/webidl/ecmascript-binding/class-string-interface.any.js
new file mode 100644
index 00000000000000..ee792d5368389b
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/class-string-interface.any.js
@@ -0,0 +1,62 @@
+"use strict";
+
+test(() => {
+  assert_own_property(Blob.prototype, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(Blob.prototype, Symbol.toStringTag);
+  assert_equals(propDesc.value, "Blob", "value");
+  assert_equals(propDesc.configurable, true, "configurable");
+  assert_equals(propDesc.enumerable, false, "enumerable");
+  assert_equals(propDesc.writable, false, "writable");
+}, "@@toStringTag exists on the prototype with the appropriate descriptor");
+
+test(() => {
+  assert_not_own_property(new Blob(), Symbol.toStringTag);
+}, "@@toStringTag must not exist on the instance");
+
+test(() => {
+  assert_equals(Object.prototype.toString.call(Blob.prototype), "[object Blob]");
+}, "Object.prototype.toString applied to the prototype");
+
+test(() => {
+  assert_equals(Object.prototype.toString.call(new Blob()), "[object Blob]");
+}, "Object.prototype.toString applied to an instance");
+
+test(t => {
+  assert_own_property(Blob.prototype, Symbol.toStringTag, "Precondition for this test: @@toStringTag on the prototype");
+
+  t.add_cleanup(() => {
+    Object.defineProperty(Blob.prototype, Symbol.toStringTag, { value: "Blob" });
+  });
+
+  Object.defineProperty(Blob.prototype, Symbol.toStringTag, { value: "NotABlob" });
+  assert_equals(Object.prototype.toString.call(Blob.prototype), "[object NotABlob]", "prototype");
+  assert_equals(Object.prototype.toString.call(new Blob()), "[object NotABlob]", "instance");
+}, "Object.prototype.toString applied after modifying the prototype's @@toStringTag");
+
+test(t => {
+  const instance = new Blob();
+  assert_not_own_property(instance, Symbol.toStringTag, "Precondition for this test: no @@toStringTag on the instance");
+
+  Object.defineProperty(instance, Symbol.toStringTag, { value: "NotABlob" });
+  assert_equals(Object.prototype.toString.call(instance), "[object NotABlob]");
+}, "Object.prototype.toString applied to the instance after modifying the instance's @@toStringTag");
+
+// Chrome had a bug (https://bugs.chromium.org/p/chromium/issues/detail?id=793406) where if there
+// was no @@toStringTag in the prototype, it would fall back to a magic class string. This tests
+// that the bug is fixed.
+
+test(() => {
+  const instance = new Blob();
+  Object.setPrototypeOf(instance, null);
+
+  assert_equals(Object.prototype.toString.call(instance), "[object Object]");
+}, "Object.prototype.toString applied to a null-prototype instance");
+
+// This test must be last.
+test(() => {
+  delete Blob.prototype[Symbol.toStringTag];
+
+  assert_equals(Object.prototype.toString.call(Blob.prototype), "[object Object]", "prototype");
+  assert_equals(Object.prototype.toString.call(new Blob()), "[object Object]", "instance");
+}, "Object.prototype.toString applied after deleting @@toStringTag");
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/class-string-iterator-prototype-object.any.js b/test/fixtures/wpt/webidl/ecmascript-binding/class-string-iterator-prototype-object.any.js
new file mode 100644
index 00000000000000..5ca549d69cff81
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/class-string-iterator-prototype-object.any.js
@@ -0,0 +1,51 @@
+"use strict";
+
+const iteratorProto = Object.getPrototypeOf((new URLSearchParams()).entries());
+
+test(() => {
+  assert_own_property(iteratorProto, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(iteratorProto, Symbol.toStringTag);
+  assert_equals(propDesc.value, "URLSearchParams Iterator", "value");
+  assert_equals(propDesc.configurable, true, "configurable");
+  assert_equals(propDesc.enumerable, false, "enumerable");
+  assert_equals(propDesc.writable, false, "writable");
+}, "@@toStringTag exists with the appropriate descriptor");
+
+test(() => {
+  assert_equals(Object.prototype.toString.call(iteratorProto), "[object URLSearchParams Iterator]");
+}, "Object.prototype.toString");
+
+test(t => {
+  assert_own_property(iteratorProto, Symbol.toStringTag, "Precondition for this test: @@toStringTag exists");
+
+  t.add_cleanup(() => {
+    Object.defineProperty(iteratorProto, Symbol.toStringTag, { value: "URLSearchParams Iterator" });
+  });
+
+  Object.defineProperty(iteratorProto, Symbol.toStringTag, { value: "Not URLSearchParams Iterator" });
+  assert_equals(Object.prototype.toString.call(iteratorProto), "[object Not URLSearchParams Iterator]");
+}, "Object.prototype.toString applied after modifying @@toStringTag");
+
+// Chrome had a bug (https://bugs.chromium.org/p/chromium/issues/detail?id=793406) where if there
+// was no @@toStringTag, it would fall back to a magic class string. This tests that the bug is
+// fixed.
+
+test(() => {
+  const iterator = (new URLSearchParams()).keys();
+  assert_equals(Object.prototype.toString.call(iterator), "[object URLSearchParams Iterator]");
+
+  Object.setPrototypeOf(iterator, null);
+  assert_equals(Object.prototype.toString.call(iterator), "[object Object]");
+}, "Object.prototype.toString applied to a null-prototype instance");
+
+test(t => {
+  const proto = Object.getPrototypeOf(iteratorProto);
+  t.add_cleanup(() => {
+    Object.setPrototypeOf(iteratorProto, proto);
+  });
+
+  Object.setPrototypeOf(iteratorProto, null);
+
+  assert_equals(Object.prototype.toString.call(iteratorProto), "[object URLSearchParams Iterator]");
+}, "Object.prototype.toString applied after nulling the prototype");
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/class-string-named-properties-object.window.js b/test/fixtures/wpt/webidl/ecmascript-binding/class-string-named-properties-object.window.js
new file mode 100644
index 00000000000000..a427a2f8142e53
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/class-string-named-properties-object.window.js
@@ -0,0 +1,23 @@
+"use strict";
+
+const namedPropertiesObject = Object.getPrototypeOf(Window.prototype);
+
+test(() => {
+  assert_own_property(namedPropertiesObject, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(namedPropertiesObject, Symbol.toStringTag);
+  assert_equals(propDesc.value, "WindowProperties", "value");
+  assert_equals(propDesc.configurable, true, "configurable");
+  assert_equals(propDesc.enumerable, false, "enumerable");
+  assert_equals(propDesc.writable, false, "writable");
+}, "@@toStringTag exists with the appropriate descriptor");
+
+test(() => {
+  assert_equals(Object.prototype.toString.call(namedPropertiesObject), "[object WindowProperties]");
+}, "Object.prototype.toString");
+
+// Chrome had a bug (https://bugs.chromium.org/p/chromium/issues/detail?id=793406) where if there
+// was no @@toStringTag, it would fall back to a magic class string. Tests for this are present in
+// the sibling class-string*.any.js tests. However, the named properties object always fails calls
+// to [[DefineOwnProperty]] or [[SetPrototypeOf]] per the Web IDL spec, so there is no way to
+// trigger the buggy behavior for it.
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/constructors.html b/test/fixtures/wpt/webidl/ecmascript-binding/constructors.html
new file mode 100644
index 00000000000000..61993a6200ed56
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/constructors.html
@@ -0,0 +1,132 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Realm for constructed objects</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id=log></div>
+<script>
+function object_realm(dp) {
+  // Note that browsers use the URL of the relevant global object's associated
+  // Document.
+  // https://github.com/w3c/DOM-Parsing/issues/46
+  var url = DOMParser.prototype.parseFromString.call(dp, "x", "text/html").documentURI;
+  var file = url.slice(url.lastIndexOf("/") + 1);
+  switch (file) {
+  case "constructors.html":
+    return "parent window";
+  case "constructors-support.html":
+    return "child window";
+  default:
+    return "???";
+  }
+}
+
+async_test(function() {
+  var iframe = document.createElement("iframe");
+  iframe.onload = this.step_func_done(function() {
+    var child = iframe.contentWindow;
+    test(function() {
+      var dp = new DOMParser();
+      assert_equals(Object.getPrototypeOf(dp), DOMParser.prototype);
+      assert_equals(object_realm(dp), "parent window");
+    }, "Normal constructor in parent window");
+
+    test(function() {
+      var dp = new child.DOMParser();
+      assert_equals(Object.getPrototypeOf(dp), child.DOMParser.prototype);
+      assert_equals(object_realm(dp), "child window");
+    }, "Normal constructor in child window");
+
+    test(function() {
+      var dp = Reflect.construct(child.DOMParser, [], DOMParser);
+      assert_equals(Object.getPrototypeOf(dp), DOMParser.prototype);
+      assert_equals(object_realm(dp), "child window");
+    }, "Constructor in child window with normal NewTarget from parent window");
+
+    test(function() {
+      var dp = Reflect.construct(DOMParser, [], child.DOMParser);
+      assert_equals(Object.getPrototypeOf(dp), child.DOMParser.prototype);
+      assert_equals(object_realm(dp), "parent window");
+    }, "Constructor in parent window with normal NewTarget from child window");
+
+    test(function() {
+      class DOMParserSubclass extends DOMParser {}
+      var dp = new DOMParserSubclass();
+      assert_equals(Object.getPrototypeOf(dp), DOMParserSubclass.prototype);
+      assert_equals(object_realm(dp), "parent window");
+    }, "Subclass constructor in parent window");
+
+    test(function() {
+      var dp = new child.DOMParserSubclass();
+      assert_equals(Object.getPrototypeOf(dp), child.DOMParserSubclass.prototype);
+      assert_equals(object_realm(dp), "child window");
+    }, "Subclass constructor in child window");
+
+    test(function() {
+      class ForeignDOMParserSubclass extends child.DOMParser {}
+      var dp = new ForeignDOMParserSubclass();
+      assert_equals(Object.getPrototypeOf(dp), ForeignDOMParserSubclass.prototype);
+      assert_equals(object_realm(dp), "child window");
+    }, "Subclass constructor in parent window with parent class in child window");
+
+    test(function() {
+      var dp = new child.ForeignDOMParserSubclass();
+      assert_equals(Object.getPrototypeOf(dp), child.ForeignDOMParserSubclass.prototype);
+      assert_equals(object_realm(dp), "parent window");
+    }, "Subclass constructor in child window with parent class in parent window");
+
+    test(function() {
+      var badNewTarget = function() {};
+      badNewTarget.prototype = 7;
+
+      var dp = Reflect.construct(child.DOMParser, [], badNewTarget);
+      assert_equals(Object.getPrototypeOf(dp), DOMParser.prototype);
+      assert_equals(object_realm(dp), "child window");
+    }, "Constructor in child window with bad NewTarget from parent window");
+
+    test(function() {
+      var dp = Reflect.construct(DOMParser, [], child.badNewTarget);
+      assert_equals(Object.getPrototypeOf(dp), child.DOMParser.prototype);
+      assert_equals(object_realm(dp), "parent window");
+    }, "Constructor in parent window with bad NewTarget from child window");
+
+    test(function() {
+      var badNewTarget = Function.prototype.bind.call(new child.Function());
+      badNewTarget.prototype = 7;
+
+      var dp = Reflect.construct(DOMParser, [], badNewTarget);
+      assert_equals(Object.getPrototypeOf(dp), child.DOMParser.prototype);
+      assert_equals(object_realm(dp), "parent window");
+    }, "Constructor in parent window with bad NewTarget from parent window that's a bound child window function");
+
+    test(function() {
+      var badNewTarget = child.Function.prototype.bind.call(new Function());
+      badNewTarget.prototype = 7;
+
+      var dp = Reflect.construct(child.DOMParser, [], badNewTarget);
+      assert_equals(Object.getPrototypeOf(dp), DOMParser.prototype);
+      assert_equals(object_realm(dp), "child window");
+    }, "Constructor in child window with bad NewTarget from child window that's a bound parent window function");
+
+    test(function() {
+      var badNewTarget = new Proxy(new child.Function(), {});
+      badNewTarget.prototype = 7;
+
+      var dp = Reflect.construct(DOMParser, [], badNewTarget);
+      assert_equals(Object.getPrototypeOf(dp), child.DOMParser.prototype);
+      assert_equals(object_realm(dp), "parent window");
+    }, "Constructor in parent window with bad NewTarget from parent window that's a proxy for a child window function");
+
+    test(function() {
+      var badNewTarget = new child.Proxy(new Function(), {});
+      badNewTarget.prototype = 7;
+
+      var dp = Reflect.construct(child.DOMParser, [], badNewTarget);
+      assert_equals(Object.getPrototypeOf(dp), DOMParser.prototype);
+      assert_equals(object_realm(dp), "child window");
+    }, "Constructor in child window with bad NewTarget from child window that's a proxy for a parent window function");
+  });
+  iframe.src = "support/constructors-support.html";
+  document.body.appendChild(iframe);
+});
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/default-iterator-object.html b/test/fixtures/wpt/webidl/ecmascript-binding/default-iterator-object.html
new file mode 100644
index 00000000000000..c7e9188521a2ae
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/default-iterator-object.html
@@ -0,0 +1,27 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Default iterator objects</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(() => {
+  const iterator1 = new URLSearchParams()[Symbol.iterator]();
+  const iterator2 = new URLSearchParams().keys();
+  const iterator3 = new URLSearchParams().values();
+  const iterator4 = new URLSearchParams().entries();
+  assert_equals(Object.getPrototypeOf(iterator1), Object.getPrototypeOf(iterator2));
+  assert_equals(Object.getPrototypeOf(iterator1), Object.getPrototypeOf(iterator3));
+  assert_equals(Object.getPrototypeOf(iterator1), Object.getPrototypeOf(iterator4));
+}, "Default iterator objects for an interface have the same prototype");
+
+test(() => {
+  const iterator = new URLSearchParams().entries();
+  assert_equals(Object.prototype.toString.call(iterator), "[object URLSearchParams Iterator]");
+}, "Object.prototype.toString returns correct value");
+
+test(() => {
+  const iterator = new URLSearchParams().entries();
+  assert_equals(iterator[Symbol.toStringTag], "URLSearchParams Iterator");
+  assert_equals(Object.getOwnPropertyDescriptor(iterator, Symbol.toStringTag), undefined);
+}, "@@toStringTag has correct value from prototype");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/default-toJSON-cross-realm.html b/test/fixtures/wpt/webidl/ecmascript-binding/default-toJSON-cross-realm.html
new file mode 100644
index 00000000000000..79c3097f339b58
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/default-toJSON-cross-realm.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Cross-realm [Default] toJSON() creates result object in its realm</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#default-tojson-steps">
+
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/create-realm.js"></script>
+
+<body>
+<script>
+promise_test(async t => {
+    const other = await createRealm(t);
+    const json = other.DOMRectReadOnly.prototype.toJSON.call(new DOMRectReadOnly());
+
+    assert_equals(Object.getPrototypeOf(json), other.Object.prototype);
+}, "Cross-realm [Default] toJSON() creates result object in its realm");
+
+promise_test(async t => {
+    const other = await createRealm(t);
+    const json = other.DOMQuad.prototype.toJSON.call(new DOMQuad());
+
+    assert_equals(Object.getPrototypeOf(json.p1), DOMPoint.prototype);
+}, "Cross-realm [Default] toJSON() converts its interface attributes to ECMAScript values of correct realm");
+</script>
+</body>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/global-immutable-prototype.any.js b/test/fixtures/wpt/webidl/ecmascript-binding/global-immutable-prototype.any.js
new file mode 100644
index 00000000000000..6291c3ae935608
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/global-immutable-prototype.any.js
@@ -0,0 +1,25 @@
+// META: global=window,worker
+// META: title=Immutability of the global prototype chain
+
+const objects = [];
+setup(() => {
+  for (let object = self; object; object = Object.getPrototypeOf(object)) {
+    objects.push(object);
+  }
+});
+
+test(() => {
+  for (const object of objects) {
+    assert_throws_js(TypeError, () => {
+      Object.setPrototypeOf(object, {});
+    });
+  }
+}, "Setting to a different prototype");
+
+test(() => {
+  for (const object of objects) {
+    const expected = Object.getPrototypeOf(object);
+    Object.setPrototypeOf(object, expected);
+    assert_equals(Object.getPrototypeOf(object), expected);
+  }
+}, "Setting to the same prototype");
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/global-mutable-prototype.any.js b/test/fixtures/wpt/webidl/ecmascript-binding/global-mutable-prototype.any.js
new file mode 100644
index 00000000000000..eba96e9adf4647
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/global-mutable-prototype.any.js
@@ -0,0 +1,27 @@
+// META: global=shadowrealm
+// META: title=Mutability of the global prototype chain
+
+const objects = [];
+setup(() => {
+  for (let object = self; object; object = Object.getPrototypeOf(object)) {
+    objects.push(object);
+  }
+});
+
+test(() => {
+  for (const object of objects) {
+    const proto = Object.getPrototypeOf(object);
+    const plainObject = {};
+    Object.setPrototypeOf(object, plainObject);
+    assert_equals(Object.getPrototypeOf(object), plainObject);
+    Object.setPrototypeOf(object, proto);
+  }
+}, "Setting to a different prototype");
+
+test(() => {
+  for (const object of objects) {
+    const expected = Object.getPrototypeOf(object);
+    Object.setPrototypeOf(object, expected);
+    assert_equals(Object.getPrototypeOf(object), expected);
+  }
+}, "Setting to the same prototype");
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/global-object-implicit-this-value-cross-realm.html b/test/fixtures/wpt/webidl/ecmascript-binding/global-object-implicit-this-value-cross-realm.html
new file mode 100644
index 00000000000000..b9939b801cbd80
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/global-object-implicit-this-value-cross-realm.html
@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Cross-realm getter / setter / operation doesn't use lexical global object if |this| value is incompatible object / null / undefined</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#dfn-attribute-getter">
+<link rel="help" href="https://webidl.spec.whatwg.org/#dfn-attribute-setter">
+<link rel="help" href="https://webidl.spec.whatwg.org/#dfn-create-operation-function">
+
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/create-realm.js"></script>
+
+<body>
+<script>
+promise_test(async t => {
+    const other = await createRealm(t);
+    const notWindow = Object.create(Object.getPrototypeOf(other));
+
+    assert_throws_js(other.TypeError, () => { Object.create(other).window; });
+    assert_throws_js(other.TypeError, () => { Object.getOwnPropertyDescriptor(other, "history").get.call(notWindow); });
+    assert_throws_js(other.TypeError, () => { Reflect.get(other, "screen", notWindow); });
+    assert_throws_js(other.TypeError, () => { new Proxy(other, {}).onclick; });
+}, "Cross-realm global object's getter throws when called on incompatible object");
+
+promise_test(async t => {
+    const other = await createRealm(t);
+    const notWindow = Object.create(Object.getPrototypeOf(other));
+
+    assert_throws_js(other.TypeError, () => { Object.create(other).name = "dummy"; });
+    assert_throws_js(other.TypeError, () => { Object.getOwnPropertyDescriptor(other, "status").set.call(notWindow, other.status); });
+    // parent is [Replaceable]
+    assert_throws_js(other.TypeError, () => { Reflect.set(other, "parent", window, notWindow); });
+    assert_throws_js(other.TypeError, () => { new Proxy(other, {}).location = location; });
+}, "Cross-realm global object's setter throws when called on incompatible object");
+
+promise_test(async t => {
+    const other = await createRealm(t);
+    const notWindow = Object.create(Object.getPrototypeOf(other));
+
+    assert_throws_js(other.TypeError, () => { Object.create(other).focus(); });
+    assert_throws_js(other.TypeError, () => { other.clearInterval.call(notWindow, 0); });
+    assert_throws_js(other.TypeError, () => { Reflect.apply(other.blur, notWindow, []); });
+    assert_throws_js(other.TypeError, () => { new Proxy(other, {}).removeEventListener("foo", () => {}); });
+}, "Cross-realm global object's operation throws when called on incompatible object");
+
+promise_test(async t => {
+    const other = await createRealm(t);
+    const otherNameGetter = Object.getOwnPropertyDescriptor(other, "name").get;
+
+    assert_equals(Reflect.get(other, "self", null), other);
+    assert_equals(Reflect.get(other, "document", undefined), other.document);
+    assert_equals(otherNameGetter.call(null), "dummy");
+    // An engine might have different code path for calling a function from outer scope to implement step 1.b.iii of https://tc39.es/ecma262/#sec-evaluatecall
+    assert_equals((() => otherNameGetter())(), "dummy");
+}, "Cross-realm global object's getter called on null / undefined");
+
+promise_test(async t => {
+    const other = await createRealm(t);
+    const otherLocationSetter = Object.getOwnPropertyDescriptor(other, "location").set;
+    const otherHref = other.location.href;
+    const newSelf = {};
+
+    // self is [Replaceable]
+    assert_true(Reflect.set(other, "self", newSelf, null));
+    assert_true(Reflect.set(other, "name", "newName", undefined));
+
+    otherLocationSetter.call(null, `${otherHref}#foo`);
+    assert_equals(other.location.hash, "#foo");
+    // An engine might have different code path for calling a function from outer scope to implement step 1.b.iii of https://tc39.es/ecma262/#sec-evaluatecall
+    (() => { otherLocationSetter(`${otherHref}#bar`); })();
+    assert_equals(other.location.hash, "#bar");
+
+    // Check these after calling "location" setter make sure no navigation has occurred
+    assert_equals(other.self, newSelf);
+    assert_equals(other.name, "newName");
+}, "Cross-realm global object's setter called on null / undefined");
+
+promise_test(async t => {
+    const other = await createRealm(t);
+    const otherFocus = other.focus;
+    const otherDispatchEvent = other.dispatchEvent;
+
+    assert_equals(document.activeElement, document.body);
+    // An engine might have different code path for calling a function from outer scope to implement step 1.b.iii of https://tc39.es/ecma262/#sec-evaluatecall
+    (() => { otherFocus(); })();
+    assert_equals(document.activeElement.contentWindow, other);
+
+    let caughtEvent;
+    other.addEventListener.call(null, "foo", event => { caughtEvent = event; });
+    const dispatchedEvent = new other.Event("foo");
+    assert_true(otherDispatchEvent(dispatchedEvent));
+    assert_equals(caughtEvent, dispatchedEvent);
+
+    const messagePromise = new EventWatcher(t, other, "message").wait_for("message");
+    other.postMessage.call(null, "foo");
+    assert_equals((await messagePromise).data, "foo");
+}, "Cross-realm global object's operation called on null / undefined");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/global-object-implicit-this-value.any.js b/test/fixtures/wpt/webidl/ecmascript-binding/global-object-implicit-this-value.any.js
new file mode 100644
index 00000000000000..4c159c67519c0b
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/global-object-implicit-this-value.any.js
@@ -0,0 +1,85 @@
+// META: global=window,worker
+
+// https://webidl.spec.whatwg.org/#dfn-attribute-getter (step 1.1.2.1)
+// https://webidl.spec.whatwg.org/#dfn-attribute-setter (step 4.5.1)
+// https://webidl.spec.whatwg.org/#dfn-create-operation-function (step 2.1.2.1)
+
+const notGlobalObject = Object.create(Object.getPrototypeOf(globalThis));
+
+test(() => {
+    assert_throws_js(TypeError, () => { Object.create(globalThis).self; });
+    assert_throws_js(TypeError, () => { getGlobalPropertyDescriptor("location").get.call(notGlobalObject); });
+    assert_throws_js(TypeError, () => { Reflect.get(globalThis, "navigator", notGlobalObject); });
+    assert_throws_js(TypeError, () => { new Proxy(globalThis, {}).onerror; });
+}, "Global object's getter throws when called on incompatible object");
+
+test(() => {
+    assert_throws_js(TypeError, () => { Object.create(globalThis).origin = origin; });
+    assert_throws_js(TypeError, () => { getGlobalPropertyDescriptor("onerror").set.call(notGlobalObject, onerror); });
+    assert_throws_js(TypeError, () => { Reflect.set(globalThis, "onoffline", onoffline, notGlobalObject); });
+    assert_throws_js(TypeError, () => { new Proxy(globalThis, {}).ononline = ononline; });
+}, "Global object's setter throws when called on incompatible object");
+
+test(() => {
+    assert_throws_js(TypeError, () => { Object.create(globalThis).setInterval(() => {}, 100); });
+    assert_throws_js(TypeError, () => { clearTimeout.call(notGlobalObject, () => {}); });
+    assert_throws_js(TypeError, () => { Reflect.apply(btoa, notGlobalObject, [""]); });
+    assert_throws_js(TypeError, () => { new Proxy(globalThis, {}).removeEventListener("foo", () => {}); });
+}, "Global object's operation throws when called on incompatible object");
+
+if (typeof document !== "undefined") {
+    test(() => {
+        assert_throws_js(TypeError, () => { Object.getOwnPropertyDescriptor(window, "document").get.call(document.all); });
+    }, "Global object's getter throws when called on incompatible object (document.all)");
+
+    test(() => {
+        assert_throws_js(TypeError, () => { Object.getOwnPropertyDescriptor(window, "name").set.call(document.all); });
+    }, "Global object's setter throws when called on incompatible object (document.all)");
+
+    test(() => {
+        assert_throws_js(TypeError, () => { focus.call(document.all); });
+    }, "Global object's operation throws when called on incompatible object (document.all)");
+}
+
+// An engine might have different code path for calling a function from outer scope to implement step 1.b.iii of https://tc39.es/ecma262/#sec-evaluatecall
+const locationGetter = getGlobalPropertyDescriptor("location").get;
+test(() => {
+    assert_equals(getGlobalPropertyDescriptor("self").get.call(null), self);
+    assert_equals((() => locationGetter())(), location);
+    assert_equals(Reflect.get(globalThis, "origin", null), origin);
+    assert_equals(Reflect.get(globalThis, "onoffline", undefined), onoffline);
+}, "Global object's getter works when called on null / undefined");
+
+test(() => {
+    const fn = () => {};
+
+    // origin is [Replaceable]
+    getGlobalPropertyDescriptor("origin").set.call(null, "foo");
+    assert_equals(origin, "foo");
+    getGlobalPropertyDescriptor("onerror").set.call(undefined, fn);
+    assert_equals(onerror, fn);
+    assert_true(Reflect.set(globalThis, "onoffline", fn, null));
+    assert_equals(onoffline, fn);
+
+    const ononlineSetter = getGlobalPropertyDescriptor("ononline").set;
+    (() => { ononlineSetter(fn); })();
+    assert_equals(ononline, fn);
+}, "Global object's setter works when called on null / undefined");
+
+// An engine might have different code path for calling a function from outer scope to implement step 1.b.iii of https://tc39.es/ecma262/#sec-evaluatecall
+const __addEventListener = addEventListener;
+test(() => {
+    assert_equals(atob.call(null, ""), "");
+    assert_equals(typeof (0, setInterval)(() => {}, 100), "number");
+
+    (() => { __addEventListener("foo", event => { event.preventDefault(); }); })();
+    const __dispatchEvent = dispatchEvent;
+    (() => { assert_false(__dispatchEvent(new Event("foo", { cancelable: true }))); })();
+}, "Global object's operation works when called on null / undefined");
+
+function getGlobalPropertyDescriptor(key) {
+    for (let obj = globalThis; obj; obj = Object.getPrototypeOf(obj)) {
+        const desc = Object.getOwnPropertyDescriptor(obj, key);
+        if (desc) return desc;
+    }
+}
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/has-instance.html b/test/fixtures/wpt/webidl/ecmascript-binding/has-instance.html
new file mode 100644
index 00000000000000..caf0be47290607
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/has-instance.html
@@ -0,0 +1,26 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>instanceof behavior</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+
+<iframe></iframe>
+
+<script>
+test(function() {
+  var obj = Object.create(Element.prototype);
+  assert_true(obj instanceof Element);
+  assert_true(obj instanceof Node);
+  assert_false(obj instanceof Attr);
+}, "Manually-constructed prototype chains are correctly handled by instanceof");
+
+test(() => {
+  // This tests that the historical override of [[HasInstance]] was removed:
+  // https://github.com/heycam/webidl/pull/356
+  assert_false(document.body instanceof frames[0].Element);
+}, "instanceof must return false across different globals, for platform objects");
+
+test(() => {
+  assert_false(EventTarget.hasOwnProperty(Symbol.hasInstance));
+}, "platform objects do not have Symbol.hasInstance installed");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/interface-object-set-receiver.html b/test/fixtures/wpt/webidl/ecmascript-binding/interface-object-set-receiver.html
new file mode 100644
index 00000000000000..ca75a96bbad52e
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/interface-object-set-receiver.html
@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>window.Interface is defined on [[Set]] receiver</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#define-the-global-property-references">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+"use strict";
+const testValue = Object.freeze(function() {});
+
+test(() => {
+  window.Window = testValue;
+  assert_false(window.propertyIsEnumerable("Window"));
+
+  window.History = testValue;
+  assert_false(window.propertyIsEnumerable("History"));
+
+  window.HTMLDivElement = testValue;
+  assert_false(window.propertyIsEnumerable("HTMLDivElement"))
+}, "Direct [[Set]] preserves [[Enumerable]]: false property attribute");
+
+test(() => {
+  const heir = Object.create(window);
+
+  heir.Location = testValue;
+  assert_equals(heir.Location, testValue);
+  assert_not_equals(window.Location, testValue);
+
+  heir.HTMLDocument = testValue;
+  assert_equals(heir.HTMLDocument, testValue);
+  assert_not_equals(window.HTMLDocument, testValue);
+
+  heir.HTMLPreElement = testValue;
+  assert_equals(heir.HTMLPreElement, testValue);
+  assert_not_equals(window.HTMLPreElement, testValue);
+}, "Prototype chain [[Set]] creates property on receiver");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/interface-object.html b/test/fixtures/wpt/webidl/ecmascript-binding/interface-object.html
new file mode 100644
index 00000000000000..132c61ddaed4a3
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/interface-object.html
@@ -0,0 +1,28 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Interface objects</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(function () {
+    assert_equals(typeof window.Blob, "function")
+    delete window.Blob;
+    assert_equals(window.Blob, undefined);
+}, "An interface object deleted after it has been accessed is undefined");
+
+test(function () {
+    delete window.File;
+    assert_equals(window.File, undefined);
+}, "An interface object deleted before it has been defined is undefined");
+
+test(function () {
+    delete window.ImageData;
+    assert_equals(Object.getOwnPropertyDescriptor(window, "ImageData"), undefined);
+    delete window.ImageData;
+    assert_equals(Object.getOwnPropertyDescriptor(window, "ImageData"), undefined);
+}, "Interface objects deleted multiple times stay deleted");
+
+test(function () {
+    assert_equals(window["abc\udc88"], undefined);
+}, "Fancy property names don't break the resolve hook on Window");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/interface-prototype-constructor-set-receiver.html b/test/fixtures/wpt/webidl/ecmascript-binding/interface-prototype-constructor-set-receiver.html
new file mode 100644
index 00000000000000..64a2da8eb2da2d
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/interface-prototype-constructor-set-receiver.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Interface.prototype.constructor is defined on [[Set]] receiver</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#interface-prototype-object">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+"use strict";
+const testValue = Object.freeze(function() {});
+
+test(() => {
+  Location.prototype.constructor = testValue;
+  assert_false(Location.prototype.propertyIsEnumerable("constructor"));
+
+  HTMLDocument.prototype.constructor = testValue;
+  assert_false(HTMLDocument.prototype.propertyIsEnumerable("constructor"));
+
+  HTMLDivElement.prototype.constructor = testValue;
+  assert_false(HTMLDivElement.prototype.propertyIsEnumerable("constructor"));
+}, "Direct [[Set]] preserves [[Enumerable]]: false property attribute");
+
+test(() => {
+  window.constructor = testValue;
+  assert_equals(window.constructor, testValue);
+  assert_equals(Window.prototype.constructor, Window);
+
+  navigator.constructor = testValue;
+  assert_equals(navigator.constructor, testValue);
+  assert_equals(Navigator.prototype.constructor, Navigator);
+
+  const span = document.createElement("span");
+  span.constructor = testValue;
+  assert_equals(span.constructor, testValue);
+  assert_equals(HTMLSpanElement.prototype.constructor, HTMLSpanElement);
+}, "Prototype chain [[Set]] creates property on receiver");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/interface-prototype-object.html b/test/fixtures/wpt/webidl/ecmascript-binding/interface-prototype-object.html
new file mode 100644
index 00000000000000..299bcf926dc23d
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/interface-prototype-object.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Interface prototype objects</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#interface-prototype-object">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(function() {
+  // https://webidl.spec.whatwg.org/#create-an-interface-prototype-object
+  assert_own_property(Element.prototype, Symbol.unscopables, "Element.prototype has @@unscopables.");
+  let unscopables = Element.prototype[Symbol.unscopables];
+  assert_equals(typeof unscopables, "object", "@@unscopables is an Object.");
+  assert_equals(Object.getPrototypeOf(unscopables), null, "@@unscopables's prototype is null.");
+}, "[Unscopable] extended attribute makes @@unscopables object on the prototype object, whose prototype is null.");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/invalid-this-value-cross-realm.html b/test/fixtures/wpt/webidl/ecmascript-binding/invalid-this-value-cross-realm.html
new file mode 100644
index 00000000000000..0535115ac61f43
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/invalid-this-value-cross-realm.html
@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Cross-realm getter / setter / operation doesn't use lexical global object to throw an error for incompatible |this| value</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#dfn-attribute-getter">
+<link rel="help" href="https://webidl.spec.whatwg.org/#dfn-attribute-setter">
+<link rel="help" href="https://webidl.spec.whatwg.org/#dfn-create-operation-function">
+
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="support/create-realm.js"></script>
+
+<body>
+<script>
+promise_test(async t => {
+    const other = await createRealm(t);
+    const notElement = Object.create(other.HTMLElement.prototype);
+
+    assert_throws_js(other.TypeError, () => { Object.create(other.document).head; });
+    assert_throws_js(other.TypeError, () => { Object.getOwnPropertyDescriptor(other.HTMLElement.prototype, "title").get.call(notElement); });
+    assert_throws_js(other.TypeError, () => { Reflect.get(other.document.createElement("div"), "hidden", notElement); });
+    assert_throws_js(other.TypeError, () => { new Proxy(other.text, {}).nodeType; });
+}, "Cross-realm getter throws when called on incompatible object");
+
+promise_test(async t => {
+    const other = await createRealm(t);
+    const notElement = Object.create(other.HTMLElement.prototype);
+    const notText = Object.create(other.Text.prototype);
+
+    assert_throws_js(other.TypeError, () => { Object.create(other.element).innerHTML = ""; });
+    assert_throws_js(other.TypeError, () => { Object.getOwnPropertyDescriptor(other.HTMLElement.prototype, "onclick").set.call(notElement, null); });
+    assert_throws_js(other.TypeError, () => { Reflect.set(new other.Text("foo"), "data", "foo", notText); });
+    assert_throws_js(other.TypeError, () => { new Proxy(other.document, {}).title = ""; });
+}, "Cross-realm setter throws when called on incompatible object");
+
+promise_test(async t => {
+    const other = await createRealm(t);
+    const notDocument = Object.create(other.HTMLDocument.prototype);
+    const notText = Object.create(other.Text.prototype);
+
+    assert_throws_js(other.TypeError, () => { Object.create(other.element).click(); });
+    assert_throws_js(other.TypeError, () => { other.document.querySelector.call(notDocument, "*"); });
+    assert_throws_js(other.TypeError, () => { Reflect.apply(other.text.remove, notText, []); });
+    assert_throws_js(other.TypeError, () => { new Proxy(other.document.createElement("a"), {}).addEventListener("foo", () => {}); });
+}, "Cross-realm operation throws when called on incompatible object");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/iterator-invalidation-foreach.html b/test/fixtures/wpt/webidl/ecmascript-binding/iterator-invalidation-foreach.html
new file mode 100644
index 00000000000000..9d2e3b9cb25ce6
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/iterator-invalidation-foreach.html
@@ -0,0 +1,40 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Behavior of iterators when modified within foreach</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<link rel="help" href="https://webidl.spec.whatwg.org/#es-forEach">
+<link rel="author" title="Manish Goregaokar" href="mailto:manishsmail@gmail.com">
+<script>
+test(function() {
+    let params = new URLSearchParams("a=1&b=2&c=3");
+    let arr = [];
+    params.forEach((p) => {
+        arr.push(p);
+        params.delete("b");
+    })
+    assert_array_equals(arr, ["1", "3"]);
+}, "forEach will not iterate over elements removed during iteration");
+test(function() {
+    let params = new URLSearchParams("a=1&b=2&c=3&d=4");
+    let arr = [];
+    params.forEach((p) => {
+        arr.push(p);
+        if (p == "2") {
+            params.delete("a");
+        }
+    })
+    assert_array_equals(arr, ["1", "2", "4"]);
+}, "Removing elements already iterated over during forEach will cause iterator to skip an element");
+test(function() {
+    let params = new URLSearchParams("a=1&b=2&c=3&d=4");
+    let arr = [];
+    params.forEach((p) => {
+        arr.push(p);
+        if (p == "2") {
+            params.append("e", "5");
+        }
+    })
+    assert_array_equals(arr, ["1", "2", "3", "4", "5"]);
+}, "Elements added during iteration with forEach will be reached");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/iterator-prototype-object.html b/test/fixtures/wpt/webidl/ecmascript-binding/iterator-prototype-object.html
new file mode 100644
index 00000000000000..7859c1e46ac464
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/iterator-prototype-object.html
@@ -0,0 +1,47 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Iterator prototype objects</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(() => {
+  const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+  const iteratorProto = Object.getPrototypeOf(new URLSearchParams().entries());
+  assert_equals(Object.getPrototypeOf(iteratorProto), esIteratorPrototype);
+}, "Has %IteratorPrototype% as prototype");
+
+test(() => {
+  const iteratorProto = Object.getPrototypeOf(new URLSearchParams().entries());
+  const desc = Object.getOwnPropertyDescriptor(iteratorProto, "next");
+  assert_equals(typeof desc.value, "function");
+  assert_equals(desc.writable, true);
+  assert_equals(desc.enumerable, true);
+  assert_equals(desc.configurable, true);
+}, "next() exists and is writable, enumerable, and configurable");
+
+test(() => {
+  const usp = new URLSearchParams();
+  const iteratorProto = Object.getPrototypeOf(usp.entries());
+
+  assert_throws_js(TypeError, () => {
+    iteratorProto.next();
+  });
+  assert_throws_js(TypeError, () => {
+    iteratorProto.next.call(undefined);
+  });
+  assert_throws_js(TypeError, () => {
+    iteratorProto.next.call(42);
+  });
+  assert_throws_js(TypeError, () => {
+    iteratorProto.next.call(new Headers().entries());
+  });
+}, "next() throws TypeError when called on ineligible receiver");
+
+// class string behavior tested in a dedicated file
+
+test(() => {
+  const iteratorProto1 = Object.getPrototypeOf(new URLSearchParams().entries());
+  const iteratorProto2 = Object.getPrototypeOf(new Headers().entries());
+  assert_not_equals(iteratorProto1, iteratorProto2);
+}, "Is specific to an interface");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/legacy-callback-interface-object.html b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-callback-interface-object.html
new file mode 100644
index 00000000000000..627d29507f7dad
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-callback-interface-object.html
@@ -0,0 +1,69 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Legacy callback interface objects</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<link rel="author" title="Domenic Denicola" href="mailto:d@domenic.me">
+<link rel="help" href="https://webidl.spec.whatwg.org/#legacy-callback-interface-object">
+
+<script>
+test(() => {
+  assert_equals(typeof NodeFilter, "function");
+}, "Must be a function according to typeof");
+
+test(() => {
+  assert_true(Object.getPrototypeOf(NodeFilter) === Function.prototype);
+}, "Must have the correct [[Prototype]]");
+
+test(() => {
+  const propDesc = Object.getOwnPropertyDescriptor(window, "NodeFilter");
+  assert_true(propDesc.writable, "writable");
+  assert_false(propDesc.enumerable, "enumerable");
+  assert_true(propDesc.configurable, "configurable");
+}, "Must have the correct property descriptor");
+
+test(() => {
+  assert_throws_js(TypeError, () => NodeFilter(), "call");
+  assert_throws_js(TypeError, () => new NodeFilter(), "construct");
+}, "Must throw a TypeError when called or constructed")
+
+test(() => {
+  assert_false(NodeFilter.hasOwnProperty("prototype"));
+}, "Must not have a .prototype property");
+
+test(() => {
+  assert_true(NodeFilter.hasOwnProperty("name"));
+  assert_equals(NodeFilter.name, "NodeFilter");
+
+  const propDesc = Object.getOwnPropertyDescriptor(NodeFilter, "name");
+  assert_false(propDesc.writable, "writable");
+  assert_false(propDesc.enumerable, "enumerable");
+  assert_true(propDesc.configurable, "configurable");
+}, "Must have an own name property equal to the interface name and with the correct descriptors");
+
+test(() => {
+  assert_true(NodeFilter.hasOwnProperty("length"));
+  assert_equals(NodeFilter.length, 0);
+
+  const propDesc = Object.getOwnPropertyDescriptor(NodeFilter, "length");
+  assert_false(propDesc.writable, "writable");
+  assert_false(propDesc.enumerable, "enumerable");
+  assert_true(propDesc.configurable, "configurable");
+}, "Must have an own length property with value zero and the correct descriptors");
+
+test(() => {
+  // The JS spec (OrdinaryHasInstance) bails out early for non-objects
+  // Historically we overrode [[HasInstance]] to throw anyway, but this was removed:
+  // https://github.com/heycam/webidl/pull/356
+  assert_false(5 instanceof NodeFilter, "5");
+
+  // OrdinaryHasInstance throws a TypeError if the right-hand-side doesn't have a .prototype object,
+  // which is the case for callback interfaces.
+  assert_throws_js(TypeError, () => {
+    (function () { }) instanceof NodeFilter;
+  });
+  assert_throws_js(TypeError, () => {
+    ({ }) instanceof NodeFilter;
+  });
+}, "instanceof must throw but only when we don't bail out early");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/legacy-factor-function-subclass.window.js b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-factor-function-subclass.window.js
new file mode 100644
index 00000000000000..1fd64f41bb2e8e
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-factor-function-subclass.window.js
@@ -0,0 +1,13 @@
+"use strict";
+
+test(() => {
+  class CustomImage extends Image {}
+  var instance = new CustomImage();
+
+  assert_equals(
+    Object.getPrototypeOf(instance), CustomImage.prototype,
+    "Object.getPrototypeOf(instance) === CustomImage.prototype");
+
+  assert_true(instance instanceof CustomImage, "instance instanceof CustomImage");
+  assert_true(instance instanceof HTMLImageElement, "instance instanceof HTMLImageElement");
+}, "[LegacyFactoryFunction] can be subclassed and correctly handles NewTarget");
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/legacy-factory-function-builtin-properties.window.js b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-factory-function-builtin-properties.window.js
new file mode 100644
index 00000000000000..fc5c48aca380c0
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-factory-function-builtin-properties.window.js
@@ -0,0 +1,6 @@
+"use strict";
+
+test(() => {
+  const ownPropKeys = Reflect.ownKeys(Image).slice(0, 3);
+  assert_array_equals(ownPropKeys, ["length", "name", "prototype"]);
+}, 'Legacy factory function property enumeration order of "length", "name", and "prototype"');
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/DefineOwnProperty.html b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/DefineOwnProperty.html
new file mode 100644
index 00000000000000..bd7ba19c1a90b6
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/DefineOwnProperty.html
@@ -0,0 +1,165 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Legacy platform objects [[DefineOwnProperty]] method</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#legacy-platform-object-defineownproperty">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="./helper.js"></script>
+<script>
+
+test(function() {
+  let span = document.createElement("span");
+  span.className = "foo";
+  // DOMTokenList supports an indexed property getter but not a setter.
+  let domTokenList = span.classList;
+  // Confirm the test settings.
+  assert_equals(domTokenList.length, 1);
+  assert_prop_desc_equals(domTokenList, "0",
+                          {value: "foo", writable: false, enumerable: true,
+                           configurable: true});
+  assert_prop_desc_equals(domTokenList, "1", undefined);
+  // Actual test
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domTokenList, "0", {value: true, writable: true}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domTokenList, "1", {value: true, writable: true}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domTokenList, "0", {get: () => {}}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domTokenList, "0", {set: () => {}}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domTokenList, "1", {get: () => {}}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domTokenList, "1", {set: () => {}}));
+  assert_equals(domTokenList[0], "foo");
+  assert_equals(domTokenList[1], undefined);
+  domTokenList[0] = "bar";
+  domTokenList[1] = "bar";
+  assert_equals(domTokenList[0], "foo");
+  assert_equals(domTokenList[1], undefined);
+  assert_throws_js(TypeError, () => {
+    "use strict";
+    domTokenList[0] = "bar";
+  });
+  assert_throws_js(TypeError, () => {
+    "use strict";
+    domTokenList[1] = "bar";
+  });
+  // Nothing must change after all.
+  assert_equals(domTokenList.length, 1);
+  assert_prop_desc_equals(domTokenList, "0",
+                          {value: "foo", writable: false, enumerable: true,
+                           configurable: true});
+  assert_prop_desc_equals(domTokenList, "1", undefined);
+}, "Test [[DefineOwnProperty]] with no indexed property setter support.");
+
+test(function() {
+  // HTMLSelectElement supports an indexed property setter.
+  let select = document.createElement("select");
+  let option0 = document.createElement("option");
+  let option1 = document.createElement("option");
+  // Confirm the test settings.
+  assert_equals(select.length, 0);
+  assert_prop_desc_equals(select, "0", undefined);
+  // Try to define an accessor property with non supported property index.
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(select, "0", {get: () => {}}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(select, "0", {set: () => {}}));
+  assert_prop_desc_equals(select, "0", undefined);
+  // writable, enumerable, configurable will be ignored.
+  Object.defineProperty(select, "0", {value: option0, writable: false,
+                                      enumerable: false, configurable: false});
+  assert_prop_desc_equals(select, "0",
+                          {value: option0, writable: true, enumerable: true,
+                           configurable: true});
+  select[1] = option1;
+  assert_prop_desc_equals(select, "1",
+                          {value: option1, writable: true, enumerable: true,
+                           configurable: true});
+  // Try to define an accessor property with a supported property index.
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(select, "0", {get: () => {}}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(select, "0", {set: () => {}}));
+  assert_prop_desc_equals(select, "0",
+                          {value: option0, writable: true, enumerable: true,
+                           configurable: true});
+}, "Test [[DefineOwnProperty]] with indexed property setter support.");
+
+test(function() {
+  let dataList = document.createElement("datalist");
+  let option0 = document.createElement("option");
+  option0.id = "foo";
+  dataList.append(option0);
+  // HTMLCollection supports a named property getter but not a setter.
+  let htmlCollection = dataList.options;
+  // Confirm the test settings.
+  assert_equals(htmlCollection.length, 1);
+  // HTMLCollection is marked LegacyUnenumerableNamedProperties so enumerable
+  // is false.
+  assert_prop_desc_equals(htmlCollection, "foo",
+                          {value: option0, writable: false, enumerable: false,
+                           configurable: true});
+  assert_prop_desc_equals(htmlCollection, "bar", undefined);
+  // Actual test
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(htmlCollection, "foo",
+                            {value: true, writable: true}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(htmlCollection, "foo", {get: () => {}}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(htmlCollection, "foo", {set: () => {}}));
+  let option1 = document.createElement("option");
+  option1.id = "bar";
+  Object.defineProperty(htmlCollection, "bar",
+                        {value: option1, writable: true});
+  assert_equals(htmlCollection["foo"], option0);
+  assert_equals(htmlCollection["bar"], option1);
+  htmlCollection["foo"] = document.documentElement;
+  htmlCollection["baz"] = document.documentElement;
+  assert_equals(htmlCollection["foo"], option0);
+  assert_equals(htmlCollection["baz"], document.documentElement);
+  assert_throws_js(TypeError, () => {
+    "use strict";
+    htmlCollection["foo"] = document.documentElement;
+  });
+  // Nothing must change after all for supported property names.
+  assert_prop_desc_equals(htmlCollection, "foo",
+                          {value: option0, writable: false, enumerable: false,
+                           configurable: true});
+}, "Test [[DefineOwnProperty]] with no named property setter support.");
+
+test(function() {
+  let element = document.createElement("div");
+  // DOMStringMap supports a named property setter.
+  let domStringMap = element.dataset;
+  // Confirm the test settings.
+  assert_prop_desc_equals(domStringMap, "foo", undefined);
+  // Try to define an accessor property with non supported property name.
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domStringMap, "foo", {get: () => {}}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domStringMap, "foo", {set: () => {}}));
+  assert_prop_desc_equals(domStringMap, "foo", undefined);
+  // writable, enumerable, configurable will be ignored.
+  Object.defineProperty(domStringMap, "foo",
+                        {value: "foo content", writable: false,
+                         enumerable: false, configurable: false});
+  assert_prop_desc_equals(domStringMap, "foo",
+                          {value: "foo content", writable: true,
+                           enumerable: true, configurable: true});
+  domStringMap["bar"] = "bar content";
+  assert_prop_desc_equals(domStringMap, "bar",
+                          {value: "bar content", writable: true,
+                           enumerable: true, configurable: true});
+  // Try to define an accessor property with a supported property name.
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domStringMap, "foo", {get: () => {}}));
+  assert_throws_js(TypeError, () =>
+      Object.defineProperty(domStringMap, "foo", {set: () => {}}));
+  assert_prop_desc_equals(domStringMap, "foo",
+                          {value: "foo content", writable: true,
+                           enumerable: true, configurable: true});
+}, "Test [[DefineOwnProperty]] with named property setter support.");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/GetOwnProperty.html b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/GetOwnProperty.html
new file mode 100644
index 00000000000000..be3bcc61f0a3aa
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/GetOwnProperty.html
@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Legacy platform objects [[GetOwnProperty]] method</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#legacy-platform-object-getownproperty">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="./helper.js"></script>
+<script>
+
+test(function() {
+  // DOMTokenList has an indexed property getter, no indexed property setter
+  // and no named property handlers.
+  let div = document.createElement("div");
+  div.classList.add("baz", "quux");
+  const domTokenList = div.classList;
+  assert_prop_desc_equals(
+      domTokenList, "1",
+      {value: "quux", writable: false, enumerable: true, configurable: true},
+      "[[GetOwnProperty]] for indexed properties returns the right descriptor");
+  assert_prop_desc_equals(
+      domTokenList, "42", undefined,
+      "[[GetOwnProperty]] with invalid index returns undefined");
+  assert_array_equals(Object.keys(domTokenList), ["0", "1"]);
+  assert_array_equals(Object.values(domTokenList), ["baz", "quux"]);
+
+  // getElementsByTagName() returns an HTMLCollection.
+  // HTMLCollection has indexed and named property getters, no setters. Its IDL
+  // interface declaration has [LegacyUnenumerableNamedProperties] so its named
+  // properties are not enumerable.
+  let span1 = document.createElement("span");
+  span1.id = "foo";
+  let span2 = document.createElement("span");
+  span2.id = "bar";
+  document.head.appendChild(span1);
+  document.head.appendChild(span2);
+  const elementList = document.getElementsByTagName("span");
+  assert_prop_desc_equals(
+      elementList, "foo",
+      {value: span1, writable: false, enumerable: false, configurable: true},
+      "[[GetOwnProperty]] for named properties returns the right descriptor");
+  assert_prop_desc_equals(
+      elementList, "1",
+      {value: span2, writable: false, enumerable: true, configurable: true},
+      "[[GetOwnProperty]] for indexed properties returns the right descriptor");
+  assert_prop_desc_equals(
+      elementList, "unknown", undefined,
+      "[[GetOwnProperty]] with invalid property name returns undefined");
+  assert_array_equals(Object.keys(elementList), ["0", "1"]);
+  assert_array_equals(Object.values(elementList), [span1, span2]);
+}, "[[GetOwnProperty]] with getters and no setters");
+
+test(function() {
+  // DOMStringMap supports named property getters and setters, but not indexed
+  // properties.
+  let span = document.createElement("span");
+  span.dataset.foo = "bar";
+  assert_prop_desc_equals(
+      span.dataset, "foo",
+      {value: "bar", writable: true, enumerable: true, configurable: true},
+      "[[GetOwnProperty]] for named properties returns the right descriptor");
+  assert_prop_desc_equals(
+      span.dataset, "unknown", undefined,
+      "[[GetOwnProperty]] with invalid property name returns undefined");
+  assert_array_equals(Object.keys(span.dataset), ["foo"]);
+  assert_array_equals(Object.values(span.dataset), ["bar"]);
+}, "[[GetOwnProperty]] with named property getters and setters");
+
+test(function() {
+  // HTMLSelectElement has indexed property getters and setters, but no support
+  // for named properties.
+  let selectElement = document.createElement("select");
+  assert_prop_desc_equals(
+      selectElement, "0", undefined,
+      "[[GetOwnProperty]] with invalid property index returns undefined");
+  let optionElement = document.createElement("option");
+  selectElement.appendChild(optionElement);
+  assert_prop_desc_equals(
+      selectElement, "0",
+      {value: optionElement, writable: true, enumerable: true, configurable: true},
+      "[[GetOwnProperty]] for indexed properties returns the right descriptor");
+  assert_array_equals(Object.keys(selectElement), ["0"]);
+  assert_array_equals(Object.values(selectElement), [optionElement]);
+}, "[[GetOwnProperty]] with indexed property getters and setters");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/OwnPropertyKeys.html b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/OwnPropertyKeys.html
new file mode 100644
index 00000000000000..d33980517b1a94
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/OwnPropertyKeys.html
@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Legacy platform objects [[OwnPropertyKeys]] method</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#legacy-platform-object-ownpropertykeys">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+    function custom_assert_array_equals(actual, expected, msg) {
+        function replacer(k, v) {
+          if (typeof v === "symbol") {
+            return v.toString();
+          }
+          return v;
+        }
+        assert_array_equals(actual, expected, " actual " + JSON.stringify(actual, replacer) + " expected " + JSON.stringify(expected, replacer));
+    }
+
+    test(function() {
+        var element = document.createElement("div");
+        element.appendChild(document.createElement("div"));
+        element.appendChild(document.createElement("div"));
+        element.appendChild(document.createElement("div"));
+        custom_assert_array_equals(Reflect.ownKeys(element.childNodes), ["0", "1", "2"]);
+    }, "must enumerate property indices in ascending numerical order");
+
+    test(function() {
+        var element = document.createElement("div");
+        element.setAttribute("data-foo", "foo content");
+        element.setAttribute("data-bar", "bar content");
+        element.setAttribute("data-baz", "baz content");
+        custom_assert_array_equals(Reflect.ownKeys(element.dataset), ["foo", "bar", "baz"]);
+    }, "must enumerate property names in list order");
+
+
+    test(function() {
+        var element = document.createElement("div");
+        element.setAttribute("id", "foo");
+        element.setAttribute("class", "bar");
+        custom_assert_array_equals(Reflect.ownKeys(element.attributes), ["0", "1", "id", "class"]);
+    }, "must first enumerate property indices in ascending numerical order, then named properties in list order");
+
+
+    test(function() {
+        var element = document.createElement("div");
+        element.attributes.foo = "some value";
+        element.attributes.bar = "and another";
+        element.setAttribute("id", "foo");
+        element.setAttribute("class", "bar");
+        custom_assert_array_equals(Reflect.ownKeys(element.attributes), ["0", "1", "id", "class", "foo", "bar"]);
+    }, "must enumerate own properties after indexed and named properties even when they're added first");
+
+    test(function() {
+        var symb1 = Symbol();
+        var symb2 = Symbol();
+        var element = document.createElement("div");
+        element.attributes.foo = "some value";
+        element.attributes[symb1] = "symb1";
+        element.attributes[symb2] = "symb2";
+        element.attributes.bar = "and another";
+        element.setAttribute("id", "foo");
+        element.setAttribute("class", "bar");
+        custom_assert_array_equals(Reflect.ownKeys(element.attributes),
+            ["0", "1", "id", "class", "foo", "bar", symb1, symb2]);
+    }, "must enumerate symbols after strings, regardless of which ones got added first");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/Set.html b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/Set.html
new file mode 100644
index 00000000000000..1390b51cd03b51
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/Set.html
@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Legacy platform objects [[Set]] method</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#legacy-platform-object-set">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+    test(function() {
+        var element = document.createElement("div");
+        element.appendChild(document.createElement("div"));
+        element.childNodes["5"] = "foo";
+        assert_equals(element.childNodes["5"], undefined);
+    }, "must not set the property value when assigning to a numeric property on an object which implements an indexed property getter but not a setter when not in strict mode");
+
+    test(function() {
+        "use strict";
+        var element = document.createElement("div");
+        element.appendChild(document.createElement("div"));
+        assert_throws_js(TypeError, function() { element.childNodes["5"] = "foo"; });
+    }, "must throw when assigning to a numeric property on an object which implements a indexed property getter but not a setter in strict mode");
+
+    test(function() {
+        var element = document.createElement("div");
+        element.attributes.foo = "foo";
+        assert_equals(element.attributes.foo, "foo");
+    }, "must allow assigning to a named property on an object which implements a named property getter but not a setter when not in strict mode");
+
+    test(function() {
+        "use strict";
+        var element = document.createElement("div");
+        element.attributes.foo = "foo";
+        assert_equals(element.attributes.foo, "foo");
+    }, "must allow assigning to a named property on an object which implements a named property getter but not a setter in strict mode");
+
+    test(function() {
+        "use strict";
+        var form = document.createElement("form");
+        assert_equals(form.method, "get");
+        var input = document.createElement("input");
+        input.name = "method";
+        input.id = "method";
+        form.appendChild(input);
+        assert_equals(form.method, input);
+        form.method = "post";
+        assert_equals(form.method, input);
+        input.remove();
+        assert_equals(form.method, "post");
+    }, "must allow setting built-in property on a [LegacyOverrideBuiltIns] object even if a named property shadows it");
+
+    var symbol = Symbol();
+
+    test(function() {
+        var element = document.createElement("div");
+        element.appendChild(document.createElement("div"));
+        element.childNodes[symbol] = "foo";
+        assert_equals(element.childNodes[symbol], "foo");
+    }, "must allow assigning to a symbol property on an object which implements an indexed property getter but not a setter when not in strict mode");
+
+    test(function() {
+        "use strict";
+        var element = document.createElement("div");
+        element.appendChild(document.createElement("div"));
+        element.childNodes[symbol] = "foo";
+        assert_equals(element.childNodes[symbol], "foo");
+    }, "must allow assigning to a symbol property on an object which implements an indexed property getter but not a setter in strict mode");
+
+    test(function() {
+        var element = document.createElement("div");
+        element.attributes[symbol] = "foo";
+        assert_equals(element.attributes[symbol], "foo");
+    }, "must allow assigning to a symbol property on an object which implements indexed and named property getters but no setters when not in strict mode");
+
+    test(function() {
+        "use strict";
+        var element = document.createElement("div");
+        element.attributes[symbol] = "foo";
+        assert_equals(element.attributes[symbol], "foo");
+    }, "must allow assigning to a symbol property on an object which implements indexed and named property getters but no setters in strict mode");
+
+    test(function() {
+        sessionStorage.clear();
+        this.add_cleanup(function() { sessionStorage.clear(); });
+        sessionStorage[symbol] = "foo";
+        assert_equals(sessionStorage[symbol], "foo");
+    }, "must allow assigning to a symbol property on an object which implements indexed and named property getters and setters when not in strict mode");
+
+    test(function() {
+        "use strict";
+        sessionStorage.clear();
+        this.add_cleanup(function() { sessionStorage.clear(); });
+        sessionStorage[symbol] = "foo";
+        assert_equals(sessionStorage[symbol], "foo");
+    }, "must allow assigning to a symbol property on an object which implements indexed and named property getters and setters in strict mode");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/helper.js b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/helper.js
new file mode 100644
index 00000000000000..01c1d00694eb9b
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/legacy-platform-object/helper.js
@@ -0,0 +1,22 @@
+function assert_prop_desc_equals(object, property_key, expected) {
+  let actual = Object.getOwnPropertyDescriptor(object, property_key);
+  if (expected === undefined) {
+    assert_equals(
+        actual, undefined,
+        "(assert_prop_desc_equals: no property descriptor expected)");
+    return;
+  }
+  for (p in actual) {
+    assert_true(
+        expected.hasOwnProperty(p),
+        "(assert_prop_desc_equals: property '" + p + "' is not expected)");
+    assert_equals(
+        actual[p], expected[p],
+        "(assert_prop_desc_equals: property '" + p + "')");
+  }
+  for (p in expected) {
+    assert_true(
+        actual.hasOwnProperty(p),
+        "(assert_prop_desc_equals: expected property '" + p + "' missing)");
+  }
+}
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/no-regexp-special-casing.any.js b/test/fixtures/wpt/webidl/ecmascript-binding/no-regexp-special-casing.any.js
new file mode 100644
index 00000000000000..4446dbf69c02ab
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/no-regexp-special-casing.any.js
@@ -0,0 +1,47 @@
+"use strict";
+// RegExps used to be special-cased in Web IDL, but that was removed in
+// https://github.com/heycam/webidl/commit/bbb2bde. These tests check that implementations no longer
+// do any such special-casing.
+
+test(() => {
+  const regExp = new RegExp();
+  regExp.message = "some message";
+
+  const errorEvent = new ErrorEvent("type", regExp);
+
+  assert_equals(errorEvent.message, "some message");
+}, "Conversion to a dictionary works");
+
+test(() => {
+  const messageChannel = new MessageChannel();
+  const regExp = new RegExp();
+  regExp[Symbol.iterator] = function* () {
+    yield messageChannel.port1;
+  };
+
+  const messageEvent = new MessageEvent("type", { ports: regExp });
+
+  assert_array_equals(messageEvent.ports, [messageChannel.port1]);
+}, "Conversion to a sequence works");
+
+promise_test(async () => {
+  const regExp = new RegExp();
+
+  const response = new Response(regExp);
+
+  assert_equals(await response.text(), "/(?:)/");
+}, "Can convert a RegExp to a USVString");
+
+test(() => {
+  let functionCalled = false;
+
+  const regExp = new RegExp();
+  regExp.handleEvent = () => {
+    functionCalled = true;
+  };
+
+  self.addEventListener("testevent", regExp);
+  self.dispatchEvent(new Event("testevent"));
+
+  assert_true(functionCalled);
+}, "Can be used as an object implementing a callback interface");
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/observable-array-no-leak-of-internals.window.js b/test/fixtures/wpt/webidl/ecmascript-binding/observable-array-no-leak-of-internals.window.js
new file mode 100644
index 00000000000000..f93464005d017f
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/observable-array-no-leak-of-internals.window.js
@@ -0,0 +1,18 @@
+"use strict";
+
+test(() => {
+  const observableArray = document.adoptedStyleSheets;
+
+  let leaked_target = null;
+  let leaked_handler = null;
+
+  let target_leaker = (target) => { leaked_target = target; return null; };
+  Object.defineProperty(Object.prototype, "getPrototypeOf", {get: function() {
+    leaked_handler = this;
+    return target_leaker;
+  }})
+  Object.getPrototypeOf(observableArray);
+
+  assert_equals(leaked_target, null, "The proxy target leaked.");
+  assert_equals(leaked_handler, null, "The proxy handler leaked.");
+}, "ObservableArray's internals won't leak");
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/observable-array-ownkeys.window.js b/test/fixtures/wpt/webidl/ecmascript-binding/observable-array-ownkeys.window.js
new file mode 100644
index 00000000000000..29b537c4750a38
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/observable-array-ownkeys.window.js
@@ -0,0 +1,34 @@
+"use strict";
+
+test(() => {
+  const observableArray = document.adoptedStyleSheets;
+  assert_array_equals(
+      Object.getOwnPropertyNames(observableArray),
+      ["length"],
+      "Initially only \"length\".");
+
+  observableArray["zzz"] = true;
+  observableArray["aaa"] = true;
+  assert_array_equals(
+      Object.getOwnPropertyNames(observableArray),
+      ["length", "zzz", "aaa"],
+      "Own properties whose key is a string have been added.");
+
+  observableArray[0] = new CSSStyleSheet();
+  observableArray[1] = new CSSStyleSheet();
+  assert_array_equals(
+      Object.getOwnPropertyNames(observableArray),
+      ["0", "1", "length", "zzz", "aaa"],
+      "Own properties whose key is an array index have been added.");
+
+  observableArray[Symbol.toStringTag] = "string_tag";
+  observableArray[Symbol.toPrimitive] = "primitive";
+  assert_array_equals(
+      Object.getOwnPropertyNames(observableArray),
+      ["0", "1", "length", "zzz", "aaa"],
+      "Own properties whose key is a symbol have been added (non-symbol).");
+  assert_array_equals(
+      Object.getOwnPropertySymbols(observableArray),
+      [Symbol.toStringTag, Symbol.toPrimitive],
+      "Own properties whose key is a symbol have been added (symbol).");
+}, "ObservableArray's ownKeys trap");
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/put-forwards.html b/test/fixtures/wpt/webidl/ecmascript-binding/put-forwards.html
new file mode 100644
index 00000000000000..7d99d65aa21385
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/put-forwards.html
@@ -0,0 +1,148 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>[PutForwards] behavior</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<link rel="author" title="Jens Widell" href="mailto:jl@opera.com">
+<link rel="help" href="https://webidl.spec.whatwg.org/#PutForwards">
+
+<script>
+test(() => {
+  var getter_called = false;
+  var element = document.createElement("div");
+  var element_style = element.style;
+  var descriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "style");
+
+  Object.defineProperty(element, "style", {
+    get: function () {
+      getter_called = true;
+      return element_style;
+    },
+    set: descriptor.set
+  });
+
+  element.style = "color: green";
+
+  assert_true(getter_called, "Overridden getter should be called");
+  assert_equals(element_style.color, "green", "Put forwarding still works");
+}, "Overriding getter of [PutForwards] attribute");
+
+test(() => {
+  var setter_called = false;
+  var element = document.createElement("div");
+  var element_style = element.style;
+  var descriptor = Object.getOwnPropertyDescriptor(CSSStyleDeclaration.prototype, "cssText");
+
+  Object.defineProperty(element_style, "cssText", {
+    get: descriptor.get,
+    set: function (v) {
+      setter_called = true;
+      descriptor.set.call(this, v);
+    }
+  });
+
+  element.style = "color: green";
+
+  assert_true(setter_called, "Overridden setter should be called");
+  assert_equals(element_style.color, "green", "Put forwarding still works");
+}, "Overriding setter of [PutForwards] target attribute");
+
+test(() => {
+  var element = document.createElement("div");
+  var element_style = element.style;
+  var fake_style = { cssText: "original" };
+  var descriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "style");
+
+  Object.defineProperty(element, "style", {
+    get: function () {
+      return fake_style;
+    },
+    set: descriptor.set
+  });
+
+  element.style = "color: green";
+
+  assert_equals(element_style.cssText, "", "Original value intact");
+  assert_equals(fake_style.cssText, "color: green", "Fake style object updated");
+}, "Overriding target of [PutForwards] attribute");
+
+test(() => {
+  var element = document.createElement("div");
+  var descriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "style");
+
+  Object.defineProperty(element, "style", {
+    get: function () {
+      throw new SyntaxError();
+    },
+    set: descriptor.set
+  });
+
+  assert_throws_js(SyntaxError, () => {
+    element.style = "color: green";
+  });
+}, "Exception propagation from getter of [PutForwards] attribute");
+
+test(() => {
+  var element = document.createElement("div");
+  var element_style = element.style;
+  var descriptor = Object.getOwnPropertyDescriptor(CSSStyleDeclaration.prototype, "cssText");
+
+  Object.defineProperty(element_style, "cssText", {
+    get: descriptor.get,
+    set: function (v) {
+      throw new SyntaxError();
+    }
+  });
+
+  assert_throws_js(SyntaxError, () => {
+    element.style = "color: green";
+  });
+}, "Exception propagation from setter of [PutForwards] target attribute");
+
+test(() => {
+  var element = document.createElement("div");
+  var descriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "style");
+
+  Object.defineProperty(element, "style", {
+    get: function () {
+      return null;
+    },
+    set: descriptor.set
+  });
+
+  assert_throws_js(TypeError, () => {
+    element.style = "color: green";
+  });
+}, "TypeError when getter of [PutForwards] attribute returns non-object");
+
+
+test(() => {
+  var element = document.createElement("div");
+
+  var element_style = element.style;
+  Object.defineProperty(element.style, "cssText", {
+    value: null,
+    writable: false,
+  });
+
+  element.style = "color: green";
+  assert_equals(element.style, element_style);
+  assert_equals(element.style.cssText, null);
+}, "Does not throw when setter of [PutForwards] attribute returns false");
+
+function test_token_list(elementName, attribute, target, value) {
+  test(() => {
+    var element=document.createElement(elementName);
+    assert_true(element[attribute] instanceof DOMTokenList,"The attribute is a DOMTokenList");
+    element[attribute]=value;
+    assert_equals(element.getAttribute(target),value,"Setting the attribute is reflected in the target");
+    element[attribute]="";
+    assert_equals(element.getAttribute(target),"","Clearing the attribute is reflected in the target");
+  },"Setting "+elementName+"."+attribute+" to "+value+" is reflected in "+target)
+}
+
+test_token_list("a","relList","rel","noreferrer");
+test_token_list("area","relList","rel","noreferrer");
+test_token_list("form","relList","rel","noreferrer");
+test_token_list("link","relList","rel","stylesheet");
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/replaceable-setter-throws-if-defineownproperty-fails.html b/test/fixtures/wpt/webidl/ecmascript-binding/replaceable-setter-throws-if-defineownproperty-fails.html
new file mode 100644
index 00000000000000..872bbff9604265
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/replaceable-setter-throws-if-defineownproperty-fails.html
@@ -0,0 +1,38 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>[Replaceable] setter throws TypeError if [[DefineOwnProperty]] fails</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<link rel="author" title="Alexey Shvayka" href="shvaikalesh@gmail.com">
+<link rel="help" href="https://webidl.spec.whatwg.org/#Replaceable">
+
+<body>
+<script>
+for (const key of ["self", "parent", "origin", "innerWidth"]) {
+    test(() => {
+        Object.defineProperty(window, key, { configurable: false });
+        assert_throws_js(TypeError, () => { window[key] = 1; });
+
+        const desc = Object.getOwnPropertyDescriptor(window, key);
+        assert_false("value" in desc);
+        assert_equals(typeof desc.get, "function");
+        assert_equals(typeof desc.set, "function");
+        assert_true(desc.enumerable);
+        assert_false(desc.configurable);
+    }, `window.${key} setter throws TypeError if called on non-configurable accessor property`);
+}
+
+for (const key of ["screen", "length", "event", "outerHeight"]) {
+    test(() => {
+        const { set } = Object.getOwnPropertyDescriptor(window, key);
+        Object.defineProperty(window, key, { value: 1, writable: false, configurable: false });
+        assert_throws_js(TypeError, () => { set.call(window, 2); });
+
+        const desc = Object.getOwnPropertyDescriptor(window, key);
+        assert_equals(desc.value, 1);
+        assert_false(desc.writable);
+        assert_true(desc.enumerable);
+        assert_false(desc.configurable);
+    }, `window.${key} setter throws TypeError if called on non-configurable non-writable data property`);
+}
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/sequence-conversion.html b/test/fixtures/wpt/webidl/ecmascript-binding/sequence-conversion.html
new file mode 100644
index 00000000000000..40764e9f577603
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/sequence-conversion.html
@@ -0,0 +1,157 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Sequence conversion</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#es-sequence">
+<link rel="author" title="Domenic Denicola" href="mailto:d@domenic.me">
+
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+
+<canvas></canvas>
+
+<script>
+"use strict";
+
+const canvas = document.querySelector("canvas");
+const ctx = canvas.getContext("2d");
+
+test(() => {
+  ctx.setLineDash([1, 2]);
+  assert_array_equals(ctx.getLineDash(), [1, 2]);
+}, "An array");
+
+test(() => {
+  function* generatorFunc() {
+    yield 4;
+    yield 5;
+  }
+  const generator = generatorFunc();
+
+  ctx.setLineDash(generator);
+  assert_array_equals(ctx.getLineDash(), [4, 5]);
+}, "A generator");
+
+test(() => {
+  function* generatorFunc() {
+    yield 6;
+    yield 7;
+  }
+
+  let callCount = 0;
+  const array = [1, 2];
+  Object.defineProperty(array, Symbol.iterator, {
+    get() {
+      ++callCount;
+      return generatorFunc;
+    }
+  });
+
+  ctx.setLineDash(array);
+  assert_array_equals(ctx.getLineDash(), [6, 7]);
+  assert_equals(callCount, 1, "@@iterator must only have been gotten once");
+}, "An array with an overridden Symbol.iterator");
+
+test(t => {
+  function* generatorFunc() {
+    yield ["foo", "bar"];
+    yield ["baz", "quux"];
+  }
+
+  let callCount = 0;
+  const obj = {};
+  Object.defineProperty(obj, Symbol.iterator, {
+    get() {
+      ++callCount;
+      return generatorFunc;
+    }
+  });
+
+  const searchParams = new URLSearchParams(obj);
+  assert_equals(searchParams.get("foo"), "bar");
+  assert_equals(searchParams.get("baz"), "quux");
+  assert_equals(callCount, 1, "@@iterator must only have been gotten once");
+}, "An object with an overriden Symbol.iterator");
+
+test(t => {
+  const originalIterator = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+  t.add_cleanup(() => {
+    Object.defineProperty(Array.prototype, Symbol.iterator, originalIterator);
+  });
+
+  function* generatorFunc() {
+    yield 11;
+    yield 12;
+  }
+
+  let callCount = 0;
+  const array = [1, 2];
+  Object.defineProperty(Array.prototype, Symbol.iterator, {
+    get() {
+      ++callCount;
+      return generatorFunc;
+    }
+  });
+
+  ctx.setLineDash(array);
+  assert_array_equals(ctx.getLineDash(), [11, 12]);
+  assert_equals(callCount, 1, "@@iterator must only have been gotten once");
+}, "An array with an overridden Symbol.iterator on the prototype");
+
+test(t => {
+  const arrayIteratorPrototype = Object.getPrototypeOf(Array.prototype[Symbol.iterator]());
+  const nextBefore = arrayIteratorPrototype.next;
+  t.add_cleanup(() => {
+    arrayIteratorPrototype.next = nextBefore;
+  });
+
+  let callCount = 0;
+  arrayIteratorPrototype.next = () => {
+    switch (callCount) {
+      case 0: {
+        ++callCount;
+        return { done: false, value: 8 };
+      }
+      case 1: {
+        ++callCount;
+        return { done: false, value: 9 };
+      }
+      case 2: {
+        ++callCount;
+        return { done: true, value: 10 }; // value should be ignored this time
+      }
+      default: {
+        assert_unreached("next() should be called three times exactly");
+      }
+    }
+  };
+
+  const array = [1, 2];
+  ctx.setLineDash(array);
+  assert_array_equals(ctx.getLineDash(), [8, 9]);
+  assert_equals(callCount, 3, "next() must have been called thrice");
+}, "An array with an overridden %ArrayIterator%.prototype.next");
+
+test(t => {
+  t.add_cleanup(() => {
+    delete Array.prototype[1];
+  });
+
+  Object.defineProperty(Array.prototype, "1", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return 14;
+    }
+  });
+
+  const array = [13, , 15, 16];
+  ctx.setLineDash(array);
+  assert_array_equals(ctx.getLineDash(), [13, 14, 15, 16]);
+}, "A holey array with fallback to an accessor on the prototype");
+
+test(t => {
+  // Should fail rather than falling back to record
+  assert_throws_js(TypeError, function() { new URLSearchParams(["key", "value"]); });
+}, "A string array in sequence<sequence> or record");
+
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/setter-argument.html b/test/fixtures/wpt/webidl/ecmascript-binding/setter-argument.html
new file mode 100644
index 00000000000000..bfa4291b236533
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/setter-argument.html
@@ -0,0 +1,176 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Setter should treat no arguments as undefined</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<body>
+<script>
+const invalidThisValues = [undefined, null, 1, {}, new Image()];
+
+// String attribute.
+
+test(() => {
+  const setter = Object.getOwnPropertyDescriptor(Animation.prototype, "id").set;
+
+  for (const thisValue of invalidThisValues) {
+    assert_throws_js(TypeError, () => { setter.call(thisValue); });
+    assert_throws_js(TypeError, () => { setter.call(thisValue, undefined); });
+    assert_throws_js(TypeError, () => { setter.call(thisValue, "foo"); });
+  }
+}, `String attribute setter should throw if this value is invalid`);
+
+test(() => {
+  const thisValue = new Animation();
+  const setter = Object.getOwnPropertyDescriptor(Animation.prototype, "id").set;
+
+  assert_equals(thisValue.id, "");
+
+  setter.call(thisValue);
+  assert_equals(thisValue.id, "undefined",
+               "undefined value should be stringified");
+}, `String attribute setter should treat no arguments as undefined`);
+
+test(() => {
+  const thisValue = new Animation();
+  const setter = Object.getOwnPropertyDescriptor(Animation.prototype, "id").set;
+
+  assert_equals(thisValue.id, "");
+
+  setter.call(thisValue, undefined);
+  assert_equals(thisValue.id, "undefined",
+               "undefined value should be stringified");
+}, `String attribute setter called with undefined should behave in the same way as no arguments`);
+
+test(() => {
+  const thisValue = new Animation();
+  const setter = Object.getOwnPropertyDescriptor(Animation.prototype, "id").set;
+
+  assert_equals(thisValue.id, "");
+
+  setter.call(thisValue, "foo");
+  assert_equals(thisValue.id, "foo");
+}, `String attribute setter called with string should just work`);
+
+// Object attribute.
+
+test(() => {
+  const setter = Object.getOwnPropertyDescriptor(Document.prototype, "body").set;
+
+  for (const thisValue of invalidThisValues) {
+    assert_throws_js(TypeError, () => { setter.call(thisValue); });
+    assert_throws_js(TypeError, () => { setter.call(thisValue, undefined); });
+    assert_throws_js(TypeError, () => { setter.call(thisValue, "foo"); });
+  }
+}, `Object attribute setter should throw if this value is invalid`);
+
+test(() => {
+  const thisValue = new Document();
+  const setter = Object.getOwnPropertyDescriptor(Document.prototype, "body").set;
+
+  assert_throws_dom("HierarchyRequestError", () => { setter.call(thisValue); });
+}, `Object attribute setter should treat no arguments as undefined`);
+
+test(() => {
+  const thisValue = new Document();
+  const setter = Object.getOwnPropertyDescriptor(Document.prototype, "body").set;
+
+  assert_throws_dom("HierarchyRequestError", () => { setter.call(thisValue, undefined); });
+}, `Object attribute setter called with undefined should behave in the same way as no arguments`);
+
+// [Replaceable] attribute.
+
+test(() => {
+  const thisValue = window;
+  const setter = Object.getOwnPropertyDescriptor(window, "scrollX").set;
+
+  setter.call(thisValue);
+  assert_equals(thisValue.scrollX, undefined);
+}, `[Replaceable] setter should treat no arguments as undefined`);
+
+test(() => {
+  const thisValue = window;
+  const setter = Object.getOwnPropertyDescriptor(window, "screenLeft").set;
+
+  setter.call(thisValue, undefined);
+  assert_equals(thisValue.screenLeft, undefined);
+}, `[Replaceable] setter called with undefined should behave in the same way as no arguments`);
+
+test(() => {
+  const thisValue = window;
+  const setter = Object.getOwnPropertyDescriptor(window, "screenTop").set;
+
+  setter.call(thisValue, "foo");
+  assert_equals(thisValue.screenTop, "foo");
+}, `[Replaceable] setter called with other value should just work`);
+
+// [LegacyLenientThis] attribute.
+
+test(() => {
+  const setter = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "onmouseenter").set;
+
+  for (const thisValue of invalidThisValues) {
+    setter.call(thisValue);
+    setter.call(thisValue, undefined);
+    setter.call(thisValue, "foo");
+  }
+}, `[LegacyLenientThis] setter should not throw even if this value is invalid, regardless of the arguments count`);
+
+test(() => {
+  const thisValue = document.createElement("div");
+  const setter = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "onmouseenter").set;
+
+  setter.call(thisValue);
+  assert_equals(thisValue.onmouseenter, null);
+}, `[LegacyLenientThis] setter should treat no arguments as undefined`);
+
+test(() => {
+  const thisValue = document.createElement("div");
+  const setter = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "onmouseenter").set;
+
+  setter.call(thisValue, undefined);
+  assert_equals(thisValue.onmouseenter, null);
+}, `[LegacyLenientThis] setter called with undefined should behave in the same way as no arguments`);
+
+// [LegacyLenientSetter] attribute.
+
+test(() => {
+  const thisValue = new Document();
+  const setter = Object.getOwnPropertyDescriptor(Document.prototype, "fullscreenEnabled").set;
+
+  setter.call(thisValue);
+  assert_equals(thisValue.fullscreenEnabled, false);
+}, `[LegacyLenientSetter] setter should treat no arguments as undefined`);
+
+test(() => {
+  const thisValue = new Document();
+  const setter = Object.getOwnPropertyDescriptor(Document.prototype, "fullscreenEnabled").set;
+
+  setter.call(thisValue, undefined);
+  assert_equals(thisValue.fullscreenEnabled, false);
+}, `[LegacyLenientSetter] setter called with undefined should behave in the same way as no arguments`);
+
+// [PutForward] attribute.
+
+test(() => {
+  const thisValue = document.createElement("a");
+  const setter = Object.getOwnPropertyDescriptor(HTMLAnchorElement.prototype, "relList").set;
+
+  assert_equals(thisValue.relList.length, 0);
+
+  setter.call(thisValue);
+  assert_equals(thisValue.relList.length, 1);
+  assert_equals(thisValue.relList[0], "undefined");
+}, `[PutForward] setter should treat no arguments as undefined`);
+
+test(() => {
+  const thisValue = document.createElement("a");
+  const setter = Object.getOwnPropertyDescriptor(HTMLAnchorElement.prototype, "relList").set;
+
+  assert_equals(thisValue.relList.length, 0);
+
+  setter.call(thisValue, undefined);
+
+  assert_equals(thisValue.relList.length, 1);
+  assert_equals(thisValue.relList[0], "undefined");
+}, `[PutForward] setter called with undefined should behave in the same way as no arguments`);
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/support/constructors-support.html b/test/fixtures/wpt/webidl/ecmascript-binding/support/constructors-support.html
new file mode 100644
index 00000000000000..3b2616170b1d4f
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/support/constructors-support.html
@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<script>
+window.badNewTarget = function() {};
+badNewTarget.prototype = 8;
+
+window.DOMParserSubclass = class extends DOMParser {}
+window.ForeignDOMParserSubclass = class extends parent.DOMParser {}
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/support/create-realm.js b/test/fixtures/wpt/webidl/ecmascript-binding/support/create-realm.js
new file mode 100644
index 00000000000000..45ded884fc1f22
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/support/create-realm.js
@@ -0,0 +1,12 @@
+"use strict";
+
+function createRealm(t) {
+    return new Promise(resolve => {
+        const iframe = document.createElement("iframe");
+        t.add_cleanup(() => { iframe.remove(); });
+        iframe.onload = () => { resolve(iframe.contentWindow); };
+        iframe.name = "dummy";
+        iframe.src = "support/dummy-iframe.html";
+        document.body.append(iframe);
+    });
+}
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/support/dummy-iframe.html b/test/fixtures/wpt/webidl/ecmascript-binding/support/dummy-iframe.html
new file mode 100644
index 00000000000000..3f773ae6f811ac
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/support/dummy-iframe.html
@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<body>foo
+<button id="element"></button>
+<script>
+    window.text = document.body.firstChild;
+</script>
diff --git a/test/fixtures/wpt/webidl/ecmascript-binding/window-named-properties-object.html b/test/fixtures/wpt/webidl/ecmascript-binding/window-named-properties-object.html
new file mode 100644
index 00000000000000..cc4976890683f4
--- /dev/null
+++ b/test/fixtures/wpt/webidl/ecmascript-binding/window-named-properties-object.html
@@ -0,0 +1,284 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Internal methods of Window's named properties object</title>
+<link rel="help" href="https://webidl.spec.whatwg.org/#named-properties-object">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<body>
+<script>
+function sloppyModeSet(base, key, value) { base[key] = value; }
+</script>
+<script>
+"use strict";
+
+const supportedNonIndex = "supported non-index property name";
+const supportedIndex = "supported indexed property name";
+const unsupportedNonIndex = "unsupported non-index property name";
+const unsupportedIndex = "unsupported indexed property name";
+const existingSymbol = "existing symbol property name";
+const nonExistingSymbol = "non-existing symbol property name";
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+
+    Object.setPrototypeOf(wp, w.EventTarget.prototype); // Setting current [[Prototype]] value shouldn't throw
+
+    assert_throws_js(TypeError, () => { Object.setPrototypeOf(wp, {}); });
+    assert_throws_js(w.TypeError, () => { wp.__proto__ = null; });
+    assert_false(Reflect.setPrototypeOf(wp, w.Object.prototype));
+
+    assert_equals(Object.getPrototypeOf(wp), w.EventTarget.prototype);
+}, "[[SetPrototypeOf]] and [[GetPrototypeOf]]");
+
+test(t => {
+    const { wp } = createWindowProperties(t);
+
+    assert_throws_js(TypeError, () => { Object.preventExtensions(wp); });
+    assert_false(Reflect.preventExtensions(wp));
+
+    assert_true(Object.isExtensible(wp));
+}, "[[PreventExtensions]] and [[IsExtensible]]");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+
+    const elA = appendElementWithId(w, "a");
+    const el0 = appendIframeWithName(w, 0);
+
+    assert_prop_desc(Object.getOwnPropertyDescriptor(wp, "a"), elA, supportedNonIndex);
+    assert_prop_desc(Reflect.getOwnPropertyDescriptor(wp, 0), el0, supportedIndex);
+    assert_equals(Reflect.getOwnPropertyDescriptor(wp, "b"), undefined, unsupportedNonIndex);
+    assert_equals(Object.getOwnPropertyDescriptor(wp, 1), undefined, unsupportedIndex);
+}, "[[GetOwnProperty]]");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+
+    appendIframeWithName(w, "hasOwnProperty");
+    appendFormWithName(w, "addEventListener");
+    appendElementWithId(w, "a");
+    appendIframeWithName(w, 0);
+
+    w.Object.prototype.a = {};
+    w.EventTarget.prototype[0] = {};
+
+    // These are shadowed by properties higher in [[Prototype]] chain. See https://webidl.spec.whatwg.org/#dfn-named-property-visibility
+    assert_equals(Object.getOwnPropertyDescriptor(wp, "hasOwnProperty"), undefined, supportedNonIndex);
+    assert_equals(Reflect.getOwnPropertyDescriptor(wp, "addEventListener"), undefined, supportedNonIndex);
+    assert_equals(Object.getOwnPropertyDescriptor(wp, "a"), undefined, supportedNonIndex);
+    assert_equals(Reflect.getOwnPropertyDescriptor(wp, 0), undefined, supportedIndex);
+}, "[[GetOwnProperty]] (named property visibility algorithm)");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+
+    appendElementWithId(w, "a");
+    appendFormWithName(w, 0);
+
+    assert_define_own_property_fails(wp, "a", {}, supportedNonIndex);
+    assert_define_own_property_fails(wp, 0, {}, supportedIndex);
+    assert_define_own_property_fails(wp, "b", {}, unsupportedNonIndex);
+    assert_define_own_property_fails(wp, 1, {}, unsupportedIndex);
+    assert_define_own_property_fails(wp, Symbol.toStringTag, {}, existingSymbol);
+    assert_define_own_property_fails(wp, Symbol(), {}, nonExistingSymbol);
+}, "[[DefineOwnProperty]]");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+
+    appendFormWithName(w, "a");
+    appendElementWithId(w, 0);
+
+    assert_true("a" in wp, supportedNonIndex);
+    assert_true(Reflect.has(wp, "a"), supportedNonIndex);
+    assert_true(0 in wp, supportedIndex);
+    assert_true(Reflect.has(wp, 0), supportedIndex);
+
+    assert_false("b" in wp, unsupportedNonIndex);
+    assert_false(Reflect.has(wp, 1), unsupportedIndex);
+}, "[[HasProperty]]");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+    const elA = appendFormWithName(w, "a");
+    const el0 = appendIframeWithName(w, 0);
+
+    assert_equals(wp.a, elA, supportedNonIndex);
+    assert_equals(wp[0], el0, supportedIndex);
+    assert_equals(wp[Symbol.toStringTag], "WindowProperties", existingSymbol);
+
+    assert_equals(wp.b, undefined, unsupportedNonIndex);
+    assert_equals(wp[1], undefined, unsupportedIndex);
+    assert_equals(wp[Symbol.iterator], undefined, nonExistingSymbol);
+}, "[[Get]]");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+
+    appendIframeWithName(w, "isPrototypeOf");
+    appendFormWithName(w, "dispatchEvent");
+    appendElementWithId(w, "a");
+    appendElementWithId(w, 0);
+
+    w.EventTarget.prototype.a = 10;
+    w.Object.prototype[0] = 20;
+
+    // These are shadowed by properties higher in [[Prototype]] chain. See https://webidl.spec.whatwg.org/#dfn-named-property-visibility
+    assert_equals(wp.isPrototypeOf, w.Object.prototype.isPrototypeOf, supportedNonIndex);
+    assert_equals(wp.dispatchEvent, w.EventTarget.prototype.dispatchEvent, supportedNonIndex);
+    assert_equals(wp.a, 10, supportedNonIndex);
+    assert_equals(wp[0], 20, supportedIndex);
+}, "[[Get]] (named property visibility algorithm)");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+    const elA = appendIframeWithName(w, "a");
+    const el0 = appendFormWithName(w, 0);
+
+    assert_set_fails(wp, "a", supportedNonIndex);
+    assert_set_fails(wp, "b", unsupportedNonIndex);
+    assert_set_fails(wp, 0, supportedIndex);
+    assert_set_fails(wp, 1, unsupportedIndex);
+    assert_set_fails(wp, Symbol.toStringTag, existingSymbol);
+    assert_set_fails(wp, Symbol(), nonExistingSymbol);
+
+    assert_equals(wp.a, elA, supportedNonIndex);
+    assert_equals(wp[0], el0, supportedIndex);
+    assert_equals(wp.b, undefined, unsupportedNonIndex);
+    assert_equals(wp[1], undefined, unsupportedIndex);
+}, "[[Set]] (direct)");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+    const receiver = Object.create(wp);
+
+    appendIframeWithName(w, "a");
+    appendElementWithId(w, 0);
+
+    let setterThisValue;
+    Object.defineProperty(w.Object.prototype, 1, { set() { setterThisValue = this; } });
+    Object.defineProperty(w.EventTarget.prototype, "b", { writable: false });
+
+    receiver.a = 10;
+    assert_throws_js(TypeError, () => { receiver.b = {}; }, unsupportedNonIndex);
+    receiver[0] = 20;
+    receiver[1] = {};
+
+    assert_equals(receiver.a, 10, supportedNonIndex);
+    assert_equals(receiver[0], 20, supportedIndex);
+    assert_false(receiver.hasOwnProperty("b"), unsupportedNonIndex);
+    assert_false(receiver.hasOwnProperty(1), unsupportedIndex);
+    assert_equals(setterThisValue, receiver, "setter |this| value is receiver");
+}, "[[Set]] (prototype chain)");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+    const receiver = {};
+
+    appendFormWithName(w, "a");
+    appendIframeWithName(w, 0);
+
+    let setterThisValue;
+    Object.defineProperty(w.Object.prototype, "b", { set() { setterThisValue = this; } });
+    Object.defineProperty(w.EventTarget.prototype, 1, { writable: false });
+
+    assert_true(Reflect.set(wp, "a", 10, receiver), supportedNonIndex);
+    assert_true(Reflect.set(wp, 0, 20, receiver), supportedIndex);
+    assert_true(Reflect.set(wp, "b", {}, receiver), unsupportedNonIndex);
+    assert_false(Reflect.set(wp, 1, {}, receiver), unsupportedIndex);
+
+    assert_equals(receiver.a, 10, supportedNonIndex);
+    assert_equals(receiver[0], 20, supportedIndex);
+    assert_false(receiver.hasOwnProperty("b"), unsupportedNonIndex);
+    assert_equals(setterThisValue, receiver, "setter |this| value is receiver");
+    assert_false(receiver.hasOwnProperty(1), unsupportedIndex);
+}, "[[Set]] (Reflect.set)");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+    const elA = appendFormWithName(w, "a");
+    const el0 = appendElementWithId(w, 0);
+
+    assert_delete_fails(wp, "a", supportedNonIndex);
+    assert_delete_fails(wp, 0, supportedIndex);
+    assert_delete_fails(wp, "b", unsupportedNonIndex);
+    assert_delete_fails(wp, 1, unsupportedIndex);
+    assert_delete_fails(wp, Symbol.toStringTag, existingSymbol);
+    assert_delete_fails(wp, Symbol("foo"), nonExistingSymbol);
+
+    assert_equals(wp.a, elA, supportedNonIndex);
+    assert_equals(wp[0], el0, supportedIndex);
+    assert_equals(wp[Symbol.toStringTag], "WindowProperties", existingSymbol);
+}, "[[Delete]]");
+
+test(t => {
+    const { w, wp } = createWindowProperties(t);
+
+    appendIframeWithName(w, "a");
+    appendElementWithId(w, 0);
+    appendFormWithName(w, "b");
+
+    const forInKeys = [];
+    for (const key in wp)
+        forInKeys.push(key);
+
+    assert_array_equals(forInKeys, Object.keys(w.EventTarget.prototype));
+    assert_array_equals(Object.getOwnPropertyNames(wp), []);
+    assert_array_equals(Reflect.ownKeys(wp), [Symbol.toStringTag]);
+}, "[[OwnPropertyKeys]]");
+
+function createWindowProperties(t) {
+    const iframe = document.createElement("iframe");
+    document.body.append(iframe);
+    t.add_cleanup(() => { iframe.remove(); });
+
+    const w = iframe.contentWindow;
+    const wp = Object.getPrototypeOf(w.Window.prototype);
+    return { w, wp };
+}
+
+function appendIframeWithName(w, name) {
+    const el = w.document.createElement("iframe");
+    el.name = name;
+    w.document.body.append(el);
+    return el.contentWindow;
+}
+
+function appendFormWithName(w, name) {
+    const el = w.document.createElement("form");
+    el.name = name;
+    w.document.body.append(el);
+    return el;
+}
+
+function appendElementWithId(w, id) {
+    const el = w.document.createElement("div");
+    el.id = id;
+    w.document.body.append(el);
+    return el;
+}
+
+function assert_prop_desc(desc, value, testInfo) {
+    assert_equals(typeof desc, "object", `${testInfo} typeof desc`);
+    assert_equals(desc.value, value, `${testInfo} [[Value]]`);
+    assert_true(desc.writable, `${testInfo} [[Writable]]`);
+    assert_false(desc.enumerable, `${testInfo} [[Enumerable]]`);
+    assert_true(desc.configurable, `${testInfo} [[Configurable]]`);
+}
+
+function assert_define_own_property_fails(object, key, desc, testInfo) {
+    assert_throws_js(TypeError, () => { Object.defineProperty(object, key, desc); }, testInfo);
+    assert_false(Reflect.defineProperty(object, key, desc), testInfo);
+}
+
+function assert_set_fails(object, key, value, testInfo) {
+    sloppyModeSet(object, key, value);
+    assert_throws_js(TypeError, () => { object[key] = value; }, testInfo);
+    assert_false(Reflect.set(object, key, value), testInfo);
+}
+
+function assert_delete_fails(object, key, testInfo) {
+    assert_throws_js(TypeError, () => { delete object[key]; }, testInfo);
+    assert_false(Reflect.deleteProperty(object, key), testInfo);
+}
+</script>
diff --git a/test/fixtures/wpt/webidl/idlharness.any.js b/test/fixtures/wpt/webidl/idlharness.any.js
new file mode 100644
index 00000000000000..f8b285c485c43a
--- /dev/null
+++ b/test/fixtures/wpt/webidl/idlharness.any.js
@@ -0,0 +1,17 @@
+// META: script=/resources/WebIDLParser.js
+// META: script=/resources/idlharness.js
+// META: global=window,dedicatedworker,shadowrealm-in-window
+
+"use strict";
+
+idl_test(
+  ['webidl'],
+  [],
+  idl_array => {
+    idl_array.add_objects({
+      DOMException: ['new DOMException()',
+                     'new DOMException("my message")',
+                     'new DOMException("my message", "myName")']
+    });
+  }
+);
diff --git a/test/sequential/test-watch-mode-restart-esm-loading-error.mjs b/test/sequential/test-watch-mode-restart-esm-loading-error.mjs
new file mode 100644
index 00000000000000..9d937aa2ed93cb
--- /dev/null
+++ b/test/sequential/test-watch-mode-restart-esm-loading-error.mjs
@@ -0,0 +1,126 @@
+import * as common from '../common/index.mjs';
+import tmpdir from '../common/tmpdir.js';
+import assert from 'node:assert';
+import path from 'node:path';
+import { execPath } from 'node:process';
+import { spawn } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { inspect } from 'node:util';
+import { createInterface } from 'node:readline';
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+let tmpFiles = 0;
+function createTmpFile(content = 'console.log("running");', ext = '.js', basename = tmpdir.path) {
+  const file = path.join(basename, `${tmpFiles++}${ext}`);
+  writeFileSync(file, content);
+  return file;
+}
+
+function runInBackground({ args = [], options = {}, completed = 'Completed running', shouldFail = false }) {
+  let future = Promise.withResolvers();
+  let child;
+  let stderr = '';
+  let stdout = [];
+
+  const run = () => {
+    args.unshift('--no-warnings');
+    child = spawn(execPath, args, { encoding: 'utf8', stdio: 'pipe', ...options });
+
+    child.stderr.on('data', (data) => {
+      stderr += data;
+    });
+
+    const rl = createInterface({ input: child.stdout });
+    rl.on('line', (data) => {
+      if (!data.startsWith('Waiting for graceful termination') && !data.startsWith('Gracefully restarted')) {
+        stdout.push(data);
+        if (data.startsWith(completed)) {
+          future.resolve({ stderr, stdout });
+          future = Promise.withResolvers();
+          stdout = [];
+          stderr = '';
+        } else if (data.startsWith('Failed running')) {
+          if (shouldFail) {
+            future.resolve({ stderr, stdout });
+          } else {
+            future.reject({ stderr, stdout });
+          }
+          future = Promise.withResolvers();
+          stdout = [];
+          stderr = '';
+        }
+      }
+    });
+  };
+
+  return {
+    async done() {
+      child?.kill();
+      future.resolve();
+      return { stdout, stderr };
+    },
+    restart(timeout = 1000) {
+      if (!child) {
+        run();
+      }
+      const timer = setTimeout(() => {
+        if (!future.resolved) {
+          child.kill();
+          future.reject(new Error('Timed out waiting for restart'));
+        }
+      }, timeout);
+      return future.promise.finally(() => {
+        clearTimeout(timer);
+      });
+    },
+  };
+}
+
+tmpdir.refresh();
+
+// Create initial file with valid code
+const initialContent = `console.log('hello, world');`;
+const file = createTmpFile(initialContent, '.mjs');
+
+const { done, restart } = runInBackground({
+  args: ['--watch', file],
+  completed: 'Completed running',
+  shouldFail: true,
+});
+
+try {
+  const { stdout, stderr } = await restart();
+  assert.strictEqual(stderr, '');
+  assert.deepStrictEqual(stdout, [
+    'hello, world',
+    `Completed running ${inspect(file)}. Waiting for file changes before restarting...`,
+  ]);
+
+  // Update file with syntax error
+  const syntaxErrorContent = `console.log('hello, wor`;
+  writeFileSync(file, syntaxErrorContent);
+
+  // Wait for the failed restart
+  const { stderr: stderr2, stdout: stdout2 } = await restart();
+  assert.match(stderr2, /SyntaxError: Invalid or unexpected token/);
+  assert.deepStrictEqual(stdout2, [
+    `Restarting ${inspect(file)}`,
+    `Failed running ${inspect(file)}. Waiting for file changes before restarting...`,
+  ]);
+
+  writeFileSync(file, `console.log('hello again, world');`);
+
+  const { stderr: stderr3, stdout: stdout3 } = await restart();
+
+  // Verify it recovered and ran successfully
+  assert.strictEqual(stderr3, '');
+  assert.deepStrictEqual(stdout3, [
+    `Restarting ${inspect(file)}`,
+    'hello again, world',
+    `Completed running ${inspect(file)}. Waiting for file changes before restarting...`,
+  ]);
+} finally {
+  await done();
+}
diff --git a/test/wpt/status/webidl.json b/test/wpt/status/webidl.json
new file mode 100644
index 00000000000000..b29a000a9d8b92
--- /dev/null
+++ b/test/wpt/status/webidl.json
@@ -0,0 +1,70 @@
+{
+  "ecmascript-binding/class-string-named-properties-object.window.js": {
+    "fail": {
+      "expected": [
+        "evaluation in WPTRunner.runJsTests()"
+      ]
+    }
+  },
+  "ecmascript-binding/global-immutable-prototype.any.js": {
+    "fail": {
+      "expected": [
+        "Setting to a different prototype"
+      ]
+    }
+  },
+  "ecmascript-binding/global-mutable-prototype.any.js": {
+    "fail": {
+      "expected": [
+        "Setting to a different prototype"
+      ]
+    }
+  },
+  "ecmascript-binding/global-object-implicit-this-value.any.js": {
+    "fail": {
+      "expected": [
+        "Global object's getter throws when called on incompatible object",
+        "Global object's setter throws when called on incompatible object",
+        "Global object's operation throws when called on incompatible object",
+        "Global object's getter works when called on null / undefined",
+        "Global object's setter works when called on null / undefined",
+        "evaluation in WPTRunner.runJsTests()"
+      ]
+    }
+  },
+  "ecmascript-binding/legacy-factor-function-subclass.window.js": {
+    "fail": {
+      "expected": [
+        "[LegacyFactoryFunction] can be subclassed and correctly handles NewTarget"
+      ]
+    }
+  },
+  "ecmascript-binding/legacy-factory-function-builtin-properties.window.js": {
+    "fail": {
+      "expected": [
+        "Legacy factory function property enumeration order of \"length\", \"name\", and \"prototype\""
+      ]
+    }
+  },
+  "ecmascript-binding/no-regexp-special-casing.any.js": {
+    "fail": {
+      "expected": [
+        "Can be used as an object implementing a callback interface"
+      ]
+    }
+  },
+  "ecmascript-binding/observable-array-no-leak-of-internals.window.js": {
+    "fail": {
+      "expected": [
+        "ObservableArray's internals won't leak"
+      ]
+    }
+  },
+  "ecmascript-binding/observable-array-ownkeys.window.js": {
+    "fail": {
+      "expected": [
+        "ObservableArray's ownKeys trap"
+      ]
+    }
+  }
+}
diff --git a/test/wpt/test-webidl.js b/test/wpt/test-webidl.js
new file mode 100644
index 00000000000000..682616608ea169
--- /dev/null
+++ b/test/wpt/test-webidl.js
@@ -0,0 +1,8 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('webidl');
+
+runner.runJsTests();
diff --git a/vcbuild.bat b/vcbuild.bat
index 18b0f3aa6fdaed..9f324c7e5b8ae0 100644
--- a/vcbuild.bat
+++ b/vcbuild.bat
@@ -11,7 +11,7 @@ if /i "%arg:~-4%"=="help" goto help
 cd %~dp0
 
 set JS_SUITES=default
-set NATIVE_SUITES=addons js-native-api node-api
+set NATIVE_SUITES=addons js-native-api node-api embedding
 @rem CI_* variables should be kept synchronized with the ones in Makefile
 set "CI_NATIVE_SUITES=%NATIVE_SUITES% benchmark"
 set "CI_JS_SUITES=%JS_SUITES% pummel"
@@ -736,9 +736,6 @@ if not exist "%config%\cctest.exe" echo cctest.exe not found. Run "vcbuild test"
 echo running 'cctest %cctest_args%'
 "%config%\cctest" %cctest_args%
 if %errorlevel% neq 0 set exit_code=%errorlevel%
-echo running '%node_exe% test\embedding\test-embedding.js'
-"%node_exe%" test\embedding\test-embedding.js
-if %errorlevel% neq 0 set exit_code=%errorlevel%
 :run-test-py
 echo running 'python tools\test.py %test_args%'
 python tools\test.py %test_args%