/* -*- 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.defineESModuleGetters(this, {
  AddonManager: "resource://gre/modules/AddonManager.sys.mjs",
});

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) {
    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.fixupAndLoadURIString(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;

  this.AccessibilityUtils.init();

  // 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.importESModule(
    "resource://testing-common/PerTestCoverageUtils.sys.mjs"
  ).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",
      // lit
      "reactiveElementVersions",
      "litHtmlVersions",
      "litElementVersions",
    ];

    this._repeatingTimers = this._getRepeatingTimers();

    this.PerTestCoverageUtils.beforeTestSync();

    if (this.tests.length) {
      this.waitForWindowsReady().then(() => {
        this.nextTest();
      });
    } else {
      this.finish();
    }
  },

  _getRepeatingTimers() {
    const kNonRepeatingTimerTypes = [
      Ci.nsITimer.TYPE_ONE_SHOT,
      Ci.nsITimer.TYPE_ONE_SHOT_LOW_PRIORITY,
    ];
    return Cc["@mozilla.org/timer-manager;1"]
      .getService(Ci.nsITimerManager)
      .getTimers()
      .filter(t => !kNonRepeatingTimerTypes.includes(t.type));
  },

  async waitForWindowsReady() {
    await this.setupDefaultTheme();
    await new Promise(resolve =>
      this.waitForGraphicsTestWindowToBeGone(resolve)
    );
    await this.promiseMainWindowReady();
  },

  async promiseMainWindowReady() {
    if (window.gBrowserInit) {
      await window.gBrowserInit.idleTasksFinished.promise;
    }
  },

  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() {
    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);

    this.AccessibilityUtils.uninit();

    // 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.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) {
    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."
      );
    }
  },

  getNewRepeatingTimers() {
    let repeatingTimers = this._getRepeatingTimers();
    let results = [];
    for (let timer of repeatingTimers) {
      let { name, delay } = timer;
      // For now ignore long repeating timers (typically from nsExpirationTracker).
      if (delay >= 10000) {
        continue;
      }

      // Also ignore the nsAvailableMemoryWatcher timer that is started when the
      // user-interaction-active notification is fired, and stopped when the
      // user-interaction-inactive notification occurs.
      // On Linux it's a 5s timer, on other platforms it's 10s, which is already
      // ignored by the previous case.
      if (
        AppConstants.platform == "linux" &&
        name == "nsAvailableMemoryWatcher"
      ) {
        continue;
      }

      // Ignore nsHttpConnectionMgr timers which show up on browser mochitests
      // running with http3. See Bug 1829841.
      if (name == "nsHttpConnectionMgr") {
        continue;
      }

      if (
        !this._repeatingTimers.find(t => t.delay == delay && t.name == name)
      ) {
        results.push(timer);
      }
    }
    if (results.length) {
      ChromeUtils.addProfilerMarker(
        "NewRepeatingTimers",
        { category: "Test" },
        results.map(t => `${t.name}: ${t.delay}ms`).join(", ")
      );
    }
    return results;
  },

  async ensureNoNewRepeatingTimers() {
    let newTimers;
    try {
      await this.TestUtils.waitForCondition(
        async function () {
          // The array returned by nsITimerManager.getTimers doesn't include
          // timers that are queued in the event loop of their target thread.
          // By waiting for a tick, we ensure the timers that might fire about
          // at the same time as our waitForCondition timer will be included.
          await this.TestUtils.waitForTick();

          newTimers = this.getNewRepeatingTimers();
          return !newTimers.length;
        }.bind(this),
        "waiting for new repeating timers to be cancelled"
      );
    } catch (e) {
      this.Assert.ok(false, e);
      for (let { name, delay } of newTimers) {
        this.Assert.ok(
          false,
          `test left unexpected repeating timer ${name} (duration: ${delay}ms)`
        );
      }
      // Once the new repeating timers have been reported, add them to
      // this._repeatingTimers to avoid reporting them again for the next
      // tests of the manifest.
      this._repeatingTimers.push(...newTimers);
    }
  },

  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");

      // Ensure to reset the clipboard in case the test has modified it,
      // so it won't affect the next tests.
      window.SpecialPowers.clipboardCopyString("");

      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);

      await this.ensureNoNewRepeatingTimers();

      // 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 {
            const { profile } =
              await Services.profiler.getProfileDataAsGzippedArrayBuffer();
            await IOUtils.write(profilePath, new Uint8Array(profile));
            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.createAboutBlankDocumentViewer(null, null);
              sidebar.setAttribute("src", "about:blank");
            }
          }

          // Destroy BackgroundPageThumbs resources.
          let { BackgroundPageThumbs } = ChromeUtils.importESModule(
            "resource://gre/modules/BackgroundPageThumbs.sys.mjs"
          );
          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} ${task.name}`,
            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} ${task.name}`,
          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, this.currentTest.path);

    // 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 */
    }

    // Ensure we are not idle at the beginning of the test. If we don't do this,
    // the browser may behave differently if the previous tests ran long.
    // eg. the session store behavior changes 3 minutes after the last user event.
    Cc["@mozilla.org/widget/useridleservice;1"]
      .getService(Ci.nsIUserIdleServiceInternal)
      .resetIdleTimeOut(0);

    // 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;
            if (gConfig.timeoutAsPass) {
              self.nextTest();
            } else {
              self.finish();
            }
          },
          gTimeoutSeconds * 1000,
        ]);
    }
  },

  QueryInterface: ChromeUtils.generateQI(["nsIConsoleListener"]),
};

// Note: duplicated in SimpleTest.js . See also bug 1820150.
function isErrorOrException(err) {
  // It'd be nice if we had either `Error.isError(err)` or `Error.isInstance(err)`
  // but we don't, so do it ourselves:
  if (!err) {
    return false;
  }
  if (err instanceof Ci.nsIException) {
    return true;
  }
  try {
    let glob = Cu.getGlobalForObject(err);
    return err instanceof glob.Error;
  } catch {
    // getGlobalForObject can be upset if it doesn't get passed an object.
    // Just do a standard instanceof check using this global and cross fingers:
  }
  return err instanceof Error;
}

/**
 * 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 + " - ";
    }

    if (
      typeof ex == "string" ||
      (typeof ex == "object" && isErrorOrException(ex))
    ) {
      this.msg += String(ex);
    } else {
      try {
        this.msg += JSON.stringify(ex);
      } catch {
        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.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];
    }
  },
};
