From 9b27a5e96243025f2a5e3db20c44e626ca714264 Mon Sep 17 00:00:00 2001
From: Hiroshige Hayashizaki <hiroshige@chromium.org>
Date: Wed, 15 Jan 2020 02:39:51 -0800
Subject: [PATCH] [Import Maps] Migrate Jest-based parsing tests into
 JSON-based

This CL

- Converts Jest-based parsing tests into JSONs
(with minor refinement, and removing test cases depending
on interoperability issues of underlying URL parsers),
- Adjust the JSON schema for parsing tests, and
- Removes imported resolution tests.

The test failures
(virtual/import-maps-without-builtin-modules/external/wpt/import-maps/common/parsing.tentative.html)
are due to https://github.com/WICG/import-maps/issues/184, i.e.
whether `null` mappings are removed from parsed import map or not.

Bug: 1026809, https://github.com/WICG/import-maps/issues/170
Change-Id: If1e53cbeafd44c1de1a7fa38ef646fcd5721b495
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1982509
Reviewed-by: Domenic Denicola <domenic@chromium.org>
Commit-Queue: Hiroshige Hayashizaki <hiroshige@chromium.org>
Cr-Commit-Position: refs/heads/master@{#731910}
---
 import-maps/common/README.md                  |  12 +-
 import-maps/common/parsing.tentative.html     |  26 +++
 .../common/resources/common-test-helper.js    | 132 ++++++++---
 .../resources/parsing-addresses-absolute.json |  63 ++++++
 .../resources/parsing-addresses-invalid.json  |  21 ++
 .../common/resources/parsing-addresses.json   |  73 ++++++
 .../resources/parsing-invalid-json.json       |   6 +
 .../parsing-schema-normalization.json         |  31 +++
 .../resources/parsing-schema-scope.json       |  46 ++++
 .../parsing-schema-specifier-map.json         |  38 ++++
 .../resources/parsing-schema-toplevel.json    |  97 ++++++++
 .../common/resources/parsing-scope-keys.json  | 191 ++++++++++++++++
 .../resources/parsing-specifier-keys.json     | 209 ++++++++++++++++++
 .../resources/parsing-trailing-slashes.json   |  13 ++
 .../imported/parsing-addresses.tentative.html |  11 -
 .../imported/parsing-schema.tentative.html    |  11 -
 .../parsing-scope-keys.tentative.html         |  11 -
 .../parsing-specifier-keys.tentative.html     |  11 -
 .../imported/resources/helpers/parsing.js     |  44 ----
 .../imported/resources/parsing-addresses.js   | 175 ---------------
 .../imported/resources/parsing-schema.js      |  99 ---------
 .../imported/resources/parsing-scope-keys.js  | 144 ------------
 .../resources/parsing-specifier-keys.js       | 164 --------------
 23 files changed, 921 insertions(+), 707 deletions(-)
 create mode 100644 import-maps/common/parsing.tentative.html
 create mode 100644 import-maps/common/resources/parsing-addresses-absolute.json
 create mode 100644 import-maps/common/resources/parsing-addresses-invalid.json
 create mode 100644 import-maps/common/resources/parsing-addresses.json
 create mode 100644 import-maps/common/resources/parsing-invalid-json.json
 create mode 100644 import-maps/common/resources/parsing-schema-normalization.json
 create mode 100644 import-maps/common/resources/parsing-schema-scope.json
 create mode 100644 import-maps/common/resources/parsing-schema-specifier-map.json
 create mode 100644 import-maps/common/resources/parsing-schema-toplevel.json
 create mode 100644 import-maps/common/resources/parsing-scope-keys.json
 create mode 100644 import-maps/common/resources/parsing-specifier-keys.json
 create mode 100644 import-maps/common/resources/parsing-trailing-slashes.json
 delete mode 100644 import-maps/imported/parsing-addresses.tentative.html
 delete mode 100644 import-maps/imported/parsing-schema.tentative.html
 delete mode 100644 import-maps/imported/parsing-scope-keys.tentative.html
 delete mode 100644 import-maps/imported/parsing-specifier-keys.tentative.html
 delete mode 100644 import-maps/imported/resources/helpers/parsing.js
 delete mode 100644 import-maps/imported/resources/parsing-addresses.js
 delete mode 100644 import-maps/imported/resources/parsing-schema.js
 delete mode 100644 import-maps/imported/resources/parsing-scope-keys.js
 delete mode 100644 import-maps/imported/resources/parsing-specifier-keys.js

diff --git a/import-maps/common/README.md b/import-maps/common/README.md
index cda42d06099f16..6092c0d767050d 100644
--- a/import-maps/common/README.md
+++ b/import-maps/common/README.md
@@ -6,7 +6,12 @@ tests for the reference JavaScript implementation at [WICG repository](https://g
 
 ## Basics
 
-A **test object** describes a set of parameters (import maps and base URLs) and specifiers to be tested.
+A **test object** describes a set of parameters (import maps and base URLs) and test expectations.
+Test expectations can be:
+
+- Expected resulting URLs for specifiers (resolution tests), or
+- Expected parsed import maps (parsing tests).
+
 Each JSON file under [resources/](resources/) directory consists of a test object.
 A minimum test object would be:
 
@@ -33,10 +38,11 @@ Required fields:
     - In WPT tests, this is used for the test name of `promise_test()` together with specifier to be resolved, like `"Main test name: a"`.
 - `importMap` (object or string): the import map to be attached.
 - `importMapBaseURL` (string): the base URL used for [parsing the import map](https://wicg.github.io/import-maps/#parse-an-import-map-string).
-- `baseURL` (string): the base URL used in [resolving a specifier](https://wicg.github.io/import-maps/#resolve-a-module-specifier) for each specifiers.
-- `expectedResults` (object; string to (string or null)): test cases.
+- (resolution tests only) `expectedResults` (object; string to (string or null)): resolution test cases.
     - The keys are specifiers to be resolved.
     - The values are expected resolved URLs. If `null`, resolution should fail.
+- (resolution tests only) `baseURL` (string): the base URL used in [resolving a specifier](https://wicg.github.io/import-maps/#resolve-a-module-specifier) for each specifiers.
+- (parsing tests only) `expectedParsedImportMap` (object): the expected parsed import map for parsing test cases.
 
 Optional fields:
 
diff --git a/import-maps/common/parsing.tentative.html b/import-maps/common/parsing.tentative.html
new file mode 100644
index 00000000000000..d3334d7bbb9b44
--- /dev/null
+++ b/import-maps/common/parsing.tentative.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<meta name="timeout" content="long">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<body>
+<script type="module">
+import { runTestsFromJSON } from "./resources/common-test-helper.js";
+
+for (const json of [
+  'resources/parsing-addresses-absolute.json',
+  'resources/parsing-addresses-invalid.json',
+  'resources/parsing-addresses.json',
+  'resources/parsing-invalid-json.json',
+  'resources/parsing-schema-normalization.json',
+  'resources/parsing-schema-scope.json',
+  'resources/parsing-schema-specifier-map.json',
+  'resources/parsing-schema-toplevel.json',
+  'resources/parsing-scope-keys.json',
+  'resources/parsing-specifier-keys.json',
+  'resources/parsing-trailing-slashes.json',
+]) {
+  promise_test(() =>
+    runTestsFromJSON(json),
+    "Test helper: fetching and sanity checking test JSON: " + json);
+}
+</script>
diff --git a/import-maps/common/resources/common-test-helper.js b/import-maps/common/resources/common-test-helper.js
index 002c4b51fd06a6..0ddad9fe150b51 100644
--- a/import-maps/common/resources/common-test-helper.js
+++ b/import-maps/common/resources/common-test-helper.js
@@ -2,17 +2,15 @@ setup({allow_uncaught_exception : true});
 
 // Creates a new Document (via <iframe>) and add an inline import map.
 function parse(importMap, importMapBaseURL) {
-  return new Promise((resolve, reject) => {
+  return new Promise(resolve => {
     const importMapString = JSON.stringify(importMap);
     const iframe = document.createElement('iframe');
 
     window.addEventListener('message', event => {
-        if (event.data.type === 'Success') {
-          resolve(iframe);
-        } else {
-          // Currently we don't distinguish fetch errors and parse errors.
-          reject(event.data.error);
-        }
+        // Parsing result is saved here and checked later, rather than
+        // rejecting the promise on errors.
+        iframe.parseImportMapResult = event.data.type;
+        resolve(iframe);
       },
       {once: true});
 
@@ -40,18 +38,28 @@ function parse(importMap, importMapBaseURL) {
       // Handle specifier resolution requests from the parent frame.
       window.addEventListener('message', event => {
         try {
-          // URL resolution is tested using Chromium's internals.
-          // TODO(hiroshige): Remove the Chromium-specific dependency.
-          const result = internals.resolveModuleSpecifier(
-              event.data.specifier,
-              event.data.baseURL,
-              document);
-          parent.postMessage({type: 'ResolutionSuccess', result: result}, '*');
+          if (event.data.action === 'resolve') {
+            // URL resolution is tested using Chromium's internals.
+            // TODO(hiroshige): Remove the Chromium-specific dependency.
+            const result = internals.resolveModuleSpecifier(
+                event.data.specifier,
+                event.data.baseURL,
+                document);
+            parent.postMessage({type: 'ResolutionSuccess', result: result}, '*');
+         } else if (event.data.action === 'getParsedImportMap') {
+           parent.postMessage({
+               type: 'GetParsedImportMapSuccess',
+               result: internals.getParsedImportMap(document)}, '*');
+         } else {
+           parent.postMessage({
+               type: 'Failure',
+               result: "Invalid Action: " + event.data.action}, '*');
+         }
         } catch (e) {
           // We post error names instead of error objects themselves and
           // re-create error objects later, to avoid issues around serializing
           // error objects which is a quite new feature.
-          parent.postMessage({type: 'ResolutionFailure', result: e.name}, '*');
+          parent.postMessage({type: 'Failure', result: e.name}, '*');
         }
       });
       </script>
@@ -77,7 +85,7 @@ function resolve(specifier, parsedImportMap, baseURL) {
     window.addEventListener('message', event => {
         if (event.data.type === 'ResolutionSuccess') {
           resolve(event.data.result);
-        } else if (event.data.type === 'ResolutionFailure') {
+        } else if (event.data.type === 'Failure') {
           if (event.data.result === 'TypeError') {
             reject(new TypeError());
           } else {
@@ -90,7 +98,21 @@ function resolve(specifier, parsedImportMap, baseURL) {
       {once: true});
 
     parsedImportMap.contentWindow.postMessage(
-        {specifier: specifier, baseURL: baseURL}, '*');
+        {action: "resolve", specifier: specifier, baseURL: baseURL}, '*');
+  });
+}
+
+// Returns a promise that is resolved with a serialized string of
+// a parsed import map JSON object.
+function getParsedImportMap(parsedImportMap) {
+  return new Promise((resolve, reject) => {
+    window.addEventListener('message', event => {
+        resolve(event.data.result);
+      },
+      {once: true});
+
+    parsedImportMap.contentWindow.postMessage(
+        {action: "getParsedImportMap"}, '*');
   });
 }
 
@@ -101,11 +123,27 @@ function assert_no_extra_properties(object, expectedProperties, description) {
   }
 }
 
+// Sort keys and then stringify for comparison.
+function stringifyImportMap(importMap) {
+  function getKeys(m) {
+    if (typeof m !== 'object')
+      return [];
+
+    let keys = [];
+    for (const key in m) {
+      keys.push(key);
+      keys = keys.concat(getKeys(m[key]));
+    }
+    return keys;
+  }
+  return JSON.stringify(importMap, getKeys(importMap).sort());
+}
+
 async function runTests(j) {
   const tests = j.tests;
   delete j.tests;
 
-  if (j.importMap) {
+  if (j.hasOwnProperty('importMap')) {
     assert_own_property(j, 'importMap');
     assert_own_property(j, 'importMapBaseURL');
     j.parsedImportMap = await parse(j.importMap, j.importMapBaseURL);
@@ -115,7 +153,8 @@ async function runTests(j) {
 
   assert_no_extra_properties(
       j,
-      ['expectedResults', 'baseURL', 'name', 'parsedImportMap',
+      ['expectedResults', 'expectedParsedImportMap',
+      'baseURL', 'name', 'parsedImportMap',
       'importMap', 'importMapBaseURL',
       'link', 'details'],
       j.name);
@@ -133,26 +172,51 @@ async function runTests(j) {
     }
   } else {
     // Leaf node.
-    for (const key of
-        ['expectedResults', 'parsedImportMap', 'baseURL', 'name']) {
+    for (const key of ['parsedImportMap', 'name']) {
       assert_own_property(j, key, j.name);
     }
+    assert_true(j.hasOwnProperty('expectedResults') ||
+                j.hasOwnProperty('expectedParsedImportMap'),
+                'expectedResults or expectedParsedImportMap should exist');
+
+    // Resolution tests.
+    if (j.hasOwnProperty('expectedResults')) {
+      assert_own_property(j, 'baseURL');
+      assert_equals(
+          j.parsedImportMap.parseImportMapResult,
+          "Success",
+          "Import map registration should be successful for resolution tests");
+      for (const specifier in j.expectedResults) {
+        const expected = j.expectedResults[specifier];
+        promise_test(async t => {
+            if (expected === null) {
+              return promise_rejects(t, new TypeError(),
+                  resolve(specifier, j.parsedImportMap, j.baseURL));
+            } else {
+              // Should be resolved to `expected`.
+              const actual = await resolve(
+                  specifier, j.parsedImportMap, j.baseURL);
+              assert_equals(actual, expected);
+            }
+          },
+          j.name + ': ' + specifier);
+      }
+    }
 
-    for (const specifier in j.expectedResults) {
-      const expected = j.expectedResults[specifier];
+    // Parsing tests.
+    if (j.hasOwnProperty('expectedParsedImportMap')) {
       promise_test(async t => {
-          if (expected === null) {
-            return promise_rejects(t, new TypeError(),
-                resolve(specifier, j.parsedImportMap, j.baseURL));
-          } else {
-            // Should be resolved to `expected`.
-            const actual = await resolve(
-                specifier, j.parsedImportMap, j.baseURL);
-            assert_equals(actual, expected);
-          }
-        },
-        j.name + ': ' + specifier);
+        if (j.expectedParsedImportMap === null) {
+          assert_equals(j.parsedImportMap.parseImportMapResult, "ParseError");
+        } else {
+          const actualParsedImportMap =
+              await getParsedImportMap(j.parsedImportMap);
+          assert_equals(stringifyImportMap(JSON.parse(actualParsedImportMap)),
+                        stringifyImportMap(j.expectedParsedImportMap));
+        }
+      }, j.name);
     }
+
   }
 }
 
diff --git a/import-maps/common/resources/parsing-addresses-absolute.json b/import-maps/common/resources/parsing-addresses-absolute.json
new file mode 100644
index 00000000000000..d392f8224faeb1
--- /dev/null
+++ b/import-maps/common/resources/parsing-addresses-absolute.json
@@ -0,0 +1,63 @@
+{
+  "name": "Absolute URL addresses",
+  "tests": {
+    "should only accept absolute URL addresses with fetch schemes": {
+      "importMap": {
+        "imports": {
+          "about": "about:good",
+          "blob": "blob:good",
+          "data": "data:good",
+          "file": "file:///good",
+          "filesystem": "filesystem:http://example.com/good/",
+          "http": "http://good/",
+          "https": "https://good/",
+          "ftp": "ftp://good/",
+          "import": "import:bad",
+          "mailto": "mailto:bad",
+          "javascript": "javascript:bad",
+          "wss": "wss:bad"
+        }
+      },
+      "importMapBaseURL": "https://base.example/path1/path2/path3",
+      "expectedParsedImportMap": {
+        "imports": {
+          "about": "about:good",
+          "blob": "blob:good",
+          "data": "data:good",
+          "file": "file:///good",
+          "filesystem": "filesystem:http://example.com/good/",
+          "http": "http://good/",
+          "https": "https://good/",
+          "ftp": "ftp://good/",
+          "import": "import:bad",
+          "javascript": "javascript:bad",
+          "mailto": "mailto:bad",
+          "wss": "wss://bad/"
+        },
+        "scopes": {}
+      }
+    },
+    "should parse absolute URLs, ignoring unparseable ones": {
+      "importMap": {
+        "imports": {
+          "unparseable2": "https://example.com:demo",
+          "unparseable3": "http://[www.example.com]/",
+          "invalidButParseable1": "https:example.org",
+          "invalidButParseable2": "https://///example.com///",
+          "prettyNormal": "https://example.net",
+          "percentDecoding": "https://ex%41mple.com/"
+        }
+      },
+      "importMapBaseURL": "https://base.example/path1/path2/path3",
+      "expectedParsedImportMap": {
+        "imports": {
+          "invalidButParseable1": "https://example.org/",
+          "invalidButParseable2": "https://example.com///",
+          "prettyNormal": "https://example.net/",
+          "percentDecoding": "https://example.com/"
+        },
+        "scopes": {}
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-addresses-invalid.json b/import-maps/common/resources/parsing-addresses-invalid.json
new file mode 100644
index 00000000000000..7d6502a1bc485c
--- /dev/null
+++ b/import-maps/common/resources/parsing-addresses-invalid.json
@@ -0,0 +1,21 @@
+{
+  "name": "Other invalid addresses",
+  "tests": {
+    "should ignore unprefixed strings that are not absolute URLs": {
+      "importMap": {
+        "imports": {
+          "foo1": "bar",
+          "foo2": "\\bar",
+          "foo3": "~bar",
+          "foo4": "#bar",
+          "foo5": "?bar"
+        }
+      },
+      "importMapBaseURL": "https://base.example/path1/path2/path3",
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-addresses.json b/import-maps/common/resources/parsing-addresses.json
new file mode 100644
index 00000000000000..d5bb54f0c8073d
--- /dev/null
+++ b/import-maps/common/resources/parsing-addresses.json
@@ -0,0 +1,73 @@
+{
+  "name": "Relative URL-like addresses",
+  "tests": {
+    "should accept strings prefixed with ./, ../, or /": {
+      "importMap": {
+        "imports": {
+          "dotSlash": "./foo",
+          "dotDotSlash": "../foo",
+          "slash": "/foo"
+        }
+      },
+      "importMapBaseURL": "https://base.example/path1/path2/path3",
+      "expectedParsedImportMap": {
+        "imports": {
+          "dotSlash": "https://base.example/path1/path2/foo",
+          "dotDotSlash": "https://base.example/path1/foo",
+          "slash": "https://base.example/foo"
+        },
+        "scopes": {}
+      }
+    },
+    "should not accept strings prefixed with ./, ../, or / for data: base URLs": {
+      "importMap": {
+        "imports": {
+          "dotSlash": "./foo",
+          "dotDotSlash": "../foo",
+          "slash": "/foo"
+        }
+      },
+      "importMapBaseURL": "data:text/html,test",
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    },
+    "should accept the literal strings ./, ../, or / with no suffix": {
+      "importMap": {
+        "imports": {
+          "dotSlash": "./",
+          "dotDotSlash": "../",
+          "slash": "/"
+        }
+      },
+      "importMapBaseURL": "https://base.example/path1/path2/path3",
+      "expectedParsedImportMap": {
+        "imports": {
+          "dotSlash": "https://base.example/path1/path2/",
+          "dotDotSlash": "https://base.example/path1/",
+          "slash": "https://base.example/"
+        },
+        "scopes": {}
+      }
+    },
+    "should ignore percent-encoded variants of ./, ../, or /": {
+      "importMap": {
+        "imports": {
+          "dotSlash1": "%2E/",
+          "dotDotSlash1": "%2E%2E/",
+          "dotSlash2": ".%2F",
+          "dotDotSlash2": "..%2F",
+          "slash2": "%2F",
+          "dotSlash3": "%2E%2F",
+          "dotDotSlash3": "%2E%2E%2F"
+        }
+      },
+      "importMapBaseURL": "https://base.example/path1/path2/path3",
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-invalid-json.json b/import-maps/common/resources/parsing-invalid-json.json
new file mode 100644
index 00000000000000..1bd1c94e8947a9
--- /dev/null
+++ b/import-maps/common/resources/parsing-invalid-json.json
@@ -0,0 +1,6 @@
+{
+  "name": "Invalid JSON",
+  "importMapBaseURL": "https://base.example/",
+  "importMap": "{imports: {}}",
+  "expectedParsedImportMap": null
+}
diff --git a/import-maps/common/resources/parsing-schema-normalization.json b/import-maps/common/resources/parsing-schema-normalization.json
new file mode 100644
index 00000000000000..a330bb8799b68e
--- /dev/null
+++ b/import-maps/common/resources/parsing-schema-normalization.json
@@ -0,0 +1,31 @@
+{
+  "name": "Normalization",
+  "importMapBaseURL": "https://base.example/",
+  "tests": {
+    "should normalize empty import maps to have imports and scopes keys": {
+      "importMap": {},
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    },
+    "should normalize an import map without imports to have imports": {
+      "importMap": {
+        "scopes": {}
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    },
+    "should normalize an import map without scopes to have scopes": {
+      "importMap": {
+        "imports": {}
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-schema-scope.json b/import-maps/common/resources/parsing-schema-scope.json
new file mode 100644
index 00000000000000..04d09395c32dba
--- /dev/null
+++ b/import-maps/common/resources/parsing-schema-scope.json
@@ -0,0 +1,46 @@
+{
+  "name": "Mismatching scopes schema",
+  "importMapBaseURL": "https://base.example/",
+  "tests": {
+    "should throw if a scope's value is not an object": {
+      "expectedParsedImportMap": null,
+      "tests": {
+        "null": {
+          "importMap": {
+            "scopes": {
+              "https://example.com/": null
+            }
+          }
+        },
+        "boolean": {
+          "importMap": {
+            "scopes": {
+              "https://example.com/": true
+            }
+          }
+        },
+        "number": {
+          "importMap": {
+            "scopes": {
+              "https://example.com/": 1
+            }
+          }
+        },
+        "string": {
+          "importMap": {
+            "scopes": {
+              "https://example.com/": "foo"
+            }
+          }
+        },
+        "array": {
+          "importMap": {
+            "scopes": {
+              "https://example.com/": []
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-schema-specifier-map.json b/import-maps/common/resources/parsing-schema-specifier-map.json
new file mode 100644
index 00000000000000..926e7a1f5f73cd
--- /dev/null
+++ b/import-maps/common/resources/parsing-schema-specifier-map.json
@@ -0,0 +1,38 @@
+{
+  "name": "Mismatching the specifier map schema",
+  "importMapBaseURL": "https://base.example/",
+  "tests": {
+    "should ignore entries where the address is not a string": {
+      "importMap": {
+        "imports": {
+          "null": null,
+          "boolean": true,
+          "number": 1,
+          "object": {},
+          "array": [],
+          "array2": [
+            "https://example.com/"
+          ],
+          "string": "https://example.com/"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "string": "https://example.com/"
+        },
+        "scopes": {}
+      }
+    },
+    "should ignore entries where the specifier key is an empty string": {
+      "importMap": {
+        "imports": {
+          "": "https://example.com/"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-schema-toplevel.json b/import-maps/common/resources/parsing-schema-toplevel.json
new file mode 100644
index 00000000000000..278cad2295c12a
--- /dev/null
+++ b/import-maps/common/resources/parsing-schema-toplevel.json
@@ -0,0 +1,97 @@
+{
+  "name": "Mismatching the top-level schema",
+  "importMapBaseURL": "https://base.example/",
+  "tests": {
+    "should throw for top-level non-objects": {
+      "expectedParsedImportMap": null,
+      "tests": {
+        "null": {
+          "importMap": null
+        },
+        "boolean": {
+          "importMap": true
+        },
+        "number": {
+          "importMap": 1
+        },
+        "string": {
+          "importMap": "foo"
+        },
+        "array": {
+          "importMap": []
+        }
+      }
+    },
+    "should throw if imports is a non-object": {
+      "expectedParsedImportMap": null,
+      "tests": {
+        "null": {
+          "importMap": {
+            "imports": null
+          }
+        },
+        "boolean": {
+          "importMap": {
+            "imports": true
+          }
+        },
+        "number": {
+          "importMap": {
+            "imports": 1
+          }
+        },
+        "string": {
+          "importMap": {
+            "imports": "foo"
+          }
+        },
+        "array": {
+          "importMap": {
+            "imports": []
+          }
+        }
+      }
+    },
+    "should throw if scopes is a non-object": {
+      "expectedParsedImportMap": null,
+      "tests": {
+        "null": {
+          "importMap": {
+            "scopes": null
+          }
+        },
+        "boolean": {
+          "importMap": {
+            "scopes": true
+          }
+        },
+        "number": {
+          "importMap": {
+            "scopes": 1
+          }
+        },
+        "string": {
+          "importMap": {
+            "scopes": "foo"
+          }
+        },
+        "array": {
+          "importMap": {
+            "scopes": []
+          }
+        }
+      }
+    },
+    "should ignore unspecified top-level entries": {
+      "importMap": {
+        "imports": {},
+        "new-feature": {},
+        "scops": {}
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-scope-keys.json b/import-maps/common/resources/parsing-scope-keys.json
new file mode 100644
index 00000000000000..4b2f1eeada92ef
--- /dev/null
+++ b/import-maps/common/resources/parsing-scope-keys.json
@@ -0,0 +1,191 @@
+{
+  "importMapBaseURL": "https://base.example/path1/path2/path3",
+  "tests": {
+    "Relative URL scope keys should work with no prefix": {
+      "importMap": {
+        "scopes": {
+          "foo": {}
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "https://base.example/path1/path2/foo": {}
+        }
+      }
+    },
+    "Relative URL scope keys should work with ./, ../, and / prefixes": {
+      "importMap": {
+        "scopes": {
+          "./foo": {},
+          "../foo": {},
+          "/foo": {}
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "https://base.example/path1/path2/foo": {},
+          "https://base.example/path1/foo": {},
+          "https://base.example/foo": {}
+        }
+      }
+    },
+    "Absolute URL scope keys should ignore relative URL scope keys when the base URL is a data: URL": {
+      "importMap": {
+        "scopes": {
+          "./foo": {},
+          "../foo": {},
+          "/foo": {}
+        }
+      },
+      "importMapBaseURL": "data:text/html,test",
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    },
+    "Relative URL scope keys should work with ./, ../, or / with no suffix": {
+      "importMap": {
+        "scopes": {
+          "./": {},
+          "../": {},
+          "/": {}
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "https://base.example/path1/path2/": {},
+          "https://base.example/path1/": {},
+          "https://base.example/": {}
+        }
+      }
+    },
+    "Relative URL scope keys should work with /s, ?s, and #s": {
+      "importMap": {
+        "scopes": {
+          "foo/bar?baz#qux": {}
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "https://base.example/path1/path2/foo/bar?baz#qux": {}
+        }
+      }
+    },
+    "Relative URL scope keys should work with an empty string scope key": {
+      "importMap": {
+        "scopes": {
+          "": {}
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "https://base.example/path1/path2/path3": {}
+        }
+      }
+    },
+    "Relative URL scope keys should work with / suffixes": {
+      "importMap": {
+        "scopes": {
+          "foo/": {},
+          "./foo/": {},
+          "../foo/": {},
+          "/foo/": {},
+          "/foo//": {}
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "https://base.example/path1/path2/foo/": {},
+          "https://base.example/path1/foo/": {},
+          "https://base.example/foo/": {},
+          "https://base.example/foo//": {}
+        }
+      }
+    },
+    "Relative URL scope keys should deduplicate based on URL parsing rules": {
+      "importMap": {
+        "scopes": {
+          "foo/\\": {
+            "1": "./a"
+          },
+          "foo//": {
+            "2": "./b"
+          },
+          "foo\\\\": {
+            "3": "./c"
+          }
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "https://base.example/path1/path2/foo//": {
+            "3": "https://base.example/path1/path2/c"
+          }
+        }
+      }
+    },
+    "Absolute URL scope keys should accept all absolute URL scope keys, with or without fetch schemes": {
+      "importMap": {
+        "scopes": {
+          "about:good": {},
+          "blob:good": {},
+          "data:good": {},
+          "file:///good": {},
+          "filesystem:http://example.com/good/": {},
+          "http://good/": {},
+          "https://good/": {},
+          "ftp://good/": {},
+          "import:bad": {},
+          "mailto:bad": {},
+          "javascript:bad": {},
+          "wss:ba": {}
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "about:good": {},
+          "blob:good": {},
+          "data:good": {},
+          "file:///good": {},
+          "filesystem:http://example.com/good/": {},
+          "http://good/": {},
+          "https://good/": {},
+          "ftp://good/": {},
+          "import:bad": {},
+          "mailto:bad": {},
+          "javascript:bad": {},
+          "wss://ba/": {}
+        }
+      }
+    },
+    "Absolute URL scope keys should parse absolute URL scope keys, ignoring unparseable ones": {
+      "importMap": {
+        "scopes": {
+          "https://example.com:demo": {},
+          "http://[www.example.com]/": {},
+          "https:example.org": {},
+          "https://///example.com///": {},
+          "https://example.net": {},
+          "https://ex%41mple.com/foo/": {}
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {
+          "https://base.example/path1/path2/example.org": {},
+          "https://example.com///": {},
+          "https://example.net/": {},
+          "https://example.com/foo/": {}
+        }
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-specifier-keys.json b/import-maps/common/resources/parsing-specifier-keys.json
new file mode 100644
index 00000000000000..b2d9cf47fa08da
--- /dev/null
+++ b/import-maps/common/resources/parsing-specifier-keys.json
@@ -0,0 +1,209 @@
+{
+  "importMapBaseURL": "https://base.example/path1/path2/path3",
+  "tests": {
+    "Relative URL specifier keys should absolutize strings prefixed with ./, ../, or / into the corresponding URLs": {
+      "importMap": {
+        "imports": {
+          "./foo": "/dotslash",
+          "../foo": "/dotdotslash",
+          "/foo": "/slash"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "https://base.example/path1/path2/foo": "https://base.example/dotslash",
+          "https://base.example/path1/foo": "https://base.example/dotdotslash",
+          "https://base.example/foo": "https://base.example/slash"
+        },
+        "scopes": {}
+      }
+    },
+    "Relative URL specifier keys should not absolutize strings prefixed with ./, ../, or / with a data: URL base": {
+      "importMap": {
+        "imports": {
+          "./foo": "https://example.com/dotslash",
+          "../foo": "https://example.com/dotdotslash",
+          "/foo": "https://example.com/slash"
+        }
+      },
+      "importMapBaseURL": "data:text/html,",
+      "expectedParsedImportMap": {
+        "imports": {
+          "./foo": "https://example.com/dotslash",
+          "../foo": "https://example.com/dotdotslash",
+          "/foo": "https://example.com/slash"
+        },
+        "scopes": {}
+      }
+    },
+    "Relative URL specifier keys should absolutize the literal strings ./, ../, or / with no suffix": {
+      "importMap": {
+        "imports": {
+          "./": "/dotslash/",
+          "../": "/dotdotslash/",
+          "/": "/slash/"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "https://base.example/path1/path2/": "https://base.example/dotslash/",
+          "https://base.example/path1/": "https://base.example/dotdotslash/",
+          "https://base.example/": "https://base.example/slash/"
+        },
+        "scopes": {}
+      }
+    },
+    "Relative URL specifier keys should work with /s, ?s, and #s": {
+      "importMap": {
+        "imports": {
+          "./foo/bar?baz#qux": "/foo"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "https://base.example/path1/path2/foo/bar?baz#qux": "https://base.example/foo"
+        },
+        "scopes": {}
+      }
+    },
+    "Relative URL specifier keys should ignore an empty string key": {
+      "importMap": {
+        "imports": {
+          "": "/foo"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {},
+        "scopes": {}
+      }
+    },
+    "Relative URL specifier keys should treat percent-encoded variants of ./, ../, or / as bare specifiers": {
+      "importMap": {
+        "imports": {
+          "%2E/": "/dotSlash1/",
+          "%2E%2E/": "/dotDotSlash1/",
+          ".%2F": "/dotSlash2",
+          "..%2F": "/dotDotSlash2",
+          "%2F": "/slash2",
+          "%2E%2F": "/dotSlash3",
+          "%2E%2E%2F": "/dotDotSlash3"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "%2E/": "https://base.example/dotSlash1/",
+          "%2E%2E/": "https://base.example/dotDotSlash1/",
+          ".%2F": "https://base.example/dotSlash2",
+          "..%2F": "https://base.example/dotDotSlash2",
+          "%2F": "https://base.example/slash2",
+          "%2E%2F": "https://base.example/dotSlash3",
+          "%2E%2E%2F": "https://base.example/dotDotSlash3"
+        },
+        "scopes": {}
+      }
+    },
+    "Relative URL specifier keys should deduplicate based on URL parsing rules": {
+      "importMap": {
+        "imports": {
+          "./foo/\\": "/foo1",
+          "./foo//": "/foo2",
+          "./foo\\\\": "/foo3"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "https://base.example/path1/path2/foo//": "https://base.example/foo3"
+        },
+        "scopes": {}
+      }
+    },
+    "Absolute URL specifier keys should accept all absolute URL specifier keys, with or without fetch schemes": {
+      "importMap": {
+        "imports": {
+          "about:good": "/about",
+          "blob:good": "/blob",
+          "data:good": "/data",
+          "file:///good": "/file",
+          "filesystem:http://example.com/good/": "/filesystem/",
+          "http://good/": "/http/",
+          "https://good/": "/https/",
+          "ftp://good/": "/ftp/",
+          "import:bad": "/import",
+          "mailto:bad": "/mailto",
+          "javascript:bad": "/javascript",
+          "wss:bad": "/wss"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "about:good": "https://base.example/about",
+          "blob:good": "https://base.example/blob",
+          "data:good": "https://base.example/data",
+          "file:///good": "https://base.example/file",
+          "filesystem:http://example.com/good/": "https://base.example/filesystem/",
+          "http://good/": "https://base.example/http/",
+          "https://good/": "https://base.example/https/",
+          "ftp://good/": "https://base.example/ftp/",
+          "import:bad": "https://base.example/import",
+          "mailto:bad": "https://base.example/mailto",
+          "javascript:bad": "https://base.example/javascript",
+          "wss://bad/": "https://base.example/wss"
+        },
+        "scopes": {}
+      }
+    },
+    "Absolute URL specifier keys should parse absolute URLs, treating unparseable ones as bare specifiers": {
+      "importMap": {
+        "imports": {
+          "https://example.com:demo": "/unparseable2",
+          "http://[www.example.com]/": "/unparseable3/",
+          "https:example.org": "/invalidButParseable1/",
+          "https://///example.com///": "/invalidButParseable2/",
+          "https://example.net": "/prettyNormal/",
+          "https://ex%41mple.com/": "/percentDecoding/"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "https://example.com:demo": "https://base.example/unparseable2",
+          "http://[www.example.com]/": "https://base.example/unparseable3/",
+          "https://example.org/": "https://base.example/invalidButParseable1/",
+          "https://example.com///": "https://base.example/invalidButParseable2/",
+          "https://example.net/": "https://base.example/prettyNormal/",
+          "https://example.com/": "https://base.example/percentDecoding/"
+        },
+        "scopes": {}
+      }
+    },
+    "Specifier keys should be sort correctly (issue #181) - Test #1": {
+      "importMap": {
+        "imports": {
+          "https://example.com/aaa": "https://example.com/aaa",
+          "https://example.com/a": "https://example.com/a"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "https://example.com/aaa": "https://example.com/aaa",
+          "https://example.com/a": "https://example.com/a"
+        },
+        "scopes": {}
+      }
+    },
+    "Specifier keys should be sort correctly (issue #181) - Test #2": {
+      "importMap": {
+        "imports": {
+          "https://example.com/a": "https://example.com/a",
+          "https://example.com/aaa": "https://example.com/aaa"
+        }
+      },
+      "expectedParsedImportMap": {
+        "imports": {
+          "https://example.com/aaa": "https://example.com/aaa",
+          "https://example.com/a": "https://example.com/a"
+        },
+        "scopes": {}
+      }
+    }
+  }
+}
diff --git a/import-maps/common/resources/parsing-trailing-slashes.json b/import-maps/common/resources/parsing-trailing-slashes.json
new file mode 100644
index 00000000000000..21e5faa13ec69c
--- /dev/null
+++ b/import-maps/common/resources/parsing-trailing-slashes.json
@@ -0,0 +1,13 @@
+{
+  "name": "Failing addresses: mismatched trailing slashes",
+  "importMap": {
+    "imports": {
+      "trailer/": "/notrailer"
+    }
+  },
+  "importMapBaseURL": "https://base.example/path1/path2/path3",
+  "expectedParsedImportMap": {
+    "imports": {},
+    "scopes": {}
+  }
+}
diff --git a/import-maps/imported/parsing-addresses.tentative.html b/import-maps/imported/parsing-addresses.tentative.html
deleted file mode 100644
index ddb3b724bb64e2..00000000000000
--- a/import-maps/imported/parsing-addresses.tentative.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="../resources/jest-test-helper.js"></script>
-<script type="module" src="resources/helpers/parsing.js"></script>
-
-<!--
-Imported from https://github.com/WICG/import-maps/blob/master/reference-implementation/__tests__/parsing-addresses.js
--->
-<script type="module" src="resources/parsing-addresses.js"></script>
diff --git a/import-maps/imported/parsing-schema.tentative.html b/import-maps/imported/parsing-schema.tentative.html
deleted file mode 100644
index 6b7c0e5b0eb40e..00000000000000
--- a/import-maps/imported/parsing-schema.tentative.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="../resources/jest-test-helper.js"></script>
-<script type="module" src="resources/helpers/parsing.js"></script>
-
-<!--
-Imported from https://github.com/WICG/import-maps/blob/master/reference-implementation/__tests__/parsing-schema.js
--->
-<script type="module" src="resources/parsing-schema.js"></script>
diff --git a/import-maps/imported/parsing-scope-keys.tentative.html b/import-maps/imported/parsing-scope-keys.tentative.html
deleted file mode 100644
index 601ac37720d700..00000000000000
--- a/import-maps/imported/parsing-scope-keys.tentative.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="../resources/jest-test-helper.js"></script>
-<script type="module" src="resources/helpers/parsing.js"></script>
-
-<!--
-Imported from https://github.com/WICG/import-maps/blob/master/reference-implementation/__tests__/parsing-scope-keys.js
--->
-<script type="module" src="resources/parsing-scope-keys.js"></script>
diff --git a/import-maps/imported/parsing-specifier-keys.tentative.html b/import-maps/imported/parsing-specifier-keys.tentative.html
deleted file mode 100644
index dd547f01d1dfb2..00000000000000
--- a/import-maps/imported/parsing-specifier-keys.tentative.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="../resources/jest-test-helper.js"></script>
-<script type="module" src="resources/helpers/parsing.js"></script>
-
-<!--
-Imported from https://github.com/WICG/import-maps/blob/master/reference-implementation/__tests__/parsing-specifier-keys.js
--->
-<script type="module" src="resources/parsing-specifier-keys.js"></script>
diff --git a/import-maps/imported/resources/helpers/parsing.js b/import-maps/imported/resources/helpers/parsing.js
deleted file mode 100644
index daad6d26d220bb..00000000000000
--- a/import-maps/imported/resources/helpers/parsing.js
+++ /dev/null
@@ -1,44 +0,0 @@
-'use strict';
-const { parseFromString } = require('../../lib/parser.js');
-
-// Local modifications from upstream:
-// Currently warnings and scopes are not checked in expectSpecifierMap().
-exports.expectSpecifierMap = (input, baseURL, output, warnings = []) => {
-  expect(parseFromString(`{ "imports": ${input} }`, baseURL))
-    .toEqual({ imports: output, scopes: {} });
-};
-
-exports.expectScopes = (inputArray, baseURL, outputArray, warnings = []) => {
-  const checkWarnings = testWarningHandler(warnings);
-
-  const inputScopesAsStrings = inputArray.map(scopePrefix => `${JSON.stringify(scopePrefix)}: {}`);
-  const inputString = `{ "scopes": { ${inputScopesAsStrings.join(', ')} } }`;
-
-  const outputScopesObject = {};
-  for (const outputScopePrefix of outputArray) {
-    outputScopesObject[outputScopePrefix] = {};
-  }
-
-  expect(parseFromString(inputString, baseURL)).toEqual({ imports: {}, scopes: outputScopesObject });
-
-  checkWarnings();
-};
-
-exports.expectBad = (input, baseURL, warnings = []) => {
-  const checkWarnings = testWarningHandler(warnings);
-  expect(() => parseFromString(input, baseURL)).toThrow(TypeError);
-  checkWarnings();
-};
-
-exports.expectWarnings = (input, baseURL, output, warnings = []) => {
-  const checkWarnings = testWarningHandler(warnings);
-  expect(parseFromString(input, baseURL)).toEqual(output);
-
-  checkWarnings();
-};
-
-function testWarningHandler(expectedWarnings) {
-  // We don't check warnings on WPT tests, because there are no
-  // ways to catch console warnings from JavaScript.
-  return () => {};
-}
diff --git a/import-maps/imported/resources/parsing-addresses.js b/import-maps/imported/resources/parsing-addresses.js
deleted file mode 100644
index 92d7714ade9b96..00000000000000
--- a/import-maps/imported/resources/parsing-addresses.js
+++ /dev/null
@@ -1,175 +0,0 @@
-'use strict';
-const { expectSpecifierMap } = require('./helpers/parsing.js');
-
-describe('Relative URL-like addresses', () => {
-  it('should accept strings prefixed with ./, ../, or /', () => {
-    expectSpecifierMap(
-      `{
-        "dotSlash": "./foo",
-        "dotDotSlash": "../foo",
-        "slash": "/foo"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        dotSlash: expect.toMatchURL('https://base.example/path1/path2/foo'),
-        dotDotSlash: expect.toMatchURL('https://base.example/path1/foo'),
-        slash: expect.toMatchURL('https://base.example/foo')
-      }
-    );
-  });
-
-  it('should not accept strings prefixed with ./, ../, or / for data: base URLs', () => {
-    expectSpecifierMap(
-      `{
-        "dotSlash": "./foo",
-        "dotDotSlash": "../foo",
-        "slash": "/foo"
-      }`,
-      'data:text/html,test',
-      {
-      },
-      [
-        `Invalid address "./foo" for the specifier key "dotSlash".`,
-        `Invalid address "../foo" for the specifier key "dotDotSlash".`,
-        `Invalid address "/foo" for the specifier key "slash".`
-      ]
-    );
-  });
-
-  it('should accept the literal strings ./, ../, or / with no suffix', () => {
-    expectSpecifierMap(
-      `{
-        "dotSlash": "./",
-        "dotDotSlash": "../",
-        "slash": "/"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        dotSlash: expect.toMatchURL('https://base.example/path1/path2/'),
-        dotDotSlash: expect.toMatchURL('https://base.example/path1/'),
-        slash: expect.toMatchURL('https://base.example/')
-      }
-    );
-  });
-
-  it('should ignore percent-encoded variants of ./, ../, or /', () => {
-    expectSpecifierMap(
-      `{
-        "dotSlash1": "%2E/",
-        "dotDotSlash1": "%2E%2E/",
-        "dotSlash2": ".%2F",
-        "dotDotSlash2": "..%2F",
-        "slash2": "%2F",
-        "dotSlash3": "%2E%2F",
-        "dotDotSlash3": "%2E%2E%2F"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-      },
-      [
-        `Invalid address "%2E/" for the specifier key "dotSlash1".`,
-        `Invalid address "%2E%2E/" for the specifier key "dotDotSlash1".`,
-        `Invalid address ".%2F" for the specifier key "dotSlash2".`,
-        `Invalid address "..%2F" for the specifier key "dotDotSlash2".`,
-        `Invalid address "%2F" for the specifier key "slash2".`,
-        `Invalid address "%2E%2F" for the specifier key "dotSlash3".`,
-        `Invalid address "%2E%2E%2F" for the specifier key "dotDotSlash3".`
-      ]
-    );
-  });
-});
-
-describe('Absolute URL addresses', () => {
-  it('should only accept absolute URL addresses with fetch schemes', () => {
-    expectSpecifierMap(
-      `{
-        "about": "about:good",
-        "blob": "blob:good",
-        "data": "data:good",
-        "file": "file:///good",
-        "filesystem": "filesystem:http://example.com/good/",
-        "http": "http://good/",
-        "https": "https://good/",
-        "ftp": "ftp://good/",
-        "import": "import:bad",
-        "mailto": "mailto:bad",
-        "javascript": "javascript:bad",
-        "wss": "wss:bad"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        about: expect.toMatchURL('about:good'),
-        blob: expect.toMatchURL('blob:good'),
-        data: expect.toMatchURL('data:good'),
-        file: expect.toMatchURL('file:///good'),
-        filesystem: expect.toMatchURL('filesystem:http://example.com/good/'),
-        http: expect.toMatchURL('http://good/'),
-        https: expect.toMatchURL('https://good/'),
-        ftp: expect.toMatchURL('ftp://good/'),
-        import: expect.toMatchURL('import:bad'),
-        javascript: expect.toMatchURL('javascript:bad'),
-        mailto: expect.toMatchURL('mailto:bad'),
-        wss: expect.toMatchURL('wss://bad/')
-      },
-      []
-    );
-  });
-
-  it('should parse absolute URLs, ignoring unparseable ones', () => {
-    expectSpecifierMap(
-      `{
-        "unparseable1": "https://ex ample.org/",
-        "unparseable2": "https://example.com:demo",
-        "unparseable3": "http://[www.example.com]/",
-        "invalidButParseable1": "https:example.org",
-        "invalidButParseable2": "https://///example.com///",
-        "prettyNormal": "https://example.net",
-        "percentDecoding": "https://ex%41mple.com/",
-        "noPercentDecoding": "https://example.com/%41"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        invalidButParseable1: expect.toMatchURL('https://example.org/'),
-        invalidButParseable2: expect.toMatchURL('https://example.com///'),
-        prettyNormal: expect.toMatchURL('https://example.net/'),
-        percentDecoding: expect.toMatchURL('https://example.com/'),
-        noPercentDecoding: expect.toMatchURL('https://example.com/%41')
-      },
-      [
-        `Invalid address "https://ex ample.org/" for the specifier key "unparseable1".`,
-        `Invalid address "https://example.com:demo" for the specifier key "unparseable2".`,
-        `Invalid address "http://[www.example.com]/" for the specifier key "unparseable3".`
-      ]
-    );
-  });
-});
-
-describe('Failing addresses: mismatched trailing slashes', () => {
-  it('should warn for the simple case', () => {
-    expectSpecifierMap(
-      `{
-        "trailer/": "/notrailer"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-      },
-      [`Invalid address "https://base.example/notrailer" for package specifier key "trailer/". Package addresses must end with "/".`]
-    );
-  });
-});
-
-describe('Other invalid addresses', () => {
-  it('should ignore unprefixed strings that are not absolute URLs', () => {
-    for (const bad of ['bar', '\\bar', '~bar', '#bar', '?bar']) {
-      expectSpecifierMap(
-        `{
-          "foo": ${JSON.stringify(bad)}
-        }`,
-        'https://base.example/path1/path2/path3',
-        {
-        },
-        [`Invalid address "${bad}" for the specifier key "foo".`]
-      );
-    }
-  });
-});
diff --git a/import-maps/imported/resources/parsing-schema.js b/import-maps/imported/resources/parsing-schema.js
deleted file mode 100644
index f60422ae62bce2..00000000000000
--- a/import-maps/imported/resources/parsing-schema.js
+++ /dev/null
@@ -1,99 +0,0 @@
-'use strict';
-const { parseFromString } = require('../lib/parser.js');
-const { expectBad, expectWarnings, expectSpecifierMap } = require('./helpers/parsing.js');
-
-const nonObjectStrings = ['null', 'true', '1', '"foo"', '[]'];
-
-test('Invalid JSON', () => {
-  expect(() => parseFromString('{ imports: {} }', 'https://base.example/')).toThrow(SyntaxError);
-});
-
-describe('Mismatching the top-level schema', () => {
-  it('should throw for top-level non-objects', () => {
-    for (const nonObject of nonObjectStrings) {
-      expectBad(nonObject, 'https://base.example/');
-    }
-  });
-
-  it('should throw if imports is a non-object', () => {
-    for (const nonObject of nonObjectStrings) {
-      expectBad(`{ "imports": ${nonObject} }`, 'https://base.example/');
-    }
-  });
-
-  it('should throw if scopes is a non-object', () => {
-    for (const nonObject of nonObjectStrings) {
-      expectBad(`{ "scopes": ${nonObject} }`, 'https://base.example/');
-    }
-  });
-
-  it('should ignore unspecified top-level entries', () => {
-    expectWarnings(
-      `{
-        "imports": {},
-        "new-feature": {},
-        "scops": {}
-      }`,
-      'https://base.example/',
-      { imports: {}, scopes: {} },
-      [
-        `Invalid top-level key "new-feature". Only "imports" and "scopes" can be present.`,
-        `Invalid top-level key "scops". Only "imports" and "scopes" can be present.`
-      ]
-    );
-  });
-});
-
-describe('Mismatching the specifier map schema', () => {
-  const invalidAddressStrings = ['null', 'true', '1', '{}', '[]', '["https://example.com/"]'];
-
-  it('should ignore entries where the address is not a string', () => {
-    for (const invalid of invalidAddressStrings) {
-      expectSpecifierMap(
-        `{
-          "foo": ${invalid},
-          "bar": "https://example.com/"
-        }`,
-        'https://base.example/',
-        {
-          bar: expect.toMatchURL('https://example.com/')
-        },
-        [`Invalid address ${invalid} for the specifier key "foo". Addresses must be strings.`]
-      );
-    }
-  });
-
-  it('should ignore entries where the specifier key is an empty string', () => {
-    expectSpecifierMap(
-      `{
-        "": "https://example.com/"
-      }`,
-      'https://base.example/',
-      {},
-      [`Invalid empty string specifier key.`]
-    );
-  });
-
-  it('should throw if a scope\'s value is not an object', () => {
-    for (const invalid of nonObjectStrings) {
-      expectBad(`{ "scopes": { "https://scope.example/": ${invalid} } }`, 'https://base.example/');
-    }
-  });
-});
-
-describe('Normalization', () => {
-  it('should normalize empty import maps to have imports and scopes keys', () => {
-    expect(parseFromString(`{}`, 'https://base.example/'))
-      .toEqual({ imports: {}, scopes: {} });
-  });
-
-  it('should normalize an import map without imports to have imports', () => {
-    expect(parseFromString(`{ "scopes": {} }`, 'https://base.example/'))
-      .toEqual({ imports: {}, scopes: {} });
-  });
-
-  it('should normalize an import map without scopes to have scopes', () => {
-    expect(parseFromString(`{ "imports": {} }`, 'https://base.example/'))
-      .toEqual({ imports: {}, scopes: {} });
-  });
-});
diff --git a/import-maps/imported/resources/parsing-scope-keys.js b/import-maps/imported/resources/parsing-scope-keys.js
deleted file mode 100644
index 4993f3a9a8bac4..00000000000000
--- a/import-maps/imported/resources/parsing-scope-keys.js
+++ /dev/null
@@ -1,144 +0,0 @@
-'use strict';
-const { expectScopes } = require('./helpers/parsing.js');
-
-describe('Relative URL scope keys', () => {
-  it('should work with no prefix', () => {
-    expectScopes(
-      ['foo'],
-      'https://base.example/path1/path2/path3',
-      ['https://base.example/path1/path2/foo']
-    );
-  });
-
-  it('should work with ./, ../, and / prefixes', () => {
-    expectScopes(
-      ['./foo', '../foo', '/foo'],
-      'https://base.example/path1/path2/path3',
-      [
-        'https://base.example/path1/path2/foo',
-        'https://base.example/path1/foo',
-        'https://base.example/foo'
-      ]
-    );
-  });
-
-  it('should work with /s, ?s, and #s', () => {
-    expectScopes(
-      ['foo/bar?baz#qux'],
-      'https://base.example/path1/path2/path3',
-      ['https://base.example/path1/path2/foo/bar?baz#qux']
-    );
-  });
-
-  it('should work with an empty string scope key', () => {
-    expectScopes(
-      [''],
-      'https://base.example/path1/path2/path3',
-      ['https://base.example/path1/path2/path3']
-    );
-  });
-
-  it('should work with / suffixes', () => {
-    expectScopes(
-      ['foo/', './foo/', '../foo/', '/foo/', '/foo//'],
-      'https://base.example/path1/path2/path3',
-      [
-        'https://base.example/path1/path2/foo/',
-        'https://base.example/path1/path2/foo/',
-        'https://base.example/path1/foo/',
-        'https://base.example/foo/',
-        'https://base.example/foo//'
-      ]
-    );
-  });
-
-  it('should deduplicate based on URL parsing rules', () => {
-    expectScopes(
-      ['foo/\\', 'foo//', 'foo\\\\'],
-      'https://base.example/path1/path2/path3',
-      ['https://base.example/path1/path2/foo//']
-    );
-  });
-});
-
-describe('Absolute URL scope keys', () => {
-  it('should accept all absolute URL scope keys, with or without fetch schemes', () => {
-    expectScopes(
-      [
-        'about:good',
-        'blob:good',
-        'data:good',
-        'file:///good',
-        'filesystem:http://example.com/good/',
-        'http://good/',
-        'https://good/',
-        'ftp://good/',
-        'import:bad',
-        'mailto:bad',
-        'javascript:bad',
-        'wss:ba'
-      ],
-      'https://base.example/path1/path2/path3',
-      [
-        'about:good',
-        'blob:good',
-        'data:good',
-        'file:///good',
-        'filesystem:http://example.com/good/',
-        'http://good/',
-        'https://good/',
-        'ftp://good/',
-        'import:bad',
-        'mailto:bad',
-        'javascript:bad',
-        'wss://ba/'
-      ],
-      []
-    );
-  });
-
-  it('should parse absolute URL scope keys, ignoring unparseable ones', () => {
-    expectScopes(
-      [
-        'https://ex ample.org/',
-        'https://example.com:demo',
-        'http://[www.example.com]/',
-        'https:example.org',
-        'https://///example.com///',
-        'https://example.net',
-        'https://ex%41mple.com/foo/',
-        'https://example.com/%41'
-      ],
-      'https://base.example/path1/path2/path3',
-      [
-        'https://base.example/path1/path2/example.org', // tricky case! remember we have a base URL
-        'https://example.com///',
-        'https://example.net/',
-        'https://example.com/foo/',
-        'https://example.com/%41'
-      ],
-      [
-        'Invalid scope "https://ex ample.org/" (parsed against base URL "https://base.example/path1/path2/path3").',
-        'Invalid scope "https://example.com:demo" (parsed against base URL "https://base.example/path1/path2/path3").',
-        'Invalid scope "http://[www.example.com]/" (parsed against base URL "https://base.example/path1/path2/path3").'
-      ]
-    );
-  });
-
-  it('should ignore relative URL scope keys when the base URL is a data: URL', () => {
-    expectScopes(
-      [
-        './foo',
-        '../foo',
-        '/foo'
-      ],
-      'data:text/html,test',
-      [],
-      [
-        'Invalid scope "./foo" (parsed against base URL "data:text/html,test").',
-        'Invalid scope "../foo" (parsed against base URL "data:text/html,test").',
-        'Invalid scope "/foo" (parsed against base URL "data:text/html,test").'
-      ]
-    );
-  });
-});
diff --git a/import-maps/imported/resources/parsing-specifier-keys.js b/import-maps/imported/resources/parsing-specifier-keys.js
deleted file mode 100644
index 7ac24bf867b06a..00000000000000
--- a/import-maps/imported/resources/parsing-specifier-keys.js
+++ /dev/null
@@ -1,164 +0,0 @@
-'use strict';
-const { expectSpecifierMap } = require('./helpers/parsing.js');
-
-describe('Relative URL-like specifier keys', () => {
-  it('should absolutize strings prefixed with ./, ../, or / into the corresponding URLs', () => {
-    expectSpecifierMap(
-      `{
-        "./foo": "/dotslash",
-        "../foo": "/dotdotslash",
-        "/foo": "/slash"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        'https://base.example/path1/path2/foo': expect.toMatchURL('https://base.example/dotslash'),
-        'https://base.example/path1/foo': expect.toMatchURL('https://base.example/dotdotslash'),
-        'https://base.example/foo': expect.toMatchURL('https://base.example/slash')
-      }
-    );
-  });
-
-  it('should not absolutize strings prefixed with ./, ../, or / with a data: URL base', () => {
-    expectSpecifierMap(
-      `{
-        "./foo": "https://example.com/dotslash",
-        "../foo": "https://example.com/dotdotslash",
-        "/foo": "https://example.com/slash"
-      }`,
-      'data:text/html,test',
-      {
-        './foo': expect.toMatchURL('https://example.com/dotslash'),
-        '../foo': expect.toMatchURL('https://example.com/dotdotslash'),
-        '/foo': expect.toMatchURL('https://example.com/slash')
-      }
-    );
-  });
-
-  it('should absolutize the literal strings ./, ../, or / with no suffix', () => {
-    expectSpecifierMap(
-      `{
-        "./": "/dotslash/",
-        "../": "/dotdotslash/",
-        "/": "/slash/"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        'https://base.example/path1/path2/': expect.toMatchURL('https://base.example/dotslash/'),
-        'https://base.example/path1/': expect.toMatchURL('https://base.example/dotdotslash/'),
-        'https://base.example/': expect.toMatchURL('https://base.example/slash/')
-      }
-    );
-  });
-
-  it('should treat percent-encoded variants of ./, ../, or / as bare specifiers', () => {
-    expectSpecifierMap(
-      `{
-        "%2E/": "/dotSlash1/",
-        "%2E%2E/": "/dotDotSlash1/",
-        ".%2F": "/dotSlash2",
-        "..%2F": "/dotDotSlash2",
-        "%2F": "/slash2",
-        "%2E%2F": "/dotSlash3",
-        "%2E%2E%2F": "/dotDotSlash3"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        '%2E/': expect.toMatchURL('https://base.example/dotSlash1/'),
-        '%2E%2E/': expect.toMatchURL('https://base.example/dotDotSlash1/'),
-        '.%2F': expect.toMatchURL('https://base.example/dotSlash2'),
-        '..%2F': expect.toMatchURL('https://base.example/dotDotSlash2'),
-        '%2F': expect.toMatchURL('https://base.example/slash2'),
-        '%2E%2F': expect.toMatchURL('https://base.example/dotSlash3'),
-        '%2E%2E%2F': expect.toMatchURL('https://base.example/dotDotSlash3')
-      }
-    );
-  });
-});
-
-describe('Absolute URL specifier keys', () => {
-  it('Accept all absolute URL specifier keys even with fetch schemes as URLs', () => {
-    expectSpecifierMap(
-      `{
-        "about:good": "/about",
-        "blob:good": "/blob",
-        "data:good": "/data",
-        "file:///good": "/file",
-        "filesystem:http://example.com/good/": "/filesystem/",
-        "http://good/": "/http/",
-        "https://good/": "/https/",
-        "ftp://good/": "/ftp/",
-        "import:bad": "/import",
-        "mailto:bad": "/mailto",
-        "javascript:bad": "/javascript",
-        "wss:bad": "/wss"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        'about:good': expect.toMatchURL('https://base.example/about'),
-        'blob:good': expect.toMatchURL('https://base.example/blob'),
-        'data:good': expect.toMatchURL('https://base.example/data'),
-        'file:///good': expect.toMatchURL('https://base.example/file'),
-        'filesystem:http://example.com/good/': expect.toMatchURL('https://base.example/filesystem/'),
-        'http://good/': expect.toMatchURL('https://base.example/http/'),
-        'https://good/': expect.toMatchURL('https://base.example/https/'),
-        'ftp://good/': expect.toMatchURL('https://base.example/ftp/'),
-        'import:bad': expect.toMatchURL('https://base.example/import'),
-        'mailto:bad': expect.toMatchURL('https://base.example/mailto'),
-        'javascript:bad': expect.toMatchURL('https://base.example/javascript'),
-        'wss://bad/': expect.toMatchURL('https://base.example/wss')
-      }
-    );
-  });
-
-  it('should parse absolute URLs, treating unparseable ones as bare specifiers', () => {
-    expectSpecifierMap(
-      `{
-        "https://ex ample.org/": "/unparseable1/",
-        "https://example.com:demo": "/unparseable2",
-        "http://[www.example.com]/": "/unparseable3/",
-        "https:example.org": "/invalidButParseable1/",
-        "https://///example.com///": "/invalidButParseable2/",
-        "https://example.net": "/prettyNormal/",
-        "https://ex%41mple.com/": "/percentDecoding/",
-        "https://example.com/%41": "/noPercentDecoding"
-      }`,
-      'https://base.example/path1/path2/path3',
-      {
-        'https://ex ample.org/': expect.toMatchURL('https://base.example/unparseable1/'),
-        'https://example.com:demo': expect.toMatchURL('https://base.example/unparseable2'),
-        'http://[www.example.com]/': expect.toMatchURL('https://base.example/unparseable3/'),
-        'https://example.org/': expect.toMatchURL('https://base.example/invalidButParseable1/'),
-        'https://example.com///': expect.toMatchURL('https://base.example/invalidButParseable2/'),
-        'https://example.net/': expect.toMatchURL('https://base.example/prettyNormal/'),
-        'https://example.com/': expect.toMatchURL('https://base.example/percentDecoding/'),
-        'https://example.com/%41': expect.toMatchURL('https://base.example/noPercentDecoding')
-      }
-    );
-  });
-
-  it('should sort correctly (issue #181)', () => {
-    expectSpecifierMap(
-      `{
-        "https://example.com/aaa": "https://example.com/aaa",
-        "https://example.com/a": "https://example.com/a"
-      }`,
-      'https://base.example/',
-      {
-        'https://example.com/aaa': expect.toMatchURL('https://example.com/aaa'),
-        'https://example.com/a': expect.toMatchURL('https://example.com/a')
-      }
-    );
-
-    expectSpecifierMap(
-      `{
-        "https://example.com/a": "https://example.com/a",
-        "https://example.com/aaa": "https://example.com/aaa"
-      }`,
-      'https://base.example/',
-      {
-        'https://example.com/aaa': expect.toMatchURL('https://example.com/aaa'),
-        'https://example.com/a': expect.toMatchURL('https://example.com/a')
-      }
-    );
-  });
-});