Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 2216 insertions, 0 deletions

diff --git a/testing/mochitest/tests/SimpleTest/SimpleTest.js b/testing/mochitest/tests/SimpleTest/SimpleTest.js
new file mode 100644
index 0000000000..a5d7528bbc
--- /dev/null
+++ b/testing/mochitest/tests/SimpleTest/SimpleTest.js
@@ -0,0 +1,2216 @@
+/* -*- js-indent-level: 2; tab-width: 2; indent-tabs-mode: nil -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+
+// Generally gTestPath should be set by the harness.
+/* global gTestPath */
+
+/**
+ * SimpleTest framework object.
+ * @class
+ */
+var SimpleTest = {};
+var parentRunner = null;
+
+// Using a try/catch rather than SpecialPowers.Cu.isRemoteProxy() because
+// it doesn't cover the case where an iframe is xorigin but fission is
+// not enabled.
+let isSameOrigin = function (w) {
+  try {
+    w.top.TestRunner;
+  } catch (e) {
+    if (e instanceof DOMException) {
+      return false;
+    }
+  }
+  return true;
+};
+let isXOrigin = !isSameOrigin(window);
+
+// Note: duplicated in browser-test.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 = SpecialPowers.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;
+}
+
+// In normal test runs, the window that has a TestRunner in its parent is
+// the primary window.  In single test runs, if there is no parent and there
+// is no opener then it is the primary window.
+var isSingleTestRun =
+  parent == window &&
+  !(opener || (window.arguments && window.arguments[0].SimpleTest));
+try {
+  var isPrimaryTestWindow =
+    (isXOrigin && parent != window && parent == top) ||
+    (!isXOrigin && (!!parent.TestRunner || isSingleTestRun));
+} catch (e) {
+  dump(
+    "TEST-UNEXPECTED-FAIL, Exception caught: " +
+      e.message +
+      ", at: " +
+      e.fileName +
+      " (" +
+      e.lineNumber +
+      "), location: " +
+      window.location.href +
+      "\n"
+  );
+}
+
+let xOriginRunner = {
+  init(harnessWindow) {
+    this.harnessWindow = harnessWindow;
+    let url = new URL(document.URL);
+    this.testFile = url.pathname;
+    this.showTestReport = url.searchParams.get("showTestReport") == "true";
+    this.expected = url.searchParams.get("expected");
+  },
+  callHarnessMethod(applyOn, command, ...params) {
+    // Message handled by xOriginTestRunnerHandler in TestRunner.js
+    this.harnessWindow.postMessage(
+      {
+        harnessType: "SimpleTest",
+        applyOn,
+        command,
+        params,
+      },
+      "*"
+    );
+  },
+  getParameterInfo() {
+    let url = new URL(document.URL);
+    return {
+      currentTestURL: url.searchParams.get("currentTestURL"),
+      testRoot: url.searchParams.get("testRoot"),
+    };
+  },
+  addFailedTest(test) {
+    this.callHarnessMethod("runner", "addFailedTest", test);
+  },
+  expectAssertions(min, max) {
+    this.callHarnessMethod("runner", "expectAssertions", min, max);
+  },
+  expectChildProcessCrash() {
+    this.callHarnessMethod("runner", "expectChildProcessCrash");
+  },
+  requestLongerTimeout(factor) {
+    this.callHarnessMethod("runner", "requestLongerTimeout", factor);
+  },
+  _lastAssertionCount: 0,
+  testFinished(tests) {
+    var newAssertionCount = SpecialPowers.assertionCount();
+    var numAsserts = newAssertionCount - this._lastAssertionCount;
+    this._lastAssertionCount = newAssertionCount;
+    this.callHarnessMethod("runner", "addAssertionCount", numAsserts);
+    this.callHarnessMethod("runner", "testFinished", tests);
+  },
+  structuredLogger: {
+    info(msg) {
+      xOriginRunner.callHarnessMethod("logger", "structuredLogger.info", msg);
+    },
+    warning(msg) {
+      xOriginRunner.callHarnessMethod(
+        "logger",
+        "structuredLogger.warning",
+        msg
+      );
+    },
+    error(msg) {
+      xOriginRunner.callHarnessMethod("logger", "structuredLogger.error", msg);
+    },
+    activateBuffering() {
+      xOriginRunner.callHarnessMethod(
+        "logger",
+        "structuredLogger.activateBuffering"
+      );
+    },
+    deactivateBuffering() {
+      xOriginRunner.callHarnessMethod(
+        "logger",
+        "structuredLogger.deactivateBuffering"
+      );
+    },
+    testStatus(url, subtest, status, expected, diagnostic, stack) {
+      xOriginRunner.callHarnessMethod(
+        "logger",
+        "structuredLogger.testStatus",
+        url,
+        subtest,
+        status,
+        expected,
+        diagnostic,
+        stack
+      );
+    },
+  },
+};
+
+// Finds the TestRunner for this test run and the SpecialPowers object (in
+// case it is not defined) from a parent/opener window.
+//
+// Finding the SpecialPowers object is needed when we have ChromePowers in
+// harness.xhtml and we need SpecialPowers in the iframe, and also for tests
+// like test_focus.xhtml where we open a window which opens another window which
+// includes SimpleTest.js.
+(function () {
+  function ancestor(w) {
+    return w.parent != w
+      ? w.parent
+      : w.opener ||
+          (!isXOrigin &&
+            w.arguments &&
+            SpecialPowers.wrap(Window).isInstance(w.arguments[0]) &&
+            w.arguments[0]);
+  }
+
+  var w = ancestor(window);
+  while (w && !parentRunner) {
+    isXOrigin = !isSameOrigin(w);
+
+    if (isXOrigin) {
+      if (w.parent != w) {
+        w = w.top;
+      }
+      xOriginRunner.init(w);
+      parentRunner = xOriginRunner;
+    }
+
+    if (!parentRunner) {
+      parentRunner = w.TestRunner;
+      if (!parentRunner && w.wrappedJSObject) {
+        parentRunner = w.wrappedJSObject.TestRunner;
+      }
+    }
+    w = ancestor(w);
+  }
+
+  if (parentRunner) {
+    SimpleTest.harnessParameters = parentRunner.getParameterInfo();
+  }
+})();
+
+/* Helper functions pulled out of various MochiKit modules */
+if (typeof repr == "undefined") {
+  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 (o === 0) {
+        ostring = 1 / o > 0 ? "+0" : "-0";
+      } else if (typeof o === "string") {
+        ostring = JSON.stringify(o);
+      } else if (Array.isArray(o)) {
+        ostring = "[" + o.map(val => repr(val)).join(", ") + "]";
+      } else {
+        ostring = o + "";
+      }
+    } catch (e) {
+      return "[" + typeof o + "]";
+    }
+    if (typeof o == "function") {
+      o = ostring.replace(/^\s+/, "");
+      var idx = o.indexOf("{");
+      if (idx != -1) {
+        o = o.substr(0, idx) + "{...}";
+      }
+    }
+    return ostring;
+  };
+}
+
+/* This returns a function that applies the previously given parameters.
+ * This is used by SimpleTest.showReport
+ */
+if (typeof partial == "undefined") {
+  this.partial = function (func) {
+    var args = [];
+    for (let i = 1; i < arguments.length; i++) {
+      args.push(arguments[i]);
+    }
+    return function () {
+      if (arguments.length) {
+        for (let i = 1; i < arguments.length; i++) {
+          args.push(arguments[i]);
+        }
+      }
+      func(args);
+    };
+  };
+}
+
+if (typeof getElement == "undefined") {
+  this.getElement = function (id) {
+    return typeof id == "string" ? document.getElementById(id) : id;
+  };
+  this.$ = this.getElement;
+}
+
+SimpleTest._newCallStack = function (path) {
+  var rval = function callStackHandler() {
+    var callStack = callStackHandler.callStack;
+    for (var i = 0; i < callStack.length; i++) {
+      if (callStack[i].apply(this, arguments) === false) {
+        break;
+      }
+    }
+    try {
+      this[path] = null;
+    } catch (e) {
+      // pass
+    }
+  };
+  rval.callStack = [];
+  return rval;
+};
+
+if (typeof addLoadEvent == "undefined") {
+  this.addLoadEvent = function (func) {
+    var existing = window.onload;
+    var regfunc = existing;
+    if (
+      !(
+        typeof existing == "function" &&
+        typeof existing.callStack == "object" &&
+        existing.callStack !== null
+      )
+    ) {
+      regfunc = SimpleTest._newCallStack("onload");
+      if (typeof existing == "function") {
+        regfunc.callStack.push(existing);
+      }
+      window.onload = regfunc;
+    }
+    regfunc.callStack.push(func);
+  };
+}
+
+function createEl(type, attrs, html) {
+  //use createElementNS so the xul/xhtml tests have no issues
+  var el;
+  if (!document.body) {
+    el = document.createElementNS("http://www.w3.org/1999/xhtml", type);
+  } else {
+    el = document.createElement(type);
+  }
+  if (attrs !== null && attrs !== undefined) {
+    for (var k in attrs) {
+      el.setAttribute(k, attrs[k]);
+    }
+  }
+  if (html !== null && html !== undefined) {
+    el.appendChild(document.createTextNode(html));
+  }
+  return el;
+}
+
+/* lots of tests use this as a helper to get css properties */
+if (typeof computedStyle == "undefined") {
+  this.computedStyle = function (elem, cssProperty) {
+    elem = getElement(elem);
+    if (elem.currentStyle) {
+      return elem.currentStyle[cssProperty];
+    }
+    if (typeof document.defaultView == "undefined" || document === null) {
+      return undefined;
+    }
+    var style = document.defaultView.getComputedStyle(elem);
+    if (typeof style == "undefined" || style === null) {
+      return undefined;
+    }
+
+    var selectorCase = cssProperty.replace(/([A-Z])/g, "-$1").toLowerCase();
+
+    return style.getPropertyValue(selectorCase);
+  };
+}
+
+SimpleTest._tests = [];
+SimpleTest._stopOnLoad = true;
+SimpleTest._cleanupFunctions = [];
+SimpleTest._timeoutFunctions = [];
+SimpleTest._inChaosMode = false;
+// When using failure pattern file to filter unexpected issues,
+// SimpleTest.expected would be an array of [pattern, expected count],
+// and SimpleTest.num_failed would be an array of actual counts which
+// has the same length as SimpleTest.expected.
+SimpleTest.expected = "pass";
+SimpleTest.num_failed = 0;
+
+SpecialPowers.setAsDefaultAssertHandler();
+
+function usesFailurePatterns() {
+  return Array.isArray(SimpleTest.expected);
+}
+
+/**
+ * Checks whether there is any failure pattern matches the given error
+ * message, and if found, bumps the counter of the failure pattern.
+ *
+ * @return {boolean} Whether a matched failure pattern is found.
+ */
+function recordIfMatchesFailurePattern(name, diag) {
+  let index = SimpleTest.expected.findIndex(([pat, count]) => {
+    return (
+      pat == null ||
+      (typeof name == "string" && name.includes(pat)) ||
+      (typeof diag == "string" && diag.includes(pat))
+    );
+  });
+  if (index >= 0) {
+    SimpleTest.num_failed[index]++;
+    return true;
+  }
+  return false;
+}
+
+SimpleTest.setExpected = function () {
+  if (!parentRunner) {
+    return;
+  }
+  if (!Array.isArray(parentRunner.expected)) {
+    SimpleTest.expected = parentRunner.expected;
+  } else {
+    // Assertions are checked by the runner.
+    SimpleTest.expected = parentRunner.expected.filter(
+      ([pat]) => pat != "ASSERTION"
+    );
+    SimpleTest.num_failed = new Array(SimpleTest.expected.length);
+    SimpleTest.num_failed.fill(0);
+  }
+};
+SimpleTest.setExpected();
+
+/**
+ * Something like assert.
+ **/
+SimpleTest.ok = function (condition, name) {
+  if (arguments.length > 2) {
+    const diag = "Too many arguments passed to `ok(condition, name)`";
+    SimpleTest.record(false, name, diag);
+  } else {
+    SimpleTest.record(condition, name);
+  }
+};
+
+SimpleTest.record = function (condition, name, diag, stack, expected) {
+  var test = { result: !!condition, name, diag };
+  let successInfo;
+  let failureInfo;
+  if (SimpleTest.expected == "fail") {
+    if (!test.result) {
+      SimpleTest.num_failed++;
+      test.result = true;
+    }
+    successInfo = {
+      status: "PASS",
+      expected: "PASS",
+      message: "TEST-PASS",
+    };
+    failureInfo = {
+      status: "FAIL",
+      expected: "FAIL",
+      message: "TEST-KNOWN-FAIL",
+    };
+  } else if (!test.result && usesFailurePatterns()) {
+    if (recordIfMatchesFailurePattern(name, diag)) {
+      test.result = true;
+      // Add a mark for unexpected failures suppressed by failure pattern.
+      name = "[suppressed] " + name;
+    }
+    successInfo = {
+      status: "FAIL",
+      expected: "FAIL",
+      message: "TEST-KNOWN-FAIL",
+    };
+    failureInfo = {
+      status: "FAIL",
+      expected: "PASS",
+      message: "TEST-UNEXPECTED-FAIL",
+    };
+  } else if (expected == "fail") {
+    successInfo = {
+      status: "PASS",
+      expected: "FAIL",
+      message: "TEST-UNEXPECTED-PASS",
+    };
+    failureInfo = {
+      status: "FAIL",
+      expected: "FAIL",
+      message: "TEST-KNOWN-FAIL",
+    };
+  } else {
+    successInfo = {
+      status: "PASS",
+      expected: "PASS",
+      message: "TEST-PASS",
+    };
+    failureInfo = {
+      status: "FAIL",
+      expected: "PASS",
+      message: "TEST-UNEXPECTED-FAIL",
+    };
+  }
+
+  if (condition) {
+    stack = null;
+  } else if (!stack) {
+    stack = new Error().stack
+      .replace(/^(.*@)http:\/\/mochi.test:8888\/tests\//gm, "    $1")
+      .split("\n");
+    stack.splice(0, 1);
+    stack = stack.join("\n");
+  }
+  SimpleTest._logResult(test, successInfo, failureInfo, stack);
+  SimpleTest._tests.push(test);
+};
+
+/**
+ * Roughly equivalent to ok(Object.is(a, b), name)
+ **/
+SimpleTest.is = function (a, b, name) {
+  // Be lazy and use Object.is til we want to test a browser without it.
+  var pass = Object.is(a, b);
+  var diag = pass ? "" : "got " + repr(a) + ", expected " + repr(b);
+  SimpleTest.record(pass, name, diag);
+};
+
+SimpleTest.isfuzzy = function (a, b, epsilon, name) {
+  var pass = a >= b - epsilon && a <= b + epsilon;
+  var diag = pass
+    ? ""
+    : "got " +
+      repr(a) +
+      ", expected " +
+      repr(b) +
+      " epsilon: +/- " +
+      repr(epsilon);
+  SimpleTest.record(pass, name, diag);
+};
+
+SimpleTest.isnot = function (a, b, name) {
+  var pass = !Object.is(a, b);
+  var diag = pass ? "" : "didn't expect " + repr(a) + ", but got it";
+  SimpleTest.record(pass, name, diag);
+};
+
+/**
+ * Check that the function call throws an exception.
+ */
+SimpleTest.doesThrow = function (fn, name) {
+  var gotException = false;
+  try {
+    fn();
+  } catch (ex) {
+    gotException = true;
+  }
+  ok(gotException, name);
+};
+
+//  --------------- Test.Builder/Test.More todo() -----------------
+
+SimpleTest.todo = function (condition, name, diag) {
+  var test = { result: !!condition, name, diag, todo: true };
+  if (
+    test.result &&
+    usesFailurePatterns() &&
+    recordIfMatchesFailurePattern(name, diag)
+  ) {
+    // Flipping the result to false so we don't get unexpected result. There
+    // is no perfect way here. A known failure can trigger unexpected pass,
+    // in which case, tagging it as KNOWN-FAIL probably makes more sense than
+    // marking it PASS.
+    test.result = false;
+    // Add a mark for unexpected failures suppressed by failure pattern.
+    name = "[suppressed] " + name;
+  }
+  var successInfo = {
+    status: "PASS",
+    expected: "FAIL",
+    message: "TEST-UNEXPECTED-PASS",
+  };
+  var failureInfo = {
+    status: "FAIL",
+    expected: "FAIL",
+    message: "TEST-KNOWN-FAIL",
+  };
+  SimpleTest._logResult(test, successInfo, failureInfo);
+  SimpleTest._tests.push(test);
+};
+
+/*
+ * Returns the absolute URL to a test data file from where tests
+ * are served. i.e. the file doesn't necessarely exists where tests
+ * are executed.
+ *
+ * (For android, mochitest are executed on the device, while
+ * all mochitest html (and others) files are served from the test runner
+ * slave)
+ */
+SimpleTest.getTestFileURL = function (path) {
+  var location = window.location;
+  // Remove mochitest html file name from the path
+  var remotePath = location.pathname.replace(/\/[^\/]+?$/, "");
+  var url = location.origin + remotePath + "/" + path;
+  return url;
+};
+
+SimpleTest._getCurrentTestURL = function () {
+  return (
+    (SimpleTest.harnessParameters &&
+      SimpleTest.harnessParameters.currentTestURL) ||
+    (parentRunner && parentRunner.currentTestURL) ||
+    (typeof gTestPath == "string" && gTestPath) ||
+    "unknown test url"
+  );
+};
+
+SimpleTest._forceLogMessageOutput = false;
+
+/**
+ * Force all test messages to be displayed.  Only applies for the current test.
+ */
+SimpleTest.requestCompleteLog = function () {
+  if (!parentRunner || SimpleTest._forceLogMessageOutput) {
+    return;
+  }
+
+  parentRunner.structuredLogger.deactivateBuffering();
+  SimpleTest._forceLogMessageOutput = true;
+
+  SimpleTest.registerCleanupFunction(function () {
+    parentRunner.structuredLogger.activateBuffering();
+    SimpleTest._forceLogMessageOutput = false;
+  });
+};
+
+SimpleTest._logResult = function (test, passInfo, failInfo, stack) {
+  var url = SimpleTest._getCurrentTestURL();
+  var result = test.result ? passInfo : failInfo;
+  var diagnostic = test.diag || null;
+  // BUGFIX : coercing test.name to a string, because some a11y tests pass an xpconnect object
+  var subtest = test.name ? String(test.name) : null;
+  var isError = !test.result == !test.todo;
+
+  if (parentRunner) {
+    if (!result.status || !result.expected) {
+      if (diagnostic) {
+        parentRunner.structuredLogger.info(diagnostic);
+      }
+      return;
+    }
+
+    if (isError) {
+      parentRunner.addFailedTest(url);
+    }
+
+    parentRunner.structuredLogger.testStatus(
+      url,
+      subtest,
+      result.status,
+      result.expected,
+      diagnostic,
+      stack
+    );
+  } else if (typeof dump === "function") {
+    var diagMessage = test.name + (test.diag ? " - " + test.diag : "");
+    var debugMsg = [result.message, url, diagMessage].join(" | ");
+    dump(debugMsg + "\n");
+  } else {
+    // Non-Mozilla browser?  Just do nothing.
+  }
+};
+
+SimpleTest.info = function (name, message) {
+  var log = message ? name + " | " + message : name;
+  if (parentRunner) {
+    parentRunner.structuredLogger.info(log);
+  } else {
+    dump(log + "\n");
+  }
+};
+
+/**
+ * Copies of is and isnot with the call to ok replaced by a call to todo.
+ **/
+
+SimpleTest.todo_is = function (a, b, name) {
+  var pass = Object.is(a, b);
+  var diag = pass
+    ? repr(a) + " should equal " + repr(b)
+    : "got " + repr(a) + ", expected " + repr(b);
+  SimpleTest.todo(pass, name, diag);
+};
+
+SimpleTest.todo_isnot = function (a, b, name) {
+  var pass = !Object.is(a, b);
+  var diag = pass
+    ? repr(a) + " should not equal " + repr(b)
+    : "didn't expect " + repr(a) + ", but got it";
+  SimpleTest.todo(pass, name, diag);
+};
+
+/**
+ * Makes a test report, returns it as a DIV element.
+ **/
+SimpleTest.report = function () {
+  var passed = 0;
+  var failed = 0;
+  var todo = 0;
+
+  var tallyAndCreateDiv = function (test) {
+    var cls, msg, div;
+    var diag = test.diag ? " - " + test.diag : "";
+    if (test.todo && !test.result) {
+      todo++;
+      cls = "test_todo";
+      msg = "todo | " + test.name + diag;
+    } else if (test.result && !test.todo) {
+      passed++;
+      cls = "test_ok";
+      msg = "passed | " + test.name + diag;
+    } else {
+      failed++;
+      cls = "test_not_ok";
+      msg = "failed | " + test.name + diag;
+    }
+    div = createEl("div", { class: cls }, msg);
+    return div;
+  };
+  var results = [];
+  for (var d = 0; d < SimpleTest._tests.length; d++) {
+    results.push(tallyAndCreateDiv(SimpleTest._tests[d]));
+  }
+
+  var summary_class =
+    // eslint-disable-next-line no-nested-ternary
+    failed != 0 ? "some_fail" : passed == 0 ? "todo_only" : "all_pass";
+
+  var div1 = createEl("div", { class: "tests_report" });
+  var div2 = createEl("div", { class: "tests_summary " + summary_class });
+  var div3 = createEl("div", { class: "tests_passed" }, "Passed: " + passed);
+  var div4 = createEl("div", { class: "tests_failed" }, "Failed: " + failed);
+  var div5 = createEl("div", { class: "tests_todo" }, "Todo: " + todo);
+  div2.appendChild(div3);
+  div2.appendChild(div4);
+  div2.appendChild(div5);
+  div1.appendChild(div2);
+  for (var t = 0; t < results.length; t++) {
+    //iterate in order
+    div1.appendChild(results[t]);
+  }
+  return div1;
+};
+
+/**
+ * Toggle element visibility
+ **/
+SimpleTest.toggle = function (el) {
+  if (computedStyle(el, "display") == "block") {
+    el.style.display = "none";
+  } else {
+    el.style.display = "block";
+  }
+};
+
+/**
+ * Toggle visibility for divs with a specific class.
+ **/
+SimpleTest.toggleByClass = function (cls, evt) {
+  var children = document.getElementsByTagName("div");
+  var elements = [];
+  for (var i = 0; i < children.length; i++) {
+    var child = children[i];
+    var clsName = child.className;
+    if (!clsName) {
+      continue;
+    }
+    var classNames = clsName.split(" ");
+    for (var j = 0; j < classNames.length; j++) {
+      if (classNames[j] == cls) {
+        elements.push(child);
+        break;
+      }
+    }
+  }
+  for (var t = 0; t < elements.length; t++) {
+    //TODO: again, for-in loop over elems seems to break this
+    SimpleTest.toggle(elements[t]);
+  }
+  if (evt) {
+    evt.preventDefault();
+  }
+};
+
+/**
+ * Shows the report in the browser
+ **/
+SimpleTest.showReport = function () {
+  var togglePassed = createEl("a", { href: "#" }, "Toggle passed checks");
+  var toggleFailed = createEl("a", { href: "#" }, "Toggle failed checks");
+  var toggleTodo = createEl("a", { href: "#" }, "Toggle todo checks");
+  togglePassed.onclick = partial(SimpleTest.toggleByClass, "test_ok");
+  toggleFailed.onclick = partial(SimpleTest.toggleByClass, "test_not_ok");
+  toggleTodo.onclick = partial(SimpleTest.toggleByClass, "test_todo");
+  var body = document.body; // Handles HTML documents
+  if (!body) {
+    // Do the XML thing.
+    body = document.getElementsByTagNameNS(
+      "http://www.w3.org/1999/xhtml",
+      "body"
+    )[0];
+  }
+  var firstChild = body.childNodes[0];
+  var addNode;
+  if (firstChild) {
+    addNode = function (el) {
+      body.insertBefore(el, firstChild);
+    };
+  } else {
+    addNode = function (el) {
+      body.appendChild(el);
+    };
+  }
+  addNode(togglePassed);
+  addNode(createEl("span", null, " "));
+  addNode(toggleFailed);
+  addNode(createEl("span", null, " "));
+  addNode(toggleTodo);
+  addNode(SimpleTest.report());
+  // Add a separator from the test content.
+  addNode(createEl("hr"));
+};
+
+/**
+ * Tells SimpleTest to don't finish the test when the document is loaded,
+ * useful for asynchronous tests.
+ *
+ * When SimpleTest.waitForExplicitFinish is called,
+ * explicit SimpleTest.finish() is required.
+ **/
+SimpleTest.waitForExplicitFinish = function () {
+  SimpleTest._stopOnLoad = false;
+};
+
+/**
+ * Multiply the timeout the parent runner uses for this test by the
+ * given factor.
+ *
+ * For example, in a test that may take a long time to complete, using
+ * "SimpleTest.requestLongerTimeout(5)" will give it 5 times as long to
+ * finish.
+ *
+ * @param {Number} factor
+ *        The multiplication factor to use on the timeout for this test.
+ */
+SimpleTest.requestLongerTimeout = function (factor) {
+  if (parentRunner) {
+    parentRunner.requestLongerTimeout(factor);
+  } else {
+    dump(
+      "[SimpleTest.requestLongerTimeout()] ignoring request, maybe you meant to call the global `requestLongerTimeout` instead?\n"
+    );
+  }
+};
+
+/**
+ * Note that the given range of assertions is to be expected.  When
+ * this function is not called, 0 assertions are expected.  When only
+ * one argument is given, that number of assertions are expected.
+ *
+ * A test where we expect to have assertions (which should largely be a
+ * transitional mechanism to get assertion counts down from our current
+ * situation) can call the SimpleTest.expectAssertions() function, with
+ * either one or two arguments:  one argument gives an exact number
+ * expected, and two arguments give a range.  For example, a test might do
+ * one of the following:
+ *
+ * @example
+ *
+ *   // Currently triggers two assertions (bug NNNNNN).
+ *   SimpleTest.expectAssertions(2);
+ *
+ *   // Currently triggers one assertion on Mac (bug NNNNNN).
+ *   if (navigator.platform.indexOf("Mac") == 0) {
+ *     SimpleTest.expectAssertions(1);
+ *   }
+ *
+ *   // Currently triggers two assertions on all platforms (bug NNNNNN),
+ *   // but intermittently triggers two additional assertions (bug NNNNNN)
+ *   // on Windows.
+ *   if (navigator.platform.indexOf("Win") == 0) {
+ *     SimpleTest.expectAssertions(2, 4);
+ *   } else {
+ *     SimpleTest.expectAssertions(2);
+ *   }
+ *
+ *   // Intermittently triggers up to three assertions (bug NNNNNN).
+ *   SimpleTest.expectAssertions(0, 3);
+ */
+SimpleTest.expectAssertions = function (min, max) {
+  if (parentRunner) {
+    parentRunner.expectAssertions(min, max);
+  }
+};
+
+SimpleTest._flakyTimeoutIsOK = false;
+SimpleTest._originalSetTimeout = window.setTimeout;
+window.setTimeout = function SimpleTest_setTimeoutShim() {
+  // Don't break tests that are loaded without a parent runner.
+  if (parentRunner) {
+    // Right now, we only enable these checks for mochitest-plain.
+    switch (SimpleTest.harnessParameters.testRoot) {
+      case "browser":
+      case "chrome":
+      case "a11y":
+        break;
+      default:
+        if (
+          !SimpleTest._alreadyFinished &&
+          arguments.length > 1 &&
+          arguments[1] > 0
+        ) {
+          if (SimpleTest._flakyTimeoutIsOK) {
+            SimpleTest.todo(
+              false,
+              "The author of the test has indicated that flaky timeouts are expected.  Reason: " +
+                SimpleTest._flakyTimeoutReason
+            );
+          } else {
+            SimpleTest.ok(
+              false,
+              "Test attempted to use a flaky timeout value " + arguments[1]
+            );
+          }
+        }
+    }
+  }
+  return SimpleTest._originalSetTimeout.apply(window, arguments);
+};
+
+/**
+ * Request the framework to allow usage of setTimeout(func, timeout)
+ * where ``timeout > 0``.  This is required to note that the author of
+ * the test is aware of the inherent flakiness in the test caused by
+ * that, and asserts that there is no way around using the magic timeout
+ * value number for some reason.
+ *
+ * Use of this function is **STRONGLY** discouraged.  Think twice before
+ * using it.  Such magic timeout values could result in intermittent
+ * failures in your test, and are almost never necessary!
+ *
+ * @param {String} reason
+ *        A string representation of the reason why the test needs timeouts.
+ *
+ */
+SimpleTest.requestFlakyTimeout = function (reason) {
+  SimpleTest.is(typeof reason, "string", "A valid string reason is expected");
+  SimpleTest.isnot(reason, "", "Reason cannot be empty");
+  SimpleTest._flakyTimeoutIsOK = true;
+  SimpleTest._flakyTimeoutReason = reason;
+};
+
+/**
+ * If the page is not yet loaded, waits for the load event. If the page is
+ * not yet focused, focuses and waits for the window to be focused.
+ * If the current page is 'about:blank', then the page is assumed to not
+ * yet be loaded. Pass true for expectBlankPage to not make this assumption
+ * if you expect a blank page to be present.
+ *
+ * The target object should be specified if it is different than 'window'. The
+ * actual focused window may be a descendant window of aObject.
+ *
+ * @param {Window|browser|BrowsingContext} [aObject]
+ *        Optional object to be focused, and may be any of:
+ *          window - a window object to focus
+ *          browser - a <browser>/<iframe> element. The top-level window
+ *                    within the frame will be focused.
+ *          browsing context - a browsing context containing a window to focus
+ *        If not specified, defaults to the global 'window'.
+ * @param {boolean} [expectBlankPage=false]
+ *        True if targetWindow.location is 'about:blank'.
+ * @param {boolean} [aBlurSubframe=false]
+ *        If true, and a subframe within the window to focus is focused, blur
+ *        it so that the specified window or browsing context will receive
+ *        focus events.
+ *
+ * @returns The browsing context that was focused.
+ */
+SimpleTest.promiseFocus = async function (
+  aObject,
+  aExpectBlankPage = false,
+  aBlurSubframe = false
+) {
+  let browser;
+  let browsingContext;
+  let windowToFocus;
+
+  if (!aObject) {
+    aObject = window;
+  }
+
+  async function waitForEvent(aTarget, aEventName) {
+    return new Promise(resolve => {
+      aTarget.addEventListener(aEventName, resolve, {
+        capture: true,
+        once: true,
+      });
+    });
+  }
+
+  if (SpecialPowers.wrap(Window).isInstance(aObject)) {
+    windowToFocus = aObject;
+
+    let isBlank = windowToFocus.location.href == "about:blank";
+    if (
+      aExpectBlankPage != isBlank ||
+      windowToFocus.document.readyState != "complete"
+    ) {
+      info("must wait for load");
+      await waitForEvent(windowToFocus, "load");
+    }
+  } else {
+    if (SpecialPowers.wrap(Element).isInstance(aObject)) {
+      // assume this is a browser/iframe element
+      browsingContext = aObject.browsingContext;
+    } else {
+      browsingContext = aObject;
+    }
+
+    browser =
+      browsingContext == aObject ? aObject.top.embedderElement : aObject;
+    windowToFocus = browser.ownerGlobal;
+  }
+
+  if (!windowToFocus.document.hasFocus()) {
+    info("must wait for focus");
+    let focusPromise = waitForEvent(windowToFocus.document, "focus");
+    SpecialPowers.focus(windowToFocus);
+    await focusPromise;
+  }
+
+  if (browser) {
+    if (windowToFocus.document.activeElement != browser) {
+      browser.focus();
+    }
+
+    info("must wait for focus in content");
+
+    // Make sure that the child process thinks it is focused as well.
+    await SpecialPowers.ensureFocus(browsingContext, aBlurSubframe);
+  } else {
+    if (aBlurSubframe) {
+      SpecialPowers.clearFocus(windowToFocus);
+    }
+
+    browsingContext = windowToFocus.browsingContext;
+  }
+
+  // Some tests rely on this delay, likely expecting layout or paint to occur.
+  await new Promise(resolve => {
+    SimpleTest.executeSoon(resolve);
+  });
+
+  return browsingContext;
+};
+
+/**
+ * Version of promiseFocus that uses a callback. For compatibility,
+ * the callback is passed one argument, the window that was focused.
+ * If the focused window is not in the same process, null is supplied.
+ */
+SimpleTest.waitForFocus = function (callback, aObject, expectBlankPage) {
+  SimpleTest.promiseFocus(aObject, expectBlankPage).then(focusedBC => {
+    callback(focusedBC?.window);
+  });
+};
+/* eslint-enable mozilla/use-services */
+
+SimpleTest.stripLinebreaksAndWhitespaceAfterTags = function (aString) {
+  return aString.replace(/(>\s*(\r\n|\n|\r)*\s*)/gm, ">");
+};
+
+/*
+ * `navigator.platform` should include this, when the platform is Windows.
+ */
+const kPlatformWindows = "Win";
+
+/*
+ * See `SimpleTest.waitForClipboard`.
+ */
+const kTextHtmlPrefixClipboardDataWindows =
+  "<html><body>\n<!--StartFragment-->";
+
+/*
+ * See `SimpleTest.waitForClipboard`.
+ */
+const kTextHtmlSuffixClipboardDataWindows =
+  "<!--EndFragment-->\n</body>\n</html>";
+
+/*
+ * Polls the clipboard waiting for the expected value. A known value different than
+ * the expected value is put on the clipboard first (and also polled for) so we
+ * can be sure the value we get isn't just the expected value because it was already
+ * on the clipboard. This only uses the global clipboard and only for text/plain
+ * values.
+ *
+ * @param {String|Function} aExpectedStringOrValidatorFn
+ *        The string value that is expected to be on the clipboard, or a
+ *        validator function getting expected clipboard data and returning a bool.
+ *        If you specify string value, line breakers in clipboard are treated
+ *        as LineFeed.  Therefore, you cannot include CarriageReturn to the
+ *        string.
+ *        If you specify string value and expect "text/html" data, this wraps
+ *        the expected value with `kTextHtmlPrefixClipboardDataWindows` and
+ *        `kTextHtmlSuffixClipboardDataWindows` only when it runs on Windows
+ *        because they are appended only by nsDataObj.cpp for Windows.
+ *        https://searchfox.org/mozilla-central/rev/8f7b017a31326515cb467e69eef1f6c965b4f00e/widget/windows/nsDataObj.cpp#1798-1805,1839-1840,1842
+ *        Therefore, you can specify selected (copied) HTML data simply on any
+ *        platforms.
+ * @param {Function} aSetupFn
+ *        A function responsible for setting the clipboard to the expected value,
+ *        called after the known value setting succeeds.
+ * @param {Function} aSuccessFn
+ *        A function called when the expected value is found on the clipboard.
+ * @param {Function} aFailureFn
+ *        A function called if the expected value isn't found on the clipboard
+ *        within 5s. It can also be called if the known value can't be found.
+ * @param {String} [aFlavor="text/plain"]
+ *        The flavor to look for.
+ * @param {Number} [aTimeout=5000]
+ *        The timeout (in milliseconds) to wait for a clipboard change.
+ * @param {boolean} [aExpectFailure=false]
+ *        If true, fail if the clipboard contents are modified within the timeout
+ *        interval defined by aTimeout.  When aExpectFailure is true, the argument
+ *        aExpectedStringOrValidatorFn must be null, as it won't be used.
+ * @param {boolean} [aDontInitializeClipboardIfExpectFailure=false]
+ *        If aExpectFailure and this is set to true, this does NOT initialize
+ *        clipboard with random data before running aSetupFn.
+ */
+SimpleTest.waitForClipboard = function (
+  aExpectedStringOrValidatorFn,
+  aSetupFn,
+  aSuccessFn,
+  aFailureFn,
+  aFlavor,
+  aTimeout,
+  aExpectFailure,
+  aDontInitializeClipboardIfExpectFailure
+) {
+  let promise = SimpleTest.promiseClipboardChange(
+    aExpectedStringOrValidatorFn,
+    aSetupFn,
+    aFlavor,
+    aTimeout,
+    aExpectFailure,
+    aDontInitializeClipboardIfExpectFailure
+  );
+  promise.then(aSuccessFn).catch(aFailureFn);
+};
+
+/**
+ * Promise-oriented version of waitForClipboard.
+ */
+SimpleTest.promiseClipboardChange = async function (
+  aExpectedStringOrValidatorFn,
+  aSetupFn,
+  aFlavor,
+  aTimeout,
+  aExpectFailure,
+  aDontInitializeClipboardIfExpectFailure
+) {
+  let requestedFlavor = aFlavor || "text/plain";
+
+  // The known value we put on the clipboard before running aSetupFn
+  let initialVal = "waitForClipboard-known-value-" + Math.random();
+  let preExpectedVal = initialVal;
+
+  let inputValidatorFn;
+  if (aExpectFailure) {
+    // If we expect failure, the aExpectedStringOrValidatorFn should be null
+    if (aExpectedStringOrValidatorFn !== null) {
+      SimpleTest.ok(
+        false,
+        "When expecting failure, aExpectedStringOrValidatorFn must be null"
+      );
+    }
+
+    inputValidatorFn = function (aData) {
+      return aData != initialVal;
+    };
+    // Build a default validator function for common string input.
+  } else if (typeof aExpectedStringOrValidatorFn == "string") {
+    if (aExpectedStringOrValidatorFn.includes("\r")) {
+      throw new Error(
+        "Use function instead of string to compare raw line breakers in clipboard"
+      );
+    }
+    if (requestedFlavor === "text/html" && navigator.platform.includes("Win")) {
+      inputValidatorFn = function (aData) {
+        return (
+          aData.replace(/\r\n?/g, "\n") ===
+          kTextHtmlPrefixClipboardDataWindows +
+            aExpectedStringOrValidatorFn +
+            kTextHtmlSuffixClipboardDataWindows
+        );
+      };
+    } else {
+      inputValidatorFn = function (aData) {
+        return aData.replace(/\r\n?/g, "\n") === aExpectedStringOrValidatorFn;
+      };
+    }
+  } else {
+    inputValidatorFn = aExpectedStringOrValidatorFn;
+  }
+
+  let maxPolls = aTimeout ? aTimeout / 100 : 50;
+
+  async function putAndVerify(operationFn, validatorFn, flavor, expectFailure) {
+    await operationFn();
+
+    let data;
+    for (let i = 0; i < maxPolls; i++) {
+      data = SpecialPowers.getClipboardData(flavor);
+      if (validatorFn(data)) {
+        // Don't show the success message when waiting for preExpectedVal
+        if (preExpectedVal) {
+          preExpectedVal = null;
+        } else {
+          SimpleTest.ok(
+            !expectFailure,
+            "Clipboard has the given value: '" + data + "'"
+          );
+        }
+
+        return data;
+      }
+
+      // Wait 100ms and check again.
+      await new Promise(resolve => {
+        SimpleTest._originalSetTimeout.apply(window, [resolve, 100]);
+      });
+    }
+
+    let errorMsg = `Timed out while polling clipboard for ${
+      preExpectedVal ? "initialized" : "requested"
+    } data, got: ${data}`;
+    SimpleTest.ok(expectFailure, errorMsg);
+    if (!expectFailure) {
+      throw new Error(errorMsg);
+    }
+    return data;
+  }
+
+  if (!aExpectFailure || !aDontInitializeClipboardIfExpectFailure) {
+    // First we wait for a known value different from the expected one.
+    SimpleTest.info(`Initializing clipboard with "${preExpectedVal}"...`);
+    await putAndVerify(
+      function () {
+        SpecialPowers.clipboardCopyString(preExpectedVal);
+      },
+      function (aData) {
+        return aData == preExpectedVal;
+      },
+      "text/plain",
+      false
+    );
+
+    SimpleTest.info(
+      "Succeeded initializing clipboard, start requested things..."
+    );
+  } else {
+    preExpectedVal = null;
+  }
+
+  return putAndVerify(
+    aSetupFn,
+    inputValidatorFn,
+    requestedFlavor,
+    aExpectFailure
+  );
+};
+
+/**
+ * Wait for a condition for a while (actually up to 3s here).
+ *
+ * @param {Function} aCond
+ *        A function returns the result of the condition
+ * @param {Function} aCallback
+ *        A function called after the condition is passed or timeout.
+ * @param {String} aErrorMsg
+ *        The message displayed when the condition failed to pass
+ *        before timeout.
+ */
+SimpleTest.waitForCondition = function (aCond, aCallback, aErrorMsg) {
+  this.promiseWaitForCondition(aCond, aErrorMsg).then(() => aCallback());
+};
+SimpleTest.promiseWaitForCondition = async function (aCond, aErrorMsg) {
+  for (let tries = 0; tries < 30; ++tries) {
+    // Wait 100ms between checks.
+    await new Promise(resolve => {
+      SimpleTest._originalSetTimeout.apply(window, [resolve, 100]);
+    });
+
+    let conditionPassed;
+    try {
+      conditionPassed = await aCond();
+    } catch (e) {
+      ok(false, `${e}\n${e.stack}`);
+      conditionPassed = false;
+    }
+    if (conditionPassed) {
+      return;
+    }
+  }
+  ok(false, aErrorMsg);
+};
+
+/**
+ * Executes a function shortly after the call, but lets the caller continue
+ * working (or finish).
+ *
+ * @param {Function} aFunc
+ *        Function to execute soon.
+ */
+SimpleTest.executeSoon = function (aFunc) {
+  if ("SpecialPowers" in window) {
+    return SpecialPowers.executeSoon(aFunc, window);
+  }
+  setTimeout(aFunc, 0);
+  return null; // Avoid warning.
+};
+
+/**
+ * Register a cleanup/teardown function (which may be async) to run after all
+ * tasks have finished, before running the next test. If async (or the function
+ * returns a promise), the framework will wait for the promise/async function
+ * to resolve.
+ *
+ * @param {Function} aFunc
+ *        The cleanup/teardown function to run.
+ */
+SimpleTest.registerCleanupFunction = function (aFunc) {
+  SimpleTest._cleanupFunctions.push(aFunc);
+};
+
+SimpleTest.registerTimeoutFunction = function (aFunc) {
+  SimpleTest._timeoutFunctions.push(aFunc);
+};
+
+SimpleTest.testInChaosMode = function () {
+  if (SimpleTest._inChaosMode) {
+    // It's already enabled for this test, don't enter twice
+    return;
+  }
+  SpecialPowers.DOMWindowUtils.enterChaosMode();
+  SimpleTest._inChaosMode = true;
+  // increase timeout here as chaosmode is very slow (i.e. 10x)
+  // doing 20x as this overwrites anything the tests set
+  SimpleTest.requestLongerTimeout(20);
+};
+
+SimpleTest.timeout = async function () {
+  for (const func of SimpleTest._timeoutFunctions) {
+    await func();
+  }
+  SimpleTest._timeoutFunctions = [];
+};
+
+SimpleTest.finishWithFailure = function (msg) {
+  SimpleTest.ok(false, msg);
+  SimpleTest.finish();
+};
+
+/**
+ * Finishes the tests. This is automatically called, except when
+ * SimpleTest.waitForExplicitFinish() has been invoked.
+ **/
+SimpleTest.finish = function () {
+  if (SimpleTest._alreadyFinished) {
+    var err =
+      "TEST-UNEXPECTED-FAIL | SimpleTest | this test already called finish!";
+    if (parentRunner) {
+      parentRunner.structuredLogger.error(err);
+    } else {
+      dump(err + "\n");
+    }
+  }
+
+  if (SimpleTest.expected == "fail" && SimpleTest.num_failed <= 0) {
+    let msg = "We expected at least one failure";
+    let test = {
+      result: false,
+      name: "fail-if condition in manifest",
+      diag: msg,
+    };
+    let successInfo = {
+      status: "FAIL",
+      expected: "FAIL",
+      message: "TEST-KNOWN-FAIL",
+    };
+    let failureInfo = {
+      status: "PASS",
+      expected: "FAIL",
+      message: "TEST-UNEXPECTED-PASS",
+    };
+    SimpleTest._logResult(test, successInfo, failureInfo);
+    SimpleTest._tests.push(test);
+  } else if (usesFailurePatterns()) {
+    SimpleTest.expected.forEach(([pat, expected_count], i) => {
+      let count = SimpleTest.num_failed[i];
+      let diag;
+      if (expected_count === null && count == 0) {
+        diag = "expected some failures but got none";
+      } else if (expected_count !== null && expected_count != count) {
+        diag = `expected ${expected_count} failures but got ${count}`;
+      } else {
+        return;
+      }
+      let name = pat
+        ? `failure pattern \`${pat}\` in this test`
+        : "failures in this test";
+      let test = { result: false, name, diag };
+      let successInfo = {
+        status: "PASS",
+        expected: "PASS",
+        message: "TEST-PASS",
+      };
+      let failureInfo = {
+        status: "FAIL",
+        expected: "PASS",
+        message: "TEST-UNEXPECTED-FAIL",
+      };
+      SimpleTest._logResult(test, successInfo, failureInfo);
+      SimpleTest._tests.push(test);
+    });
+  }
+
+  SimpleTest._timeoutFunctions = [];
+
+  SimpleTest.testsLength = SimpleTest._tests.length;
+
+  SimpleTest._alreadyFinished = true;
+
+  if (SimpleTest._inChaosMode) {
+    SpecialPowers.DOMWindowUtils.leaveChaosMode();
+    SimpleTest._inChaosMode = false;
+  }
+
+  var afterCleanup = async function () {
+    SpecialPowers.removeFiles();
+
+    if (SpecialPowers.DOMWindowUtils.isTestControllingRefreshes) {
+      SimpleTest.ok(false, "test left refresh driver under test control");
+      SpecialPowers.DOMWindowUtils.restoreNormalRefresh();
+    }
+    if (SimpleTest._expectingUncaughtException) {
+      SimpleTest.ok(
+        false,
+        "expectUncaughtException was called but no uncaught exception was detected!"
+      );
+    }
+    if (!SimpleTest._tests.length) {
+      SimpleTest.ok(
+        false,
+        "[SimpleTest.finish()] No checks actually run. " +
+          "(You need to call ok(), is(), or similar " +
+          "functions at least once.  Make sure you use " +
+          "SimpleTest.waitForExplicitFinish() if you need " +
+          "it.)"
+      );
+    }
+
+    let workers = await SpecialPowers.registeredServiceWorkers();
+    let promise = null;
+    if (SimpleTest._expectingRegisteredServiceWorker) {
+      if (workers.length === 0) {
+        SimpleTest.ok(
+          false,
+          "This test is expected to leave a service worker registered"
+        );
+      }
+    } else if (workers.length) {
+      let FULL_PROFILE_WORKERS_TO_IGNORE = [];
+      if (parentRunner.conditionedProfile) {
+        // Full profile has service workers in the profile, without clearing the profile
+        // service workers will be leftover, in all my testing youtube is the only one.
+        FULL_PROFILE_WORKERS_TO_IGNORE = ["https://www.youtube.com/sw.js"];
+      } else {
+        SimpleTest.ok(
+          false,
+          "This test left a service worker registered without cleaning it up"
+        );
+      }
+
+      for (let worker of workers) {
+        if (FULL_PROFILE_WORKERS_TO_IGNORE.includes(worker.scriptSpec)) {
+          continue;
+        }
+        SimpleTest.ok(
+          false,
+          `Left over worker: ${worker.scriptSpec} (scope: ${worker.scope})`
+        );
+      }
+      promise = SpecialPowers.removeAllServiceWorkerData();
+    }
+
+    // If we want to wait for removeAllServiceWorkerData to finish, above,
+    // there's a small chance that spinning the event loop could cause
+    // SpecialPowers and SimpleTest to go away (e.g. if the test did
+    // document.open). promise being non-null should be rare (a test would
+    // have had to already fail by leaving a service worker around), so
+    // limit the chances of the async wait happening to that case.
+    function finish() {
+      if (parentRunner) {
+        /* We're running in an iframe, and the parent has a TestRunner */
+        parentRunner.testFinished(SimpleTest._tests);
+      }
+
+      if (!parentRunner || parentRunner.showTestReport) {
+        SpecialPowers.flushPermissions(function () {
+          SpecialPowers.flushPrefEnv(function () {
+            SimpleTest.showReport();
+          });
+        });
+      }
+    }
+
+    if (promise) {
+      promise.then(finish);
+    } else {
+      finish();
+    }
+  };
+
+  var executeCleanupFunction = function () {
+    var func = SimpleTest._cleanupFunctions.pop();
+
+    if (!func) {
+      afterCleanup();
+      return;
+    }
+
+    var ret;
+    try {
+      ret = func();
+    } catch (ex) {
+      SimpleTest.ok(false, "Cleanup function threw exception: " + ex);
+    }
+
+    if (ret && ret.constructor.name == "Promise") {
+      ret.then(executeCleanupFunction, ex =>
+        SimpleTest.ok(false, "Cleanup promise rejected: " + ex)
+      );
+    } else {
+      executeCleanupFunction();
+    }
+  };
+
+  executeCleanupFunction();
+
+  SpecialPowers.notifyObservers(null, "test-complete");
+};
+
+/**
+ * Monitor console output from now until endMonitorConsole is called.
+ *
+ * Expect to receive all console messages described by the elements of
+ * ``msgs``, an array, in the order listed in ``msgs``; each element is an
+ * object which may have any number of the following properties:
+ *
+ *   message, errorMessage, sourceName, sourceLine, category: string or regexp
+ *   lineNumber, columnNumber: number
+ *   isScriptError, isWarning: boolean
+ *
+ * Strings, numbers, and booleans must compare equal to the named
+ * property of the Nth console message.  Regexps must match.  Any
+ * fields present in the message but not in the pattern object are ignored.
+ *
+ * In addition to the above properties, elements in ``msgs`` may have a ``forbid``
+ * boolean property.  When ``forbid`` is true, a failure is logged each time a
+ * matching message is received.
+ *
+ * If ``forbidUnexpectedMsgs`` is true, then the messages received in the console
+ * must exactly match the non-forbidden messages in ``msgs``; for each received
+ * message not described by the next element in ``msgs``, a failure is logged.  If
+ * false, then other non-forbidden messages are ignored, but all expected
+ * messages must still be received.
+ *
+ * After endMonitorConsole is called, ``continuation`` will be called
+ * asynchronously.  (Normally, you will want to pass ``SimpleTest.finish`` here.)
+ *
+ * It is incorrect to use this function in a test which has not called
+ * SimpleTest.waitForExplicitFinish.
+ */
+SimpleTest.monitorConsole = function (
+  continuation,
+  msgs,
+  forbidUnexpectedMsgs
+) {
+  if (SimpleTest._stopOnLoad) {
+    ok(false, "Console monitoring requires use of waitForExplicitFinish.");
+  }
+
+  function msgMatches(msg, pat) {
+    for (var k in pat) {
+      if (!(k in msg)) {
+        return false;
+      }
+      if (pat[k] instanceof RegExp && typeof msg[k] === "string") {
+        if (!pat[k].test(msg[k])) {
+          return false;
+        }
+      } else if (msg[k] !== pat[k]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  var forbiddenMsgs = [];
+  var i = 0;
+  while (i < msgs.length) {
+    let pat = msgs[i];
+    if ("forbid" in pat) {
+      var forbid = pat.forbid;
+      delete pat.forbid;
+      if (forbid) {
+        forbiddenMsgs.push(pat);
+        msgs.splice(i, 1);
+        continue;
+      }
+    }
+    i++;
+  }
+
+  var counter = 0;
+  var assertionLabel = JSON.stringify(msgs);
+  function listener(msg) {
+    if (msg.message === "SENTINEL" && !msg.isScriptError) {
+      is(
+        counter,
+        msgs.length,
+        "monitorConsole | number of messages " + assertionLabel
+      );
+      SimpleTest.executeSoon(continuation);
+      return;
+    }
+    for (let pat of forbiddenMsgs) {
+      if (msgMatches(msg, pat)) {
+        ok(
+          false,
+          "monitorConsole | observed forbidden message " + JSON.stringify(msg)
+        );
+        return;
+      }
+    }
+    if (counter >= msgs.length) {
+      var str = "monitorConsole | extra message | " + JSON.stringify(msg);
+      if (forbidUnexpectedMsgs) {
+        ok(false, str);
+      } else {
+        info(str);
+      }
+      return;
+    }
+    var matches = msgMatches(msg, msgs[counter]);
+    if (forbidUnexpectedMsgs) {
+      ok(
+        matches,
+        "monitorConsole | [" + counter + "] must match " + JSON.stringify(msg)
+      );
+    } else {
+      info(
+        "monitorConsole | [" +
+          counter +
+          "] " +
+          (matches ? "matched " : "did not match ") +
+          JSON.stringify(msg)
+      );
+    }
+    if (matches) {
+      counter++;
+    }
+  }
+  SpecialPowers.registerConsoleListener(listener);
+};
+
+/**
+ * Stop monitoring console output.
+ */
+SimpleTest.endMonitorConsole = function () {
+  SpecialPowers.postConsoleSentinel();
+};
+
+/**
+ * Run ``testfn`` synchronously, and monitor its console output.
+ *
+ * ``msgs`` is handled as described above for monitorConsole.
+ *
+ * After ``testfn`` returns, console monitoring will stop, and ``continuation``
+ * will be called asynchronously.
+ *
+ */
+SimpleTest.expectConsoleMessages = function (testfn, msgs, continuation) {
+  SimpleTest.monitorConsole(continuation, msgs);
+  testfn();
+  SimpleTest.executeSoon(SimpleTest.endMonitorConsole);
+};
+
+/**
+ * Wrapper around ``expectConsoleMessages`` for the case where the test has
+ * only one ``testfn`` to run.
+ */
+SimpleTest.runTestExpectingConsoleMessages = function (testfn, msgs) {
+  SimpleTest.waitForExplicitFinish();
+  SimpleTest.expectConsoleMessages(testfn, msgs, SimpleTest.finish);
+};
+
+/**
+ * Indicates to the test framework that the current test expects one or
+ * more crashes (from plugins or IPC documents), and that the minidumps from
+ * those crashes should be removed.
+ */
+SimpleTest.expectChildProcessCrash = function () {
+  if (parentRunner) {
+    parentRunner.expectChildProcessCrash();
+  }
+};
+
+/**
+ * Indicates to the test framework that the next uncaught exception during
+ * the test is expected, and should not cause a test failure.
+ */
+SimpleTest.expectUncaughtException = function (aExpecting) {
+  SimpleTest._expectingUncaughtException =
+    aExpecting === void 0 || !!aExpecting;
+};
+
+/**
+ * Returns whether the test has indicated that it expects an uncaught exception
+ * to occur.
+ */
+SimpleTest.isExpectingUncaughtException = function () {
+  return SimpleTest._expectingUncaughtException;
+};
+
+/**
+ * Indicates to the test framework that all of the uncaught exceptions
+ * during the test are known problems that should be fixed in the future,
+ * but which should not cause the test to fail currently.
+ */
+SimpleTest.ignoreAllUncaughtExceptions = function (aIgnoring) {
+  SimpleTest._ignoringAllUncaughtExceptions =
+    aIgnoring === void 0 || !!aIgnoring;
+};
+
+/**
+ * Returns whether the test has indicated that all uncaught exceptions should be
+ * ignored.
+ */
+SimpleTest.isIgnoringAllUncaughtExceptions = function () {
+  return SimpleTest._ignoringAllUncaughtExceptions;
+};
+
+/**
+ * Indicates to the test framework that this test is expected to leave a
+ * service worker registered when it finishes.
+ */
+SimpleTest.expectRegisteredServiceWorker = function () {
+  SimpleTest._expectingRegisteredServiceWorker = true;
+};
+
+/**
+ * Resets any state this SimpleTest object has.  This is important for
+ * browser chrome mochitests, which reuse the same SimpleTest object
+ * across a run.
+ */
+SimpleTest.reset = function () {
+  SimpleTest._ignoringAllUncaughtExceptions = false;
+  SimpleTest._expectingUncaughtException = false;
+  SimpleTest._expectingRegisteredServiceWorker = false;
+  SimpleTest._bufferedMessages = [];
+};
+
+if (isPrimaryTestWindow) {
+  addLoadEvent(function () {
+    if (SimpleTest._stopOnLoad) {
+      SimpleTest.finish();
+    }
+  });
+}
+
+//  --------------- Test.Builder/Test.More isDeeply() -----------------
+
+SimpleTest.DNE = { dne: "Does not exist" };
+SimpleTest.LF = "\r\n";
+
+SimpleTest._deepCheck = function (e1, e2, stack, seen) {
+  var ok = false;
+  if (Object.is(e1, e2)) {
+    // Handles identical primitives and references.
+    ok = true;
+  } else if (
+    typeof e1 != "object" ||
+    typeof e2 != "object" ||
+    e1 === null ||
+    e2 === null
+  ) {
+    // If either argument is a primitive or function, don't consider the arguments the same.
+    ok = false;
+  } else if (e1 == SimpleTest.DNE || e2 == SimpleTest.DNE) {
+    ok = false;
+  } else if (SimpleTest.isa(e1, "Array") && SimpleTest.isa(e2, "Array")) {
+    ok = SimpleTest._eqArray(e1, e2, stack, seen);
+  } else {
+    ok = SimpleTest._eqAssoc(e1, e2, stack, seen);
+  }
+  return ok;
+};
+
+SimpleTest._eqArray = function (a1, a2, stack, seen) {
+  // Return if they're the same object.
+  if (a1 == a2) {
+    return true;
+  }
+
+  // JavaScript objects have no unique identifiers, so we have to store
+  // references to them all in an array, and then compare the references
+  // directly. It's slow, but probably won't be much of an issue in
+  // practice. Start by making a local copy of the array to as to avoid
+  // confusing a reference seen more than once (such as [a, a]) for a
+  // circular reference.
+  for (var j = 0; j < seen.length; j++) {
+    if (seen[j][0] == a1) {
+      return seen[j][1] == a2;
+    }
+  }
+
+  // If we get here, we haven't seen a1 before, so store it with reference
+  // to a2.
+  seen.push([a1, a2]);
+
+  var ok = true;
+  // Only examines enumerable attributes. Only works for numeric arrays!
+  // Associative arrays return 0. So call _eqAssoc() for them, instead.
+  var max = Math.max(a1.length, a2.length);
+  if (max == 0) {
+    return SimpleTest._eqAssoc(a1, a2, stack, seen);
+  }
+  for (var i = 0; i < max; i++) {
+    var e1 = i < a1.length ? a1[i] : SimpleTest.DNE;
+    var e2 = i < a2.length ? a2[i] : SimpleTest.DNE;
+    stack.push({ type: "Array", idx: i, vals: [e1, e2] });
+    ok = SimpleTest._deepCheck(e1, e2, stack, seen);
+    if (ok) {
+      stack.pop();
+    } else {
+      break;
+    }
+  }
+  return ok;
+};
+
+SimpleTest._eqAssoc = function (o1, o2, stack, seen) {
+  // Return if they're the same object.
+  if (o1 == o2) {
+    return true;
+  }
+
+  // JavaScript objects have no unique identifiers, so we have to store
+  // references to them all in an array, and then compare the references
+  // directly. It's slow, but probably won't be much of an issue in
+  // practice. Start by making a local copy of the array to as to avoid
+  // confusing a reference seen more than once (such as [a, a]) for a
+  // circular reference.
+  seen = seen.slice(0);
+  for (let j = 0; j < seen.length; j++) {
+    if (seen[j][0] == o1) {
+      return seen[j][1] == o2;
+    }
+  }
+
+  // If we get here, we haven't seen o1 before, so store it with reference
+  // to o2.
+  seen.push([o1, o2]);
+
+  // They should be of the same class.
+
+  var ok = true;
+  // Only examines enumerable attributes.
+  var o1Size = 0;
+  // eslint-disable-next-line no-unused-vars
+  for (let i in o1) {
+    o1Size++;
+  }
+  var o2Size = 0;
+  // eslint-disable-next-line no-unused-vars
+  for (let i in o2) {
+    o2Size++;
+  }
+  var bigger = o1Size > o2Size ? o1 : o2;
+  for (let i in bigger) {
+    var e1 = i in o1 ? o1[i] : SimpleTest.DNE;
+    var e2 = i in o2 ? o2[i] : SimpleTest.DNE;
+    stack.push({ type: "Object", idx: i, vals: [e1, e2] });
+    ok = SimpleTest._deepCheck(e1, e2, stack, seen);
+    if (ok) {
+      stack.pop();
+    } else {
+      break;
+    }
+  }
+  return ok;
+};
+
+SimpleTest._formatStack = function (stack) {
+  var variable = "$Foo";
+  for (let i = 0; i < stack.length; i++) {
+    var entry = stack[i];
+    var type = entry.type;
+    var idx = entry.idx;
+    if (idx != null) {
+      if (type == "Array") {
+        // Numeric array index.
+        variable += "[" + idx + "]";
+      } else {
+        // Associative array index.
+        idx = idx.replace("'", "\\'");
+        variable += "['" + idx + "']";
+      }
+    }
+  }
+
+  var vals = stack[stack.length - 1].vals.slice(0, 2);
+  var vars = [
+    variable.replace("$Foo", "got"),
+    variable.replace("$Foo", "expected"),
+  ];
+
+  var out = "Structures begin differing at:" + SimpleTest.LF;
+  for (let i = 0; i < vals.length; i++) {
+    var val = vals[i];
+    if (val === SimpleTest.DNE) {
+      val = "Does not exist";
+    } else {
+      val = repr(val);
+    }
+    out += vars[i] + " = " + val + SimpleTest.LF;
+  }
+
+  return "    " + out;
+};
+
+SimpleTest.isDeeply = function (it, as, name) {
+  var stack = [{ vals: [it, as] }];
+  var seen = [];
+  if (SimpleTest._deepCheck(it, as, stack, seen)) {
+    SimpleTest.record(true, name);
+  } else {
+    SimpleTest.record(false, name, SimpleTest._formatStack(stack));
+  }
+};
+
+SimpleTest.typeOf = function (object) {
+  var c = Object.prototype.toString.apply(object);
+  var name = c.substring(8, c.length - 1);
+  if (name != "Object") {
+    return name;
+  }
+  // It may be a non-core class. Try to extract the class name from
+  // the constructor function. This may not work in all implementations.
+  if (/function ([^(\s]+)/.test(Function.toString.call(object.constructor))) {
+    return RegExp.$1;
+  }
+  // No idea. :-(
+  return name;
+};
+
+SimpleTest.isa = function (object, clas) {
+  return SimpleTest.typeOf(object) == clas;
+};
+
+// Global symbols:
+var ok = SimpleTest.ok;
+var record = SimpleTest.record;
+var is = SimpleTest.is;
+var isfuzzy = SimpleTest.isfuzzy;
+var isnot = SimpleTest.isnot;
+var todo = SimpleTest.todo;
+var todo_is = SimpleTest.todo_is;
+var todo_isnot = SimpleTest.todo_isnot;
+var isDeeply = SimpleTest.isDeeply;
+var info = SimpleTest.info;
+
+var gOldOnError = window.onerror;
+window.onerror = function simpletestOnerror(
+  errorMsg,
+  url,
+  lineNumber,
+  columnNumber,
+  originalException
+) {
+  // Log the message.
+  // XXX Chrome mochitests sometimes trigger this window.onerror handler,
+  // but there are a number of uncaught JS exceptions from those tests.
+  // For now, for tests that self identify as having unintentional uncaught
+  // exceptions, just dump it so that the error is visible but doesn't cause
+  // a test failure.  See bug 652494.
+  var isExpected = !!SimpleTest._expectingUncaughtException;
+  var message = (isExpected ? "expected " : "") + "uncaught exception";
+  var error = errorMsg + " at ";
+  try {
+    error += originalException.stack;
+  } catch (e) {
+    // At least use the url+line+column we were given
+    error += url + ":" + lineNumber + ":" + columnNumber;
+  }
+  if (!SimpleTest._ignoringAllUncaughtExceptions) {
+    // Don't log if SimpleTest.finish() is already called, it would cause failures
+    if (!SimpleTest._alreadyFinished) {
+      SimpleTest.record(isExpected, message, error);
+    }
+    SimpleTest._expectingUncaughtException = false;
+  } else {
+    SimpleTest.todo(false, message + ": " + error);
+  }
+  // There is no Components.stack.caller to log. (See bug 511888.)
+
+  // Call previous handler.
+  if (gOldOnError) {
+    try {
+      // Ignore return value: always run default handler.
+      gOldOnError(errorMsg, url, lineNumber);
+    } catch (e) {
+      // Log the error.
+      SimpleTest.info("Exception thrown by gOldOnError(): " + e);
+      // Log its stack.
+      if (e.stack) {
+        SimpleTest.info("JavaScript error stack:\n" + e.stack);
+      }
+    }
+  }
+
+  if (!SimpleTest._stopOnLoad && !isExpected && !SimpleTest._alreadyFinished) {
+    // Need to finish() manually here, yet let the test actually end first.
+    SimpleTest.executeSoon(SimpleTest.finish);
+  }
+};
+
+// Lifted from dom/media/test/manifest.js
+// Make sure to not touch navigator in here, since we want to push prefs that
+// will affect the APIs it exposes, but the set of exposed APIs is determined
+// when Navigator.prototype is created.  So if we touch navigator before pushing
+// the prefs, the APIs it exposes will not take those prefs into account.  We
+// work around this by using a navigator object from a different global for our
+// UA string testing.
+var gAndroidSdk = null;
+function getAndroidSdk() {
+  if (gAndroidSdk === null) {
+    var iframe = document.documentElement.appendChild(
+      document.createElement("iframe")
+    );
+    iframe.style.display = "none";
+    var nav = iframe.contentWindow.navigator;
+    if (
+      !nav.userAgent.includes("Mobile") &&
+      !nav.userAgent.includes("Tablet")
+    ) {
+      gAndroidSdk = -1;
+    } else {
+      // See nsSystemInfo.cpp, the getProperty('version') returns different value
+      // on each platforms, so we need to distinguish the android platform.
+      var versionString = nav.userAgent.includes("Android")
+        ? "version"
+        : "sdk_version";
+      gAndroidSdk = SpecialPowers.Services.sysinfo.getProperty(versionString);
+    }
+    document.documentElement.removeChild(iframe);
+  }
+  return gAndroidSdk;
+}
+
+// add_task(generatorFunction):
+// Call `add_task(generatorFunction)` for each separate
+// asynchronous task in a mochitest. Tasks are run consecutively.
+// Before the first task, `SimpleTest.waitForExplicitFinish()`
+// will be called automatically, and after the last task,
+// `SimpleTest.finish()` will be called.
+var add_task = (function () {
+  // The list of tasks to run.
+  var task_list = [];
+  var run_only_this_task = null;
+
+  function isGenerator(value) {
+    return (
+      value && typeof value === "object" && typeof value.next === "function"
+    );
+  }
+
+  // The "add_task" function
+  return function (generatorFunction, options = { isSetup: false }) {
+    if (task_list.length === 0) {
+      // This is the first time add_task has been called.
+      // First, confirm that SimpleTest is available.
+      if (!SimpleTest) {
+        throw new Error("SimpleTest not available.");
+      }
+      // Don't stop tests until asynchronous tasks are finished.
+      SimpleTest.waitForExplicitFinish();
+      // Because the client is using add_task for this set of tests,
+      // we need to spawn a "master task" that calls each task in succesion.
+      // Use setTimeout to ensure the master task runs after the client
+      // script finishes.
+      setTimeout(function nextTick() {
+        // If we are in a HTML document, we should wait for the document
+        // to be fully loaded.
+        // These checks ensure that we are in an HTML document without
+        // throwing TypeError; also I am told that readyState in XUL documents
+        // are totally bogus so we don't try to do this there.
+        if (
+          typeof window !== "undefined" &&
+          typeof HTMLDocument !== "undefined" &&
+          window.document instanceof HTMLDocument &&
+          window.document.readyState !== "complete"
+        ) {
+          setTimeout(nextTick);
+          return;
+        }
+
+        (async () => {
+          // 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.
+          function skipTask(name) {
+            let logger = parentRunner && parentRunner.structuredLogger;
+            if (!logger) {
+              info("add_task | Skipping test " + name);
+              return;
+            }
+            logger.deactivateBuffering();
+            logger.testStatus(SimpleTest._getCurrentTestURL(), name, "SKIP");
+            logger.warning("add_task | Skipping test " + name);
+            logger.activateBuffering();
+          }
+
+          // We stop the entire test file at the first exception because this
+          // may mean that the state of subsequent tests may be corrupt.
+          try {
+            for (var task of task_list) {
+              var name = task.name || "";
+              if (
+                task.__skipMe ||
+                (run_only_this_task && task != run_only_this_task)
+              ) {
+                skipTask(name);
+                continue;
+              }
+              const taskInfo = action =>
+                info(
+                  `${
+                    task.isSetup ? "add_setup" : "add_task"
+                  } | ${action} ${name}`
+                );
+              taskInfo("Entering");
+              let result = await task();
+              if (isGenerator(result)) {
+                ok(false, "Task returned a generator");
+              }
+              taskInfo("Leaving");
+            }
+          } catch (ex) {
+            try {
+              let serializedEx;
+              if (
+                typeof ex == "string" ||
+                (typeof ex == "object" && isErrorOrException(ex))
+              ) {
+                serializedEx = `${ex}`;
+              } else {
+                serializedEx = JSON.stringify(ex);
+              }
+
+              SimpleTest.record(
+                false,
+                serializedEx,
+                "Should not throw any errors",
+                ex.stack
+              );
+            } catch (ex2) {
+              SimpleTest.record(
+                false,
+                "(The exception cannot be converted to string.)",
+                "Should not throw any errors",
+                ex.stack
+              );
+            }
+          }
+          // All tasks are finished.
+          SimpleTest.finish();
+        })();
+      });
+    }
+    generatorFunction.skip = () => (generatorFunction.__skipMe = true);
+    generatorFunction.only = () => (run_only_this_task = generatorFunction);
+    // Add the task to the list of tasks to run after
+    // the main thread is finished.
+    if (options.isSetup) {
+      generatorFunction.isSetup = true;
+      let lastSetupIndex = task_list.findLastIndex(t => t.isSetup) + 1;
+      task_list.splice(lastSetupIndex, 0, generatorFunction);
+    } else {
+      task_list.push(generatorFunction);
+    }
+    return generatorFunction;
+  };
+})();
+
+// Like add_task, but setup tasks are executed first.
+function add_setup(generatorFunction) {
+  return add_task(generatorFunction, { isSetup: true });
+}
+
+// Request complete log when using failure patterns so that failure info
+// from infra can be useful.
+if (usesFailurePatterns()) {
+  SimpleTest.requestCompleteLog();
+}
+
+addEventListener("message", async event => {
+  if (event.data == "SimpleTest:timeout") {
+    await SimpleTest.timeout();
+    SimpleTest.finish();
+  }
+});