Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1766 insertions, 0 deletions

diff --git a/testing/mochitest/browser-test.js b/testing/mochitest/browser-test.js
new file mode 100644
index 0000000000..7bc7085043
--- /dev/null
+++ b/testing/mochitest/browser-test.js
@@ -0,0 +1,1766 @@
+/* -*- js-indent-level: 2; tab-width: 2; indent-tabs-mode: nil -*- */
+
+/* eslint-env mozilla/browser-window */
+/* import-globals-from chrome-harness.js */
+/* import-globals-from mochitest-e10s-utils.js */
+
+// Test timeout (seconds)
+var gTimeoutSeconds = 45;
+var gConfig;
+
+var { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "AddonManager",
+  "resource://gre/modules/AddonManager.jsm"
+);
+
+const SIMPLETEST_OVERRIDES = [
+  "ok",
+  "record",
+  "is",
+  "isnot",
+  "todo",
+  "todo_is",
+  "todo_isnot",
+  "info",
+  "expectAssertions",
+  "requestCompleteLog",
+];
+
+setTimeout(testInit, 0);
+
+var TabDestroyObserver = {
+  outstanding: new Set(),
+  promiseResolver: null,
+
+  init() {
+    Services.obs.addObserver(this, "message-manager-close");
+    Services.obs.addObserver(this, "message-manager-disconnect");
+  },
+
+  destroy() {
+    Services.obs.removeObserver(this, "message-manager-close");
+    Services.obs.removeObserver(this, "message-manager-disconnect");
+  },
+
+  observe(subject, topic, data) {
+    if (topic == "message-manager-close") {
+      this.outstanding.add(subject);
+    } else if (topic == "message-manager-disconnect") {
+      this.outstanding.delete(subject);
+      if (!this.outstanding.size && this.promiseResolver) {
+        this.promiseResolver();
+      }
+    }
+  },
+
+  wait() {
+    if (!this.outstanding.size) {
+      return Promise.resolve();
+    }
+
+    return new Promise(resolve => {
+      this.promiseResolver = resolve;
+    });
+  },
+};
+
+function testInit() {
+  gConfig = readConfig();
+  if (gConfig.testRoot == "browser") {
+    // Make sure to launch the test harness for the first opened window only
+    var prefs = Services.prefs;
+    if (prefs.prefHasUserValue("testing.browserTestHarness.running")) {
+      return;
+    }
+
+    prefs.setBoolPref("testing.browserTestHarness.running", true);
+
+    if (prefs.prefHasUserValue("testing.browserTestHarness.timeout")) {
+      gTimeoutSeconds = prefs.getIntPref("testing.browserTestHarness.timeout");
+    }
+
+    var sstring = Cc["@mozilla.org/supports-string;1"].createInstance(
+      Ci.nsISupportsString
+    );
+    sstring.data = location.search;
+
+    Services.ww.openWindow(
+      window,
+      "chrome://mochikit/content/browser-harness.xhtml",
+      "browserTest",
+      "chrome,centerscreen,dialog=no,resizable,titlebar,toolbar=no,width=800,height=600",
+      sstring
+    );
+  } else {
+    // This code allows us to redirect without requiring specialpowers for chrome and a11y tests.
+    let messageHandler = function(m) {
+      // eslint-disable-next-line no-undef
+      messageManager.removeMessageListener("chromeEvent", messageHandler);
+      var url = m.json.data;
+
+      // Window is the [ChromeWindow] for messageManager, so we need content.window
+      // Currently chrome tests are run in a content window instead of a ChromeWindow
+      // eslint-disable-next-line no-undef
+      var webNav = content.window.docShell.QueryInterface(Ci.nsIWebNavigation);
+      let loadURIOptions = {
+        triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+      };
+      webNav.loadURI(url, loadURIOptions);
+    };
+
+    var listener =
+      'data:,function doLoad(e) { var data=e.detail&&e.detail.data;removeEventListener("contentEvent", function (e) { doLoad(e); }, false, true);sendAsyncMessage("chromeEvent", {"data":data}); };addEventListener("contentEvent", function (e) { doLoad(e); }, false, true);';
+    // eslint-disable-next-line no-undef
+    messageManager.addMessageListener("chromeEvent", messageHandler);
+    // eslint-disable-next-line no-undef
+    messageManager.loadFrameScript(listener, true);
+  }
+  if (gConfig.e10s) {
+    e10s_init();
+
+    let processCount = prefs.getIntPref("dom.ipc.processCount", 1);
+    if (processCount > 1) {
+      // Currently starting a content process is slow, to aviod timeouts, let's
+      // keep alive content processes.
+      prefs.setIntPref("dom.ipc.keepProcessesAlive.web", processCount);
+    }
+
+    Services.mm.loadFrameScript(
+      "chrome://mochikit/content/shutdown-leaks-collector.js",
+      true
+    );
+  } else {
+    // In non-e10s, only run the ShutdownLeaksCollector in the parent process.
+    ChromeUtils.importESModule(
+      "chrome://mochikit/content/ShutdownLeaksCollector.sys.mjs"
+    );
+  }
+}
+
+function isGenerator(value) {
+  return value && typeof value === "object" && typeof value.next === "function";
+}
+
+function Tester(aTests, structuredLogger, aCallback) {
+  this.structuredLogger = structuredLogger;
+  this.tests = aTests;
+  this.callback = aCallback;
+
+  this._scriptLoader = Services.scriptloader;
+  this.EventUtils = {};
+  this._scriptLoader.loadSubScript(
+    "chrome://mochikit/content/tests/SimpleTest/EventUtils.js",
+    this.EventUtils
+  );
+
+  this._scriptLoader.loadSubScript(
+    "chrome://mochikit/content/tests/SimpleTest/AccessibilityUtils.js",
+    // AccessibilityUtils are integrated with EventUtils to perform additional
+    // accessibility checks for certain user interactions (clicks, etc). Load
+    // them into the EventUtils scope here.
+    this.EventUtils
+  );
+  this.AccessibilityUtils = this.EventUtils.AccessibilityUtils;
+
+  // Make sure our SpecialPowers actor is instantiated, in case it was
+  // registered after our DOMWindowCreated event was fired (which it
+  // most likely was).
+  void window.windowGlobalChild.getActor("SpecialPowers");
+
+  var simpleTestScope = {};
+  this._scriptLoader.loadSubScript(
+    "chrome://mochikit/content/tests/SimpleTest/SimpleTest.js",
+    simpleTestScope
+  );
+  this._scriptLoader.loadSubScript(
+    "chrome://mochikit/content/tests/SimpleTest/MemoryStats.js",
+    simpleTestScope
+  );
+  this._scriptLoader.loadSubScript(
+    "chrome://mochikit/content/chrome-harness.js",
+    simpleTestScope
+  );
+  this.SimpleTest = simpleTestScope.SimpleTest;
+
+  window.SpecialPowers.SimpleTest = this.SimpleTest;
+  window.SpecialPowers.setAsDefaultAssertHandler();
+
+  var extensionUtilsScope = {
+    registerCleanupFunction: fn => {
+      this.currentTest.scope.registerCleanupFunction(fn);
+    },
+  };
+  extensionUtilsScope.SimpleTest = this.SimpleTest;
+  this._scriptLoader.loadSubScript(
+    "chrome://mochikit/content/tests/SimpleTest/ExtensionTestUtils.js",
+    extensionUtilsScope
+  );
+  this.ExtensionTestUtils = extensionUtilsScope.ExtensionTestUtils;
+
+  this.SimpleTest.harnessParameters = gConfig;
+
+  this.MemoryStats = simpleTestScope.MemoryStats;
+  this.ContentTask = ChromeUtils.importESModule(
+    "resource://testing-common/ContentTask.sys.mjs"
+  ).ContentTask;
+  this.BrowserTestUtils = ChromeUtils.importESModule(
+    "resource://testing-common/BrowserTestUtils.sys.mjs"
+  ).BrowserTestUtils;
+  this.TestUtils = ChromeUtils.importESModule(
+    "resource://testing-common/TestUtils.sys.mjs"
+  ).TestUtils;
+  this.PromiseTestUtils = ChromeUtils.importESModule(
+    "resource://testing-common/PromiseTestUtils.sys.mjs"
+  ).PromiseTestUtils;
+  this.Assert = ChromeUtils.importESModule(
+    "resource://testing-common/Assert.sys.mjs"
+  ).Assert;
+  this.PerTestCoverageUtils = ChromeUtils.import(
+    "resource://testing-common/PerTestCoverageUtils.jsm"
+  ).PerTestCoverageUtils;
+
+  this.PromiseTestUtils.init();
+
+  this.SimpleTestOriginal = {};
+  SIMPLETEST_OVERRIDES.forEach(m => {
+    this.SimpleTestOriginal[m] = this.SimpleTest[m];
+  });
+
+  this._coverageCollector = null;
+
+  const { XPCOMUtils } = ChromeUtils.importESModule(
+    "resource://gre/modules/XPCOMUtils.sys.mjs"
+  );
+
+  // Avoid failing tests when XPCOMUtils.defineLazyScriptGetter is used.
+  XPCOMUtils.overrideScriptLoaderForTests({
+    loadSubScript: (url, obj) => {
+      let before = Object.keys(window);
+      try {
+        return this._scriptLoader.loadSubScript(url, obj);
+      } finally {
+        for (let property of Object.keys(window)) {
+          if (
+            !before.includes(property) &&
+            !this._globalProperties.includes(property)
+          ) {
+            this._globalProperties.push(property);
+            this.SimpleTest.info(
+              `Global property added while loading ${url}: ${property}`
+            );
+          }
+        }
+      }
+    },
+    loadSubScriptWithOptions: this._scriptLoader.loadSubScriptWithOptions.bind(
+      this._scriptLoader
+    ),
+  });
+
+  // ensure the mouse is reset before each test run
+  if (Services.env.exists("MOZ_AUTOMATION")) {
+    this.EventUtils.synthesizeNativeMouseEvent({
+      type: "mousemove",
+      screenX: 1000,
+      screenY: 10,
+    });
+  }
+}
+Tester.prototype = {
+  EventUtils: {},
+  AccessibilityUtils: {},
+  SimpleTest: {},
+  ContentTask: null,
+  ExtensionTestUtils: null,
+  Assert: null,
+
+  repeat: 0,
+  a11y_checks: false,
+  runUntilFailure: false,
+  checker: null,
+  currentTestIndex: -1,
+  lastStartTime: null,
+  lastStartTimestamp: null,
+  lastAssertionCount: 0,
+  failuresFromInitialWindowState: 0,
+
+  get currentTest() {
+    return this.tests[this.currentTestIndex];
+  },
+  get done() {
+    return this.currentTestIndex == this.tests.length - 1 && this.repeat <= 0;
+  },
+
+  start: function Tester_start() {
+    TabDestroyObserver.init();
+
+    // if testOnLoad was not called, then gConfig is not defined
+    if (!gConfig) {
+      gConfig = readConfig();
+    }
+
+    if (gConfig.runUntilFailure) {
+      this.runUntilFailure = true;
+    }
+
+    if (gConfig.a11y_checks != undefined) {
+      this.a11y_checks = gConfig.a11y_checks;
+    }
+
+    if (gConfig.repeat) {
+      this.repeat = gConfig.repeat;
+    }
+
+    if (gConfig.jscovDirPrefix) {
+      let coveragePath = gConfig.jscovDirPrefix;
+      let { CoverageCollector } = ChromeUtils.importESModule(
+        "resource://testing-common/CoverageUtils.sys.mjs"
+      );
+      this._coverageCollector = new CoverageCollector(coveragePath);
+    }
+
+    this.structuredLogger.info("*** Start BrowserChrome Test Results ***");
+    Services.console.registerListener(this);
+    this._globalProperties = Object.keys(window);
+    this._globalPropertyWhitelist = [
+      "navigator",
+      "constructor",
+      "top",
+      "Application",
+      "__SS_tabsToRestore",
+      "__SSi",
+      "webConsoleCommandController",
+      // Thunderbird
+      "MailMigrator",
+      "SearchIntegration",
+    ];
+
+    this.PerTestCoverageUtils.beforeTestSync();
+
+    if (this.tests.length) {
+      this.waitForWindowsReady().then(() => {
+        this.nextTest();
+      });
+    } else {
+      this.finish();
+    }
+  },
+
+  async waitForWindowsReady() {
+    await this.setupDefaultTheme();
+    await new Promise(resolve =>
+      this.waitForGraphicsTestWindowToBeGone(resolve)
+    );
+    await this.promiseMainWindowReady();
+  },
+
+  async promiseMainWindowReady() {
+    if (window.gBrowserInit) {
+      await window.gBrowserInit.idleTasksFinishedPromise;
+    }
+  },
+
+  async setupDefaultTheme() {
+    // Developer Edition enables the wrong theme by default. Make sure
+    // the ordinary default theme is enabled.
+    let theme = await AddonManager.getAddonByID("default-theme@mozilla.org");
+    await theme.enable();
+  },
+
+  waitForGraphicsTestWindowToBeGone(aCallback) {
+    for (let win of Services.wm.getEnumerator(null)) {
+      if (
+        win != window &&
+        !win.closed &&
+        win.document.documentURI ==
+          "chrome://gfxsanity/content/sanityparent.html"
+      ) {
+        this.BrowserTestUtils.domWindowClosed(win).then(aCallback);
+        return;
+      }
+    }
+    // graphics test window is already gone, just call callback immediately
+    aCallback();
+  },
+
+  waitForWindowsState: function Tester_waitForWindowsState(aCallback) {
+    let timedOut = this.currentTest && this.currentTest.timedOut;
+    // eslint-disable-next-line no-nested-ternary
+    let baseMsg = timedOut
+      ? "Found a {elt} after previous test timed out"
+      : this.currentTest
+      ? "Found an unexpected {elt} at the end of test run"
+      : "Found an unexpected {elt}";
+
+    // Remove stale tabs
+    if (
+      this.currentTest &&
+      window.gBrowser &&
+      AppConstants.MOZ_APP_NAME != "thunderbird" &&
+      gBrowser.tabs.length > 1
+    ) {
+      let lastURI = "";
+      let lastURIcount = 0;
+      while (gBrowser.tabs.length > 1) {
+        let lastTab = gBrowser.tabs[gBrowser.tabs.length - 1];
+        if (!lastTab.closing) {
+          // Report the stale tab as an error only when they're not closing.
+          // Tests can finish without waiting for the closing tabs.
+          if (lastURI != lastTab.linkedBrowser.currentURI.spec) {
+            lastURI = lastTab.linkedBrowser.currentURI.spec;
+          } else {
+            lastURIcount++;
+            if (lastURIcount >= 3) {
+              this.currentTest.addResult(
+                new testResult({
+                  name:
+                    "terminating browser early - unable to close tabs; skipping remaining tests in folder",
+                  allowFailure: this.currentTest.allowFailure,
+                })
+              );
+              this.finish();
+            }
+          }
+          this.currentTest.addResult(
+            new testResult({
+              name:
+                baseMsg.replace("{elt}", "tab") +
+                ": " +
+                lastTab.linkedBrowser.currentURI.spec,
+              allowFailure: this.currentTest.allowFailure,
+            })
+          );
+        }
+        gBrowser.removeTab(lastTab);
+      }
+    }
+
+    // Replace the last tab with a fresh one
+    if (window.gBrowser && AppConstants.MOZ_APP_NAME != "thunderbird") {
+      gBrowser.addTab("about:blank", {
+        skipAnimation: true,
+        triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+      });
+      gBrowser.removeTab(gBrowser.selectedTab, { skipPermitUnload: true });
+      gBrowser.stop();
+    }
+
+    // Remove stale windows
+    this.structuredLogger.info("checking window state");
+    for (let win of Services.wm.getEnumerator(null)) {
+      let type = win.document.documentElement.getAttribute("windowtype");
+      if (
+        win != window &&
+        !win.closed &&
+        win.document.documentElement.getAttribute("id") !=
+          "browserTestHarness" &&
+        type != "devtools:webconsole"
+      ) {
+        switch (type) {
+          case "navigator:browser":
+            type = "browser window";
+            break;
+          case "mail:3pane":
+            type = "mail window";
+            break;
+          case null:
+            type =
+              "unknown window with document URI: " +
+              win.document.documentURI +
+              " and title: " +
+              win.document.title;
+            break;
+        }
+        let msg = baseMsg.replace("{elt}", type);
+        if (this.currentTest) {
+          this.currentTest.addResult(
+            new testResult({
+              name: msg,
+              allowFailure: this.currentTest.allowFailure,
+            })
+          );
+        } else {
+          this.failuresFromInitialWindowState++;
+          this.structuredLogger.error("browser-test.js | " + msg);
+        }
+
+        win.close();
+      }
+    }
+
+    // Make sure the window is raised before each test.
+    this.SimpleTest.waitForFocus(aCallback);
+  },
+
+  finish: function Tester_finish(aSkipSummary) {
+    var passCount = this.tests.reduce((a, f) => a + f.passCount, 0);
+    var failCount = this.tests.reduce((a, f) => a + f.failCount, 0);
+    var todoCount = this.tests.reduce((a, f) => a + f.todoCount, 0);
+
+    // Include failures from window state checking prior to running the first test
+    failCount += this.failuresFromInitialWindowState;
+
+    TabDestroyObserver.destroy();
+    Services.console.unregisterListener(this);
+
+    // It's important to terminate the module to avoid crashes on shutdown.
+    this.PromiseTestUtils.uninit();
+
+    // In the main process, we print the ShutdownLeaksCollector message here.
+    let pid = Services.appinfo.processID;
+    dump("Completed ShutdownLeaks collections in process " + pid + "\n");
+
+    this.structuredLogger.info("TEST-START | Shutdown");
+
+    if (this.tests.length) {
+      let e10sMode = window.gMultiProcessBrowser ? "e10s" : "non-e10s";
+      this.structuredLogger.info("Browser Chrome Test Summary");
+      this.structuredLogger.info("Passed:  " + passCount);
+      this.structuredLogger.info("Failed:  " + failCount);
+      this.structuredLogger.info("Todo:    " + todoCount);
+      this.structuredLogger.info("Mode:    " + e10sMode);
+    } else {
+      this.structuredLogger.error(
+        "browser-test.js | No tests to run. Did you pass invalid test_paths?"
+      );
+    }
+    this.structuredLogger.info("*** End BrowserChrome Test Results ***");
+
+    // Tests complete, notify the callback and return
+    this.callback(this.tests);
+    this.accService = null;
+    this.callback = null;
+    this.tests = null;
+  },
+
+  haltTests: function Tester_haltTests() {
+    // Do not run any further tests
+    this.currentTestIndex = this.tests.length - 1;
+    this.repeat = 0;
+  },
+
+  observe: function Tester_observe(aSubject, aTopic, aData) {
+    if (!aTopic) {
+      this.onConsoleMessage(aSubject);
+    }
+  },
+
+  onConsoleMessage: function Tester_onConsoleMessage(aConsoleMessage) {
+    // Ignore empty messages.
+    if (!aConsoleMessage.message) {
+      return;
+    }
+
+    try {
+      var msg = "Console message: " + aConsoleMessage.message;
+      if (this.currentTest) {
+        this.currentTest.addResult(new testMessage(msg));
+      } else {
+        this.structuredLogger.info(
+          "TEST-INFO | (browser-test.js) | " + msg.replace(/\n$/, "") + "\n"
+        );
+      }
+    } catch (ex) {
+      // Swallow exception so we don't lead to another error being reported,
+      // throwing us into an infinite loop
+    }
+  },
+
+  async ensureVsyncDisabled() {
+    // The WebExtension process keeps vsync enabled forever in headless mode.
+    // See bug 1782541.
+    if (Services.env.get("MOZ_HEADLESS")) {
+      return;
+    }
+
+    try {
+      await this.TestUtils.waitForCondition(
+        () => !ChromeUtils.vsyncEnabled(),
+        "waiting for vsync to be disabled"
+      );
+    } catch (e) {
+      this.Assert.ok(false, e);
+      this.Assert.ok(
+        false,
+        "vsync remained enabled at the end of the test. " +
+          "Is there an animation still running? " +
+          "Consider talking to the performance team for tips to solve this."
+      );
+    }
+  },
+
+  async nextTest() {
+    if (this.currentTest) {
+      if (this._coverageCollector) {
+        this._coverageCollector.recordTestCoverage(this.currentTest.path);
+      }
+
+      this.PerTestCoverageUtils.afterTestSync();
+
+      // Run cleanup functions for the current test before moving on to the
+      // next one.
+      let testScope = this.currentTest.scope;
+      while (testScope.__cleanupFunctions.length) {
+        let func = testScope.__cleanupFunctions.shift();
+        try {
+          let result = await func.apply(testScope);
+          if (isGenerator(result)) {
+            this.SimpleTest.ok(false, "Cleanup function returned a generator");
+          }
+        } catch (ex) {
+          this.currentTest.addResult(
+            new testResult({
+              name: "Cleanup function threw an exception",
+              ex,
+              allowFailure: this.currentTest.allowFailure,
+            })
+          );
+        }
+      }
+
+      // Spare tests cleanup work.
+      // Reset gReduceMotionOverride in case the test set it.
+      if (typeof gReduceMotionOverride == "boolean") {
+        gReduceMotionOverride = null;
+      }
+
+      Services.obs.notifyObservers(null, "test-complete");
+
+      if (
+        this.currentTest.passCount === 0 &&
+        this.currentTest.failCount === 0 &&
+        this.currentTest.todoCount === 0
+      ) {
+        this.currentTest.addResult(
+          new testResult({
+            name:
+              "This test contains no passes, no fails and no todos. Maybe" +
+              " it threw a silent exception? Make sure you use" +
+              " waitForExplicitFinish() if you need it.",
+          })
+        );
+      }
+
+      let winUtils = window.windowUtils;
+      if (winUtils.isTestControllingRefreshes) {
+        this.currentTest.addResult(
+          new testResult({
+            name: "test left refresh driver under test control",
+          })
+        );
+        winUtils.restoreNormalRefresh();
+      }
+
+      if (this.SimpleTest.isExpectingUncaughtException()) {
+        this.currentTest.addResult(
+          new testResult({
+            name:
+              "expectUncaughtException was called but no uncaught" +
+              " exception was detected!",
+            allowFailure: this.currentTest.allowFailure,
+          })
+        );
+      }
+
+      this.resolveFinishTestPromise();
+      this.resolveFinishTestPromise = null;
+      this.TestUtils.promiseTestFinished = null;
+
+      this.PromiseTestUtils.ensureDOMPromiseRejectionsProcessed();
+      this.PromiseTestUtils.assertNoUncaughtRejections();
+      this.PromiseTestUtils.assertNoMoreExpectedRejections();
+      await this.ensureVsyncDisabled();
+
+      Object.keys(window).forEach(function(prop) {
+        if (parseInt(prop) == prop) {
+          // This is a string which when parsed as an integer and then
+          // stringified gives the original string.  As in, this is in fact a
+          // string representation of an integer, so an index into
+          // window.frames.  Skip those.
+          return;
+        }
+        if (!this._globalProperties.includes(prop)) {
+          this._globalProperties.push(prop);
+          if (!this._globalPropertyWhitelist.includes(prop)) {
+            this.currentTest.addResult(
+              new testResult({
+                name: "test left unexpected property on window: " + prop,
+                allowFailure: this.currentTest.allowFailure,
+              })
+            );
+          }
+        }
+      }, this);
+
+      // eslint-disable-next-line no-undef
+      await new Promise(resolve => SpecialPowers.flushPrefEnv(resolve));
+
+      if (gConfig.cleanupCrashes) {
+        let gdir = Services.dirsvc.get("UAppData", Ci.nsIFile);
+        gdir.append("Crash Reports");
+        gdir.append("pending");
+        if (gdir.exists()) {
+          let entries = gdir.directoryEntries;
+          while (entries.hasMoreElements()) {
+            let entry = entries.nextFile;
+            if (entry.isFile()) {
+              let msg = "this test left a pending crash report; ";
+              try {
+                entry.remove(false);
+                msg += "deleted " + entry.path;
+              } catch (e) {
+                msg += "could not delete " + entry.path;
+              }
+              this.structuredLogger.info(msg);
+            }
+          }
+        }
+      }
+
+      // Notify a long running test problem if it didn't end up in a timeout.
+      if (this.currentTest.unexpectedTimeouts && !this.currentTest.timedOut) {
+        this.currentTest.addResult(
+          new testResult({
+            name:
+              "This test exceeded the timeout threshold. It should be" +
+              " rewritten or split up. If that's not possible, use" +
+              " requestLongerTimeout(N), but only as a last resort.",
+          })
+        );
+      }
+
+      // If we're in a debug build, check assertion counts.  This code
+      // is similar to the code in TestRunner.testUnloaded in
+      // TestRunner.js used for all other types of mochitests.
+      let debugsvc = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2);
+      if (debugsvc.isDebugBuild) {
+        let newAssertionCount = debugsvc.assertionCount;
+        let numAsserts = newAssertionCount - this.lastAssertionCount;
+        this.lastAssertionCount = newAssertionCount;
+
+        let max = testScope.__expectedMaxAsserts;
+        let min = testScope.__expectedMinAsserts;
+        if (numAsserts > max) {
+          // TEST-UNEXPECTED-FAIL
+          this.currentTest.addResult(
+            new testResult({
+              name:
+                "Assertion count " +
+                numAsserts +
+                " is greater than expected range " +
+                min +
+                "-" +
+                max +
+                " assertions.",
+              pass: true, // TEMPORARILY TEST-KNOWN-FAIL
+              todo: true,
+              allowFailure: this.currentTest.allowFailure,
+            })
+          );
+        } else if (numAsserts < min) {
+          // TEST-UNEXPECTED-PASS
+          this.currentTest.addResult(
+            new testResult({
+              name:
+                "Assertion count " +
+                numAsserts +
+                " is less than expected range " +
+                min +
+                "-" +
+                max +
+                " assertions.",
+              todo: true,
+              allowFailure: this.currentTest.allowFailure,
+            })
+          );
+        } else if (numAsserts > 0) {
+          // TEST-KNOWN-FAIL
+          this.currentTest.addResult(
+            new testResult({
+              name:
+                "Assertion count " +
+                numAsserts +
+                " is within expected range " +
+                min +
+                "-" +
+                max +
+                " assertions.",
+              pass: true,
+              todo: true,
+              allowFailure: this.currentTest.allowFailure,
+            })
+          );
+        }
+      }
+
+      if (this.currentTest.allowFailure) {
+        if (this.currentTest.expectedAllowedFailureCount) {
+          this.currentTest.addResult(
+            new testResult({
+              name:
+                "Expected " +
+                this.currentTest.expectedAllowedFailureCount +
+                " failures in this file, got " +
+                this.currentTest.allowedFailureCount +
+                ".",
+              pass:
+                this.currentTest.expectedAllowedFailureCount ==
+                this.currentTest.allowedFailureCount,
+            })
+          );
+        } else if (this.currentTest.allowedFailureCount == 0) {
+          this.currentTest.addResult(
+            new testResult({
+              name:
+                "We expect at least one assertion to fail because this" +
+                " test file is marked as fail-if in the manifest.",
+              todo: true,
+              knownFailure: this.currentTest.allowFailure,
+            })
+          );
+        }
+      }
+
+      // Dump memory stats for main thread.
+      if (
+        Services.appinfo.processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT
+      ) {
+        this.MemoryStats.dump(
+          this.currentTestIndex,
+          this.currentTest.path,
+          gConfig.dumpOutputDirectory,
+          gConfig.dumpAboutMemoryAfterTest,
+          gConfig.dumpDMDAfterTest
+        );
+      }
+
+      // Note the test run time
+      let name = this.currentTest.path;
+      name = name.slice(name.lastIndexOf("/") + 1);
+      ChromeUtils.addProfilerMarker(
+        "browser-test",
+        { category: "Test", startTime: this.lastStartTimestamp },
+        name
+      );
+
+      // See if we should upload a profile of a failing test.
+      if (this.currentTest.failCount) {
+        // If MOZ_PROFILER_SHUTDOWN is set, the profiler got started from --profiler
+        // and a profile will be shown even if there's no test failure.
+        if (
+          Services.env.exists("MOZ_UPLOAD_DIR") &&
+          !Services.env.exists("MOZ_PROFILER_SHUTDOWN") &&
+          Services.profiler.IsActive()
+        ) {
+          let filename = `profile_${name}.json`;
+          let path = Services.env.get("MOZ_UPLOAD_DIR");
+          let profilePath = PathUtils.join(path, filename);
+          try {
+            let profileData = await Services.profiler.getProfileDataAsGzippedArrayBuffer();
+            await IOUtils.write(profilePath, new Uint8Array(profileData));
+            this.currentTest.addResult(
+              new testResult({
+                name:
+                  "Found unexpected failures during the test; profile uploaded in " +
+                  filename,
+              })
+            );
+          } catch (e) {
+            // If the profile is large, we may encounter out of memory errors.
+            this.currentTest.addResult(
+              new testResult({
+                name:
+                  "Found unexpected failures during the test; failed to upload profile: " +
+                  e,
+              })
+            );
+          }
+        }
+      }
+
+      let time = Date.now() - this.lastStartTime;
+
+      this.structuredLogger.testEnd(
+        this.currentTest.path,
+        "OK",
+        undefined,
+        "finished in " + time + "ms"
+      );
+      this.currentTest.setDuration(time);
+
+      if (this.runUntilFailure && this.currentTest.failCount > 0) {
+        this.haltTests();
+      }
+
+      // Restore original SimpleTest methods to avoid leaks.
+      SIMPLETEST_OVERRIDES.forEach(m => {
+        this.SimpleTest[m] = this.SimpleTestOriginal[m];
+      });
+
+      this.ContentTask.setTestScope(null);
+      testScope.destroy();
+      this.currentTest.scope = null;
+    }
+
+    // Check the window state for the current test before moving to the next one.
+    // This also causes us to check before starting any tests, since nextTest()
+    // is invoked to start the tests.
+    this.waitForWindowsState(() => {
+      if (this.done) {
+        if (this._coverageCollector) {
+          this._coverageCollector.finalize();
+        } else if (
+          !AppConstants.RELEASE_OR_BETA &&
+          !AppConstants.DEBUG &&
+          !AppConstants.MOZ_CODE_COVERAGE &&
+          !AppConstants.ASAN &&
+          !AppConstants.TSAN
+        ) {
+          this.finish();
+          return;
+        }
+
+        // Uninitialize a few things explicitly so that they can clean up
+        // frames and browser intentionally kept alive until shutdown to
+        // eliminate false positives.
+        if (gConfig.testRoot == "browser") {
+          // Skip if SeaMonkey
+          if (AppConstants.MOZ_APP_NAME != "seamonkey") {
+            // Replace the document currently loaded in the browser's sidebar.
+            // This will prevent false positives for tests that were the last
+            // to touch the sidebar. They will thus not be blamed for leaking
+            // a document.
+            let sidebar = document.getElementById("sidebar");
+            if (sidebar) {
+              sidebar.setAttribute("src", "data:text/html;charset=utf-8,");
+              sidebar.docShell.createAboutBlankContentViewer(null, null);
+              sidebar.setAttribute("src", "about:blank");
+            }
+          }
+
+          // Destroy BackgroundPageThumbs resources.
+          let { BackgroundPageThumbs } = ChromeUtils.import(
+            "resource://gre/modules/BackgroundPageThumbs.jsm"
+          );
+          BackgroundPageThumbs._destroy();
+
+          if (window.gBrowser) {
+            NewTabPagePreloading.removePreloadedBrowser(window);
+          }
+        }
+
+        // Schedule GC and CC runs before finishing in order to detect
+        // DOM windows leaked by our tests or the tested code. Note that we
+        // use a shrinking GC so that the JS engine will discard JIT code and
+        // JIT caches more aggressively.
+
+        let shutdownCleanup = aCallback => {
+          Cu.schedulePreciseShrinkingGC(() => {
+            // Run the GC and CC a few times to make sure that as much
+            // as possible is freed.
+            let numCycles = 3;
+            for (let i = 0; i < numCycles; i++) {
+              Cu.forceGC();
+              Cu.forceCC();
+            }
+            aCallback();
+          });
+        };
+
+        let { AsyncShutdown } = ChromeUtils.importESModule(
+          "resource://gre/modules/AsyncShutdown.sys.mjs"
+        );
+
+        let barrier = new AsyncShutdown.Barrier(
+          "ShutdownLeaks: Wait for cleanup to be finished before checking for leaks"
+        );
+        Services.obs.notifyObservers(
+          { wrappedJSObject: barrier },
+          "shutdown-leaks-before-check"
+        );
+
+        barrier.client.addBlocker(
+          "ShutdownLeaks: Wait for tabs to finish closing",
+          TabDestroyObserver.wait()
+        );
+
+        barrier.wait().then(() => {
+          // Simulate memory pressure so that we're forced to free more resources
+          // and thus get rid of more false leaks like already terminated workers.
+          Services.obs.notifyObservers(
+            null,
+            "memory-pressure",
+            "heap-minimize"
+          );
+
+          Services.ppmm.broadcastAsyncMessage("browser-test:collect-request");
+
+          shutdownCleanup(() => {
+            setTimeout(() => {
+              shutdownCleanup(() => {
+                this.finish();
+              });
+            }, 1000);
+          });
+        });
+
+        return;
+      }
+
+      if (this.repeat > 0) {
+        --this.repeat;
+        if (this.currentTestIndex < 0) {
+          this.currentTestIndex = 0;
+        }
+        this.execTest();
+      } else {
+        this.currentTestIndex++;
+        if (gConfig.repeat) {
+          this.repeat = gConfig.repeat;
+        }
+        this.execTest();
+      }
+    });
+  },
+
+  async handleTask(task, currentTest, PromiseTestUtils, isSetup = false) {
+    let currentScope = currentTest.scope;
+    let desc = isSetup ? "setup" : "test";
+    currentScope.SimpleTest.info(`Entering ${desc} ${task.name}`);
+    let startTimestamp = performance.now();
+    try {
+      let result = await task();
+      if (isGenerator(result)) {
+        currentScope.SimpleTest.ok(false, "Task returned a generator");
+      }
+    } catch (ex) {
+      if (currentTest.timedOut) {
+        currentTest.addResult(
+          new testResult({
+            name: `Uncaught exception received from previously timed out ${desc}`,
+            pass: false,
+            ex,
+            stack: typeof ex == "object" && "stack" in ex ? ex.stack : null,
+            allowFailure: currentTest.allowFailure,
+          })
+        );
+        // We timed out, so we've already cleaned up for this test, just get outta here.
+        return;
+      }
+      currentTest.addResult(
+        new testResult({
+          name: `Uncaught exception in ${desc}`,
+          pass: currentScope.SimpleTest.isExpectingUncaughtException(),
+          ex,
+          stack: typeof ex == "object" && "stack" in ex ? ex.stack : null,
+          allowFailure: currentTest.allowFailure,
+        })
+      );
+    }
+    PromiseTestUtils.assertNoUncaughtRejections();
+    ChromeUtils.addProfilerMarker(
+      isSetup ? "setup-task" : "task",
+      { category: "Test", startTime: startTimestamp },
+      task.name.replace(/^bound /, "") || undefined
+    );
+    currentScope.SimpleTest.info(`Leaving ${desc} ${task.name}`);
+  },
+
+  async _runTaskBasedTest(currentTest) {
+    let currentScope = currentTest.scope;
+
+    // First run all the setups:
+    let setupFn;
+    while ((setupFn = currentScope.__setups.shift())) {
+      await this.handleTask(
+        setupFn,
+        currentTest,
+        this.PromiseTestUtils,
+        true /* is setup task */
+      );
+    }
+
+    // Allow for a task to be skipped; we need only use the structured logger
+    // for this, whilst deactivating log buffering to ensure that messages
+    // are always printed to stdout.
+    let skipTask = task => {
+      let logger = this.structuredLogger;
+      logger.deactivateBuffering();
+      logger.testStatus(this.currentTest.path, task.name, "SKIP");
+      logger.warning("Skipping test " + task.name);
+      logger.activateBuffering();
+    };
+
+    let task;
+    while ((task = currentScope.__tasks.shift())) {
+      if (
+        task.__skipMe ||
+        (currentScope.__runOnlyThisTask &&
+          task != currentScope.__runOnlyThisTask)
+      ) {
+        skipTask(task);
+        continue;
+      }
+      await this.handleTask(task, currentTest, this.PromiseTestUtils);
+    }
+    currentScope.finish();
+  },
+
+  execTest: function Tester_execTest() {
+    this.structuredLogger.testStart(this.currentTest.path);
+
+    this.SimpleTest.reset();
+    // Reset accessibility environment.
+    this.AccessibilityUtils.reset(this.a11y_checks);
+
+    // Load the tests into a testscope
+    let currentScope = (this.currentTest.scope = new testScope(
+      this,
+      this.currentTest,
+      this.currentTest.expected
+    ));
+    let currentTest = this.currentTest;
+
+    // HTTPS-First (Bug 1704453) TODO: in case a test is annoated
+    // with https_first_disabled then we explicitly flip the pref
+    // dom.security.https_first to false for the duration of the test.
+    if (currentTest.https_first_disabled) {
+      window.SpecialPowers.pushPrefEnv({
+        set: [["dom.security.https_first", false]],
+      });
+    }
+
+    if (currentTest.allow_xul_xbl) {
+      window.SpecialPowers.pushPermissions([
+        { type: "allowXULXBL", allow: true, context: "http://mochi.test:8888" },
+        { type: "allowXULXBL", allow: true, context: "http://example.org" },
+      ]);
+    }
+
+    // Import utils in the test scope.
+    let { scope } = this.currentTest;
+    scope.EventUtils = this.EventUtils;
+    scope.AccessibilityUtils = this.AccessibilityUtils;
+    scope.SimpleTest = this.SimpleTest;
+    scope.gTestPath = this.currentTest.path;
+    scope.ContentTask = this.ContentTask;
+    scope.BrowserTestUtils = this.BrowserTestUtils;
+    scope.TestUtils = this.TestUtils;
+    scope.ExtensionTestUtils = this.ExtensionTestUtils;
+    // Pass a custom report function for mochitest style reporting.
+    scope.Assert = new this.Assert(function(err, message, stack) {
+      currentTest.addResult(
+        new testResult(
+          err
+            ? {
+                name: err.message,
+                ex: err.stack,
+                stack: err.stack,
+                allowFailure: currentTest.allowFailure,
+              }
+            : {
+                name: message,
+                pass: true,
+                stack,
+                allowFailure: currentTest.allowFailure,
+              }
+        )
+      );
+    }, true);
+
+    this.ContentTask.setTestScope(currentScope);
+
+    // Allow Assert.sys.mjs methods to be tacked to the current scope.
+    scope.export_assertions = function() {
+      for (let func in this.Assert) {
+        this[func] = this.Assert[func].bind(this.Assert);
+      }
+    };
+
+    // Override SimpleTest methods with ours.
+    SIMPLETEST_OVERRIDES.forEach(function(m) {
+      this.SimpleTest[m] = this[m];
+    }, scope);
+
+    // load the tools to work with chrome .jar and remote
+    try {
+      this._scriptLoader.loadSubScript(
+        "chrome://mochikit/content/chrome-harness.js",
+        scope
+      );
+    } catch (ex) {
+      /* no chrome-harness tools */
+    }
+
+    // Import head.js script if it exists.
+    var currentTestDirPath = this.currentTest.path.substr(
+      0,
+      this.currentTest.path.lastIndexOf("/")
+    );
+    var headPath = currentTestDirPath + "/head.js";
+    try {
+      this._scriptLoader.loadSubScript(headPath, scope);
+    } catch (ex) {
+      // Bug 755558 - Ignore loadSubScript errors due to a missing head.js.
+      const isImportError = /^Error opening input stream/.test(ex.toString());
+
+      // Bug 1503169 - head.js may call loadSubScript, and generate similar errors.
+      // Only swallow errors that are strictly related to loading head.js.
+      const containsHeadPath = ex.toString().includes(headPath);
+
+      if (!isImportError || !containsHeadPath) {
+        this.currentTest.addResult(
+          new testResult({
+            name: "head.js import threw an exception",
+            ex,
+          })
+        );
+      }
+    }
+
+    // Import the test script.
+    try {
+      this.lastStartTimestamp = performance.now();
+      this.TestUtils.promiseTestFinished = new Promise(resolve => {
+        this.resolveFinishTestPromise = resolve;
+      });
+      this._scriptLoader.loadSubScript(this.currentTest.path, scope);
+      // Run the test
+      this.lastStartTime = Date.now();
+      if (this.currentTest.scope.__tasks) {
+        // This test consists of tasks, added via the `add_task()` API.
+        if ("test" in this.currentTest.scope) {
+          throw new Error(
+            "Cannot run both a add_task test and a normal test at the same time."
+          );
+        }
+        // Spin off the async work without waiting for it to complete.
+        // It'll call finish() when it's done.
+        this._runTaskBasedTest(this.currentTest);
+      } else if (typeof scope.test == "function") {
+        scope.test();
+      } else {
+        throw new Error(
+          "This test didn't call add_task, nor did it define a generatorTest() function, nor did it define a test() function, so we don't know how to run it."
+        );
+      }
+    } catch (ex) {
+      if (!this.SimpleTest.isIgnoringAllUncaughtExceptions()) {
+        this.currentTest.addResult(
+          new testResult({
+            name: "Exception thrown",
+            pass: this.SimpleTest.isExpectingUncaughtException(),
+            ex,
+            allowFailure: this.currentTest.allowFailure,
+          })
+        );
+        this.SimpleTest.expectUncaughtException(false);
+      } else {
+        this.currentTest.addResult(new testMessage("Exception thrown: " + ex));
+      }
+      this.currentTest.scope.finish();
+    }
+
+    // If the test ran synchronously, move to the next test, otherwise the test
+    // will trigger the next test when it is done.
+    if (this.currentTest.scope.__done) {
+      this.nextTest();
+    } else {
+      var self = this;
+      var timeoutExpires = Date.now() + gTimeoutSeconds * 1000;
+      var waitUntilAtLeast = timeoutExpires - 1000;
+      this.currentTest.scope.__waitTimer = this.SimpleTest._originalSetTimeout.apply(
+        window,
+        [
+          function timeoutFn() {
+            // We sometimes get woken up long before the gTimeoutSeconds
+            // have elapsed (when running in chaos mode for example). This
+            // code ensures that we don't wrongly time out in that case.
+            if (Date.now() < waitUntilAtLeast) {
+              self.currentTest.scope.__waitTimer = setTimeout(
+                timeoutFn,
+                timeoutExpires - Date.now()
+              );
+              return;
+            }
+
+            if (--self.currentTest.scope.__timeoutFactor > 0) {
+              // We were asked to wait a bit longer.
+              self.currentTest.scope.info(
+                "Longer timeout required, waiting longer...  Remaining timeouts: " +
+                  self.currentTest.scope.__timeoutFactor
+              );
+              self.currentTest.scope.__waitTimer = setTimeout(
+                timeoutFn,
+                gTimeoutSeconds * 1000
+              );
+              return;
+            }
+
+            // If the test is taking longer than expected, but it's not hanging,
+            // mark the fact, but let the test continue.  At the end of the test,
+            // if it didn't timeout, we will notify the problem through an error.
+            // To figure whether it's an actual hang, compare the time of the last
+            // result or message to half of the timeout time.
+            // Though, to protect against infinite loops, limit the number of times
+            // we allow the test to proceed.
+            const MAX_UNEXPECTED_TIMEOUTS = 10;
+            if (
+              Date.now() - self.currentTest.lastOutputTime <
+                (gTimeoutSeconds / 2) * 1000 &&
+              ++self.currentTest.unexpectedTimeouts <= MAX_UNEXPECTED_TIMEOUTS
+            ) {
+              self.currentTest.scope.__waitTimer = setTimeout(
+                timeoutFn,
+                gTimeoutSeconds * 1000
+              );
+              return;
+            }
+
+            let knownFailure = false;
+            if (gConfig.timeoutAsPass) {
+              knownFailure = true;
+            }
+            self.currentTest.addResult(
+              new testResult({
+                name: "Test timed out",
+                allowFailure: knownFailure,
+              })
+            );
+            self.currentTest.timedOut = true;
+            self.currentTest.scope.__waitTimer = null;
+            self.nextTest();
+          },
+          gTimeoutSeconds * 1000,
+        ]
+      );
+    }
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIConsoleListener"]),
+};
+
+/**
+ * Represents the result of one test assertion. This is described with a string
+ * in traditional logging, and has a "status" and "expected" property used in
+ * structured logging. Normally, results are mapped as follows:
+ *
+ *   pass:    todo:    Added to:    Described as:           Status:  Expected:
+ *     true     false    passCount    TEST-PASS               PASS     PASS
+ *     true     true     todoCount    TEST-KNOWN-FAIL         FAIL     FAIL
+ *     false    false    failCount    TEST-UNEXPECTED-FAIL    FAIL     PASS
+ *     false    true     failCount    TEST-UNEXPECTED-PASS    PASS     FAIL
+ *
+ * The "allowFailure" argument indicates that this is one of the assertions that
+ * should be allowed to fail, for example because "fail-if" is true for the
+ * current test file in the manifest. In this case, results are mapped this way:
+ *
+ *   pass:    todo:    Added to:    Described as:           Status:  Expected:
+ *     true     false    passCount    TEST-PASS               PASS     PASS
+ *     true     true     todoCount    TEST-KNOWN-FAIL         FAIL     FAIL
+ *     false    false    todoCount    TEST-KNOWN-FAIL         FAIL     FAIL
+ *     false    true     todoCount    TEST-KNOWN-FAIL         FAIL     FAIL
+ */
+function testResult({ name, pass, todo, ex, stack, allowFailure }) {
+  this.info = false;
+  this.name = name;
+  this.msg = "";
+
+  if (allowFailure && !pass) {
+    this.allowedFailure = true;
+    this.pass = true;
+    this.todo = false;
+  } else if (allowFailure && pass) {
+    this.pass = true;
+    this.todo = false;
+  } else {
+    this.pass = !!pass;
+    this.todo = todo;
+  }
+
+  this.expected = this.todo ? "FAIL" : "PASS";
+
+  if (this.pass) {
+    this.status = this.expected;
+    return;
+  }
+
+  this.status = this.todo ? "PASS" : "FAIL";
+
+  if (ex) {
+    if (typeof ex == "object" && "fileName" in ex) {
+      // we have an exception - print filename and linenumber information
+      this.msg += "at " + ex.fileName + ":" + ex.lineNumber + " - ";
+    }
+    this.msg += String(ex);
+  }
+
+  if (stack) {
+    this.msg += "\nStack trace:\n";
+    let normalized;
+    if (stack instanceof Ci.nsIStackFrame) {
+      let frames = [];
+      for (
+        let frame = stack;
+        frame;
+        frame = frame.asyncCaller || frame.caller
+      ) {
+        let msg = `${frame.filename}:${frame.name}:${frame.lineNumber}`;
+        frames.push(frame.asyncCause ? `${frame.asyncCause}*${msg}` : msg);
+      }
+      normalized = frames.join("\n");
+    } else {
+      normalized = "" + stack;
+    }
+    this.msg += normalized;
+  }
+
+  if (gConfig.debugOnFailure) {
+    // You've hit this line because you requested to break into the
+    // debugger upon a testcase failure on your test run.
+    // eslint-disable-next-line no-debugger
+    debugger;
+  }
+}
+
+function testMessage(msg) {
+  this.msg = msg || "";
+  this.info = true;
+}
+
+// Need to be careful adding properties to this object, since its properties
+// cannot conflict with global variables used in tests.
+function testScope(aTester, aTest, expected) {
+  this.__tester = aTester;
+
+  aTest.allowFailure = expected == "fail";
+
+  var self = this;
+  this.ok = function test_ok(condition, name) {
+    if (arguments.length > 2) {
+      const ex = "Too many arguments passed to ok(condition, name)`.";
+      self.record(false, name, ex);
+    } else {
+      self.record(condition, name);
+    }
+  };
+  this.record = function test_record(condition, name, ex, stack, expected) {
+    if (expected == "fail") {
+      aTest.addResult(
+        new testResult({
+          name,
+          pass: !condition,
+          todo: true,
+          ex,
+          stack: stack || Components.stack.caller,
+          allowFailure: aTest.allowFailure,
+        })
+      );
+    } else {
+      aTest.addResult(
+        new testResult({
+          name,
+          pass: condition,
+          ex,
+          stack: stack || Components.stack.caller,
+          allowFailure: aTest.allowFailure,
+        })
+      );
+    }
+  };
+  this.is = function test_is(a, b, name) {
+    self.record(
+      Object.is(a, b),
+      name,
+      `Got ${self.repr(a)}, expected ${self.repr(b)}`,
+      false,
+      Components.stack.caller
+    );
+  };
+  this.isfuzzy = function test_isfuzzy(a, b, epsilon, name) {
+    self.record(
+      a >= b - epsilon && a <= b + epsilon,
+      name,
+      `Got ${self.repr(a)}, expected ${self.repr(b)} epsilon: +/- ${self.repr(
+        epsilon
+      )}`,
+      false,
+      Components.stack.caller
+    );
+  };
+  this.isnot = function test_isnot(a, b, name) {
+    self.record(
+      !Object.is(a, b),
+      name,
+      `Didn't expect ${self.repr(a)}, but got it`,
+      false,
+      Components.stack.caller
+    );
+  };
+  this.todo = function test_todo(condition, name, ex, stack) {
+    aTest.addResult(
+      new testResult({
+        name,
+        pass: !condition,
+        todo: true,
+        ex,
+        stack: stack || Components.stack.caller,
+        allowFailure: aTest.allowFailure,
+      })
+    );
+  };
+  this.todo_is = function test_todo_is(a, b, name) {
+    self.todo(
+      Object.is(a, b),
+      name,
+      `Got ${self.repr(a)}, expected ${self.repr(b)}`,
+      Components.stack.caller
+    );
+  };
+  this.todo_isnot = function test_todo_isnot(a, b, name) {
+    self.todo(
+      !Object.is(a, b),
+      name,
+      `Didn't expect ${self.repr(a)}, but got it`,
+      Components.stack.caller
+    );
+  };
+  this.info = function test_info(name) {
+    aTest.addResult(new testMessage(name));
+  };
+  this.repr = function repr(o) {
+    if (typeof o == "undefined") {
+      return "undefined";
+    } else if (o === null) {
+      return "null";
+    }
+    try {
+      if (typeof o.__repr__ == "function") {
+        return o.__repr__();
+      } else if (typeof o.repr == "function" && o.repr != repr) {
+        return o.repr();
+      }
+    } catch (e) {}
+    try {
+      if (
+        typeof o.NAME == "string" &&
+        (o.toString == Function.prototype.toString ||
+          o.toString == Object.prototype.toString)
+      ) {
+        return o.NAME;
+      }
+    } catch (e) {}
+    var ostring;
+    try {
+      if (Object.is(o, +0)) {
+        ostring = "+0";
+      } else if (Object.is(o, -0)) {
+        ostring = "-0";
+      } else if (typeof o === "string") {
+        ostring = JSON.stringify(o);
+      } else if (Array.isArray(o)) {
+        ostring = "[" + o.map(val => repr(val)).join(", ") + "]";
+      } else {
+        ostring = String(o);
+      }
+    } catch (e) {
+      return `[${Object.prototype.toString.call(o)}]`;
+    }
+    if (typeof o == "function") {
+      ostring = ostring.replace(/\) \{[^]*/, ") { ... }");
+    }
+    return ostring;
+  };
+
+  this.executeSoon = function test_executeSoon(func) {
+    Services.tm.dispatchToMainThread({
+      run() {
+        func();
+      },
+    });
+  };
+
+  this.waitForExplicitFinish = function test_waitForExplicitFinish() {
+    self.__done = false;
+  };
+
+  this.waitForFocus = function test_waitForFocus(
+    callback,
+    targetWindow,
+    expectBlankPage
+  ) {
+    self.SimpleTest.waitForFocus(callback, targetWindow, expectBlankPage);
+  };
+
+  this.waitForClipboard = function test_waitForClipboard(
+    expected,
+    setup,
+    success,
+    failure,
+    flavor
+  ) {
+    self.SimpleTest.waitForClipboard(expected, setup, success, failure, flavor);
+  };
+
+  this.registerCleanupFunction = function test_registerCleanupFunction(
+    aFunction
+  ) {
+    self.__cleanupFunctions.push(aFunction);
+  };
+
+  this.requestLongerTimeout = function test_requestLongerTimeout(aFactor) {
+    self.__timeoutFactor = aFactor;
+  };
+
+  this.copyToProfile = function test_copyToProfile(filename) {
+    self.SimpleTest.copyToProfile(filename);
+  };
+
+  this.expectUncaughtException = function test_expectUncaughtException(
+    aExpecting
+  ) {
+    self.SimpleTest.expectUncaughtException(aExpecting);
+  };
+
+  this.ignoreAllUncaughtExceptions = function test_ignoreAllUncaughtExceptions(
+    aIgnoring
+  ) {
+    self.SimpleTest.ignoreAllUncaughtExceptions(aIgnoring);
+  };
+
+  this.expectAssertions = function test_expectAssertions(aMin, aMax) {
+    let min = aMin;
+    let max = aMax;
+    if (typeof max == "undefined") {
+      max = min;
+    }
+    if (
+      typeof min != "number" ||
+      typeof max != "number" ||
+      min < 0 ||
+      max < min
+    ) {
+      throw new Error("bad parameter to expectAssertions");
+    }
+    self.__expectedMinAsserts = min;
+    self.__expectedMaxAsserts = max;
+  };
+
+  this.setExpectedFailuresForSelfTest = function test_setExpectedFailuresForSelfTest(
+    expectedAllowedFailureCount
+  ) {
+    aTest.allowFailure = true;
+    aTest.expectedAllowedFailureCount = expectedAllowedFailureCount;
+  };
+
+  this.finish = function test_finish() {
+    self.__done = true;
+    if (self.__waitTimer) {
+      self.executeSoon(function() {
+        if (self.__done && self.__waitTimer) {
+          clearTimeout(self.__waitTimer);
+          self.__waitTimer = null;
+          self.__tester.nextTest();
+        }
+      });
+    }
+  };
+
+  this.requestCompleteLog = function test_requestCompleteLog() {
+    self.__tester.structuredLogger.deactivateBuffering();
+    self.registerCleanupFunction(function() {
+      self.__tester.structuredLogger.activateBuffering();
+    });
+  };
+
+  return this;
+}
+
+function decorateTaskFn(fn) {
+  fn = fn.bind(this);
+  fn.skip = (val = true) => (fn.__skipMe = val);
+  fn.only = () => (this.__runOnlyThisTask = fn);
+  return fn;
+}
+
+testScope.prototype = {
+  __done: true,
+  __tasks: null,
+  __setups: [],
+  __runOnlyThisTask: null,
+  __waitTimer: null,
+  __cleanupFunctions: [],
+  __timeoutFactor: 1,
+  __expectedMinAsserts: 0,
+  __expectedMaxAsserts: 0,
+
+  EventUtils: {},
+  AccessibilityUtils: {},
+  SimpleTest: {},
+  ContentTask: null,
+  BrowserTestUtils: null,
+  TestUtils: null,
+  ExtensionTestUtils: null,
+  Assert: null,
+
+  /**
+   * Add a function which returns a promise (usually an async function)
+   * as a test task.
+   *
+   * The task ends when the promise returned by the function resolves or
+   * rejects. If the test function throws, or the promise it returns
+   * rejects, the test is reported as a failure. Execution continues
+   * with the next test function.
+   *
+   * Example usage:
+   *
+   * add_task(async function test() {
+   *   let result = await Promise.resolve(true);
+   *
+   *   ok(result);
+   *
+   *   let secondary = await someFunctionThatReturnsAPromise(result);
+   *   is(secondary, "expected value");
+   * });
+   *
+   * add_task(async function test_early_return() {
+   *   let result = await somethingThatReturnsAPromise();
+   *
+   *   if (!result) {
+   *     // Test is ended immediately, with success.
+   *     return;
+   *   }
+   *
+   *   is(result, "foo");
+   * });
+   */
+  add_task(aFunction) {
+    if (!this.__tasks) {
+      this.waitForExplicitFinish();
+      this.__tasks = [];
+    }
+    let bound = decorateTaskFn.call(this, aFunction);
+    this.__tasks.push(bound);
+    return bound;
+  },
+
+  add_setup(aFunction) {
+    if (!this.__setups.length) {
+      this.waitForExplicitFinish();
+    }
+    let bound = aFunction.bind(this);
+    this.__setups.push(bound);
+    return bound;
+  },
+
+  destroy: function test_destroy() {
+    for (let prop in this) {
+      delete this[prop];
+    }
+  },
+};