Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

1 files changed, 2226 insertions, 0 deletions

diff --git a/testing/xpcshell/runxpcshelltests.py b/testing/xpcshell/runxpcshelltests.py
new file mode 100755
index 0000000000..8ef8aed65f
--- /dev/null
+++ b/testing/xpcshell/runxpcshelltests.py
@@ -0,0 +1,2226 @@
+#!/usr/bin/env python
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import copy
+import json
+import os
+import pipes
+import random
+import re
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import traceback
+from argparse import Namespace
+from collections import defaultdict, deque, namedtuple
+from contextlib import contextmanager
+from datetime import datetime, timedelta
+from functools import partial
+from multiprocessing import cpu_count
+from subprocess import PIPE, STDOUT, Popen
+from tempfile import gettempdir, mkdtemp
+from threading import Event, Thread, Timer, current_thread
+
+import mozdebug
+import six
+from mozserve import Http3Server
+
+try:
+    import psutil
+
+    HAVE_PSUTIL = True
+except Exception:
+    HAVE_PSUTIL = False
+
+from xpcshellcommandline import parser_desktop
+
+SCRIPT_DIR = os.path.abspath(os.path.realpath(os.path.dirname(__file__)))
+
+try:
+    from mozbuild.base import MozbuildObject
+
+    build = MozbuildObject.from_environment(cwd=SCRIPT_DIR)
+except ImportError:
+    build = None
+
+HARNESS_TIMEOUT = 5 * 60
+TBPL_RETRY = 4  # defined in mozharness
+
+# benchmarking on tbpl revealed that this works best for now
+# TODO: This has been evaluated/set many years ago and we might want to
+# benchmark this again.
+# These days with e10s/fission the number of real processes/threads running
+# can be significantly higher, with both consequences on runtime and memory
+# consumption. So be aware that NUM_THREADS is just saying how many tests will
+# be started maximum in parallel and that depending on the tests there is
+# only a weak correlation to the effective number of processes or threads.
+# Be also aware that we can override this value with the threadCount option
+# on the command line to tweak it for a concrete CPU/memory combination.
+NUM_THREADS = int(cpu_count() * 4)
+if sys.platform == "win32":
+    NUM_THREADS = NUM_THREADS / 2
+
+EXPECTED_LOG_ACTIONS = set(
+    [
+        "test_status",
+        "log",
+    ]
+)
+
+# --------------------------------------------------------------
+# TODO: this is a hack for mozbase without virtualenv, remove with bug 849900
+#
+here = os.path.dirname(__file__)
+mozbase = os.path.realpath(os.path.join(os.path.dirname(here), "mozbase"))
+
+if os.path.isdir(mozbase):
+    for package in os.listdir(mozbase):
+        sys.path.append(os.path.join(mozbase, package))
+
+import mozcrash
+import mozfile
+import mozinfo
+from manifestparser import TestManifest
+from manifestparser.filters import chunk_by_slice, failures, pathprefix, tags
+from manifestparser.util import normsep
+from mozlog import commandline
+from mozprofile import Profile
+from mozprofile.cli import parse_preferences
+from mozrunner.utils import get_stack_fixer_function
+
+# --------------------------------------------------------------
+
+# TODO: perhaps this should be in a more generally shared location?
+# This regex matches all of the C0 and C1 control characters
+# (U+0000 through U+001F; U+007F; U+0080 through U+009F),
+# except TAB (U+0009), CR (U+000D), LF (U+000A) and backslash (U+005C).
+# A raw string is deliberately not used.
+_cleanup_encoding_re = re.compile("[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f\\\\]")
+
+
+def _cleanup_encoding_repl(m):
+    c = m.group(0)
+    return "\\\\" if c == "\\" else "\\x{0:02X}".format(ord(c))
+
+
+def cleanup_encoding(s):
+    """S is either a byte or unicode string.  Either way it may
+    contain control characters, unpaired surrogates, reserved code
+    points, etc.  If it is a byte string, it is assumed to be
+    UTF-8, but it may not be *correct* UTF-8.  Return a
+    sanitized unicode object."""
+    if not isinstance(s, six.string_types):
+        if isinstance(s, six.binary_type):
+            return six.ensure_str(s)
+        else:
+            return six.text_type(s)
+    if isinstance(s, six.binary_type):
+        s = s.decode("utf-8", "replace")
+    # Replace all C0 and C1 control characters with \xNN escapes.
+    return _cleanup_encoding_re.sub(_cleanup_encoding_repl, s)
+
+
+@contextmanager
+def popenCleanupHack():
+    """
+    Hack to work around https://bugs.python.org/issue37380
+    The basic idea is that on old versions of Python on Windows,
+    we need to clear subprocess._cleanup before we call Popen(),
+    then restore it afterwards.
+    """
+    savedCleanup = None
+    if mozinfo.isWin and sys.version_info[0] == 3 and sys.version_info < (3, 7, 5):
+        savedCleanup = subprocess._cleanup
+        subprocess._cleanup = lambda: None
+    try:
+        yield
+    finally:
+        if savedCleanup:
+            subprocess._cleanup = savedCleanup
+
+
+""" Control-C handling """
+gotSIGINT = False
+
+
+def markGotSIGINT(signum, stackFrame):
+    global gotSIGINT
+    gotSIGINT = True
+
+
+class XPCShellTestThread(Thread):
+    def __init__(
+        self, test_object, retry=True, verbose=False, usingTSan=False, **kwargs
+    ):
+        Thread.__init__(self)
+        self.daemon = True
+
+        self.test_object = test_object
+        self.retry = retry
+        self.verbose = verbose
+        self.usingTSan = usingTSan
+
+        self.appPath = kwargs.get("appPath")
+        self.xrePath = kwargs.get("xrePath")
+        self.utility_path = kwargs.get("utility_path")
+        self.testingModulesDir = kwargs.get("testingModulesDir")
+        self.debuggerInfo = kwargs.get("debuggerInfo")
+        self.jsDebuggerInfo = kwargs.get("jsDebuggerInfo")
+        self.httpdJSPath = kwargs.get("httpdJSPath")
+        self.headJSPath = kwargs.get("headJSPath")
+        self.testharnessdir = kwargs.get("testharnessdir")
+        self.profileName = kwargs.get("profileName")
+        self.singleFile = kwargs.get("singleFile")
+        self.env = copy.deepcopy(kwargs.get("env"))
+        self.symbolsPath = kwargs.get("symbolsPath")
+        self.logfiles = kwargs.get("logfiles")
+        self.app_binary = kwargs.get("app_binary")
+        self.xpcshell = kwargs.get("xpcshell")
+        self.xpcsRunArgs = kwargs.get("xpcsRunArgs")
+        self.failureManifest = kwargs.get("failureManifest")
+        self.jscovdir = kwargs.get("jscovdir")
+        self.stack_fixer_function = kwargs.get("stack_fixer_function")
+        self._rootTempDir = kwargs.get("tempDir")
+        self.cleanup_dir_list = kwargs.get("cleanup_dir_list")
+        self.pStdout = kwargs.get("pStdout")
+        self.pStderr = kwargs.get("pStderr")
+        self.keep_going = kwargs.get("keep_going")
+        self.log = kwargs.get("log")
+        self.app_dir_key = kwargs.get("app_dir_key")
+        self.interactive = kwargs.get("interactive")
+        self.rootPrefsFile = kwargs.get("rootPrefsFile")
+        self.extraPrefs = kwargs.get("extraPrefs")
+        self.verboseIfFails = kwargs.get("verboseIfFails")
+        self.headless = kwargs.get("headless")
+        self.runFailures = kwargs.get("runFailures")
+        self.timeoutAsPass = kwargs.get("timeoutAsPass")
+        self.crashAsPass = kwargs.get("crashAsPass")
+        self.conditionedProfileDir = kwargs.get("conditionedProfileDir")
+        if self.runFailures:
+            self.retry = False
+
+        # Default the test prefsFile to the rootPrefsFile.
+        self.prefsFile = self.rootPrefsFile
+
+        # only one of these will be set to 1. adding them to the totals in
+        # the harness
+        self.passCount = 0
+        self.todoCount = 0
+        self.failCount = 0
+
+        # Context for output processing
+        self.output_lines = []
+        self.has_failure_output = False
+        self.saw_proc_start = False
+        self.saw_proc_end = False
+        self.command = None
+        self.harness_timeout = kwargs.get("harness_timeout")
+        self.timedout = False
+        self.infra = False
+
+        # event from main thread to signal work done
+        self.event = kwargs.get("event")
+        self.done = False  # explicitly set flag so we don't rely on thread.isAlive
+
+    def run(self):
+        try:
+            self.run_test()
+        except PermissionError as e:
+            self.infra = True
+            self.exception = e
+            self.traceback = traceback.format_exc()
+        except Exception as e:
+            self.exception = e
+            self.traceback = traceback.format_exc()
+        else:
+            self.exception = None
+            self.traceback = None
+        if self.retry:
+            self.log.info(
+                "%s failed or timed out, will retry." % self.test_object["id"]
+            )
+        self.done = True
+        self.event.set()
+
+    def kill(self, proc):
+        """
+        Simple wrapper to kill a process.
+        On a remote system, this is overloaded to handle remote process communication.
+        """
+        return proc.kill()
+
+    def removeDir(self, dirname):
+        """
+        Simple wrapper to remove (recursively) a given directory.
+        On a remote system, we need to overload this to work on the remote filesystem.
+        """
+        mozfile.remove(dirname)
+
+    def poll(self, proc):
+        """
+        Simple wrapper to check if a process has terminated.
+        On a remote system, this is overloaded to handle remote process communication.
+        """
+        return proc.poll()
+
+    def createLogFile(self, test_file, stdout):
+        """
+        For a given test file and stdout buffer, create a log file.
+        On a remote system we have to fix the test name since it can contain directories.
+        """
+        with open(test_file + ".log", "w") as f:
+            f.write(stdout)
+
+    def getReturnCode(self, proc):
+        """
+        Simple wrapper to get the return code for a given process.
+        On a remote system we overload this to work with the remote process management.
+        """
+        if proc is not None and hasattr(proc, "returncode"):
+            return proc.returncode
+        return -1
+
+    def communicate(self, proc):
+        """
+        Simple wrapper to communicate with a process.
+        On a remote system, this is overloaded to handle remote process communication.
+        """
+        # Processing of incremental output put here to
+        # sidestep issues on remote platforms, where what we know
+        # as proc is a file pulled off of a device.
+        if proc.stdout:
+            while True:
+                line = proc.stdout.readline()
+                if not line:
+                    break
+                self.process_line(line)
+
+            if self.saw_proc_start and not self.saw_proc_end:
+                self.has_failure_output = True
+
+        return proc.communicate()
+
+    def launchProcess(
+        self, cmd, stdout, stderr, env, cwd, timeout=None, test_name=None
+    ):
+        """
+        Simple wrapper to launch a process.
+        On a remote system, this is more complex and we need to overload this function.
+        """
+        # timeout is needed by remote xpcshell to extend the
+        # remote device timeout. It is not used in this function.
+        if six.PY3:
+            cwd = six.ensure_str(cwd)
+            for i in range(len(cmd)):
+                cmd[i] = six.ensure_str(cmd[i])
+
+        if HAVE_PSUTIL:
+            popen_func = psutil.Popen
+        else:
+            popen_func = Popen
+
+        with popenCleanupHack():
+            proc = popen_func(cmd, stdout=stdout, stderr=stderr, env=env, cwd=cwd)
+
+        return proc
+
+    def checkForCrashes(self, dump_directory, symbols_path, test_name=None):
+        """
+        Simple wrapper to check for crashes.
+        On a remote system, this is more complex and we need to overload this function.
+        """
+        quiet = False
+        if self.crashAsPass:
+            quiet = True
+
+        return mozcrash.log_crashes(
+            self.log, dump_directory, symbols_path, test=test_name, quiet=quiet
+        )
+
+    def logCommand(self, name, completeCmd, testdir):
+        self.log.info("%s | full command: %r" % (name, completeCmd))
+        self.log.info("%s | current directory: %r" % (name, testdir))
+        # Show only those environment variables that are changed from
+        # the ambient environment.
+        changedEnv = set("%s=%s" % i for i in six.iteritems(self.env)) - set(
+            "%s=%s" % i for i in six.iteritems(os.environ)
+        )
+        self.log.info("%s | environment: %s" % (name, list(changedEnv)))
+        shell_command_tokens = [
+            pipes.quote(tok) for tok in list(changedEnv) + completeCmd
+        ]
+        self.log.info(
+            "%s | as shell command: (cd %s; %s)"
+            % (name, pipes.quote(testdir), " ".join(shell_command_tokens))
+        )
+
+    def killTimeout(self, proc):
+        if proc is not None and hasattr(proc, "pid"):
+            mozcrash.kill_and_get_minidump(
+                proc.pid, self.tempDir, utility_path=self.utility_path
+            )
+        else:
+            self.log.info("not killing -- proc or pid unknown")
+
+    def postCheck(self, proc):
+        """Checks for a still-running test process, kills it and fails the test if found.
+        We can sometimes get here before the process has terminated, which would
+        cause removeDir() to fail - so check for the process and kill it if needed.
+        """
+        if proc and self.poll(proc) is None:
+            if HAVE_PSUTIL:
+                try:
+                    self.kill(proc)
+                except psutil.NoSuchProcess:
+                    pass
+            else:
+                self.kill(proc)
+            message = "%s | Process still running after test!" % self.test_object["id"]
+            if self.retry:
+                self.log.info(message)
+                return
+
+            self.log.error(message)
+            self.log_full_output()
+            self.failCount = 1
+
+    def testTimeout(self, proc):
+        if self.test_object["expected"] == "pass":
+            expected = "PASS"
+        else:
+            expected = "FAIL"
+
+        if self.retry:
+            self.log.test_end(
+                self.test_object["id"],
+                "TIMEOUT",
+                expected="TIMEOUT",
+                message="Test timed out",
+            )
+        else:
+            result = "TIMEOUT"
+            if self.timeoutAsPass:
+                expected = "FAIL"
+                result = "FAIL"
+            self.failCount = 1
+            self.log.test_end(
+                self.test_object["id"],
+                result,
+                expected=expected,
+                message="Test timed out",
+            )
+            self.log_full_output()
+
+        self.done = True
+        self.timedout = True
+        self.killTimeout(proc)
+        self.log.info("xpcshell return code: %s" % self.getReturnCode(proc))
+        self.postCheck(proc)
+        self.clean_temp_dirs(self.test_object["path"])
+
+    def updateTestPrefsFile(self):
+        # If the Manifest file has some additional prefs, merge the
+        # prefs set in the user.js file stored in the _rootTempdir
+        # with the prefs from the manifest and the prefs specified
+        # in the extraPrefs option.
+        if "prefs" in self.test_object:
+            # Merge the user preferences in a fake profile dir in a
+            # local temporary dir (self.tempDir is the remoteTmpDir
+            # for the RemoteXPCShellTestThread subclass and so we
+            # can't use that tempDir here).
+            localTempDir = mkdtemp(prefix="xpc-other-", dir=self._rootTempDir)
+
+            filename = "user.js"
+            interpolation = {"server": "dummyserver"}
+            profile = Profile(profile=localTempDir, restore=False)
+            # _rootTempDir contains a user.js file, generated by buildPrefsFile
+            profile.merge(self._rootTempDir, interpolation=interpolation)
+
+            prefs = self.test_object["prefs"].strip().split()
+            name = self.test_object["id"]
+            if self.verbose:
+                self.log.info(
+                    "%s: Per-test extra prefs will be set:\n  {}".format(
+                        "\n  ".join(prefs)
+                    )
+                    % name
+                )
+
+            profile.set_preferences(parse_preferences(prefs), filename=filename)
+            # Make sure that the extra prefs form the command line are overriding
+            # any prefs inherited from the shared profile data or the manifest prefs.
+            profile.set_preferences(
+                parse_preferences(self.extraPrefs), filename=filename
+            )
+            return os.path.join(profile.profile, filename)
+
+        # Return the root prefsFile if there is no other prefs to merge.
+        # This is the path set by buildPrefsFile.
+        return self.rootPrefsFile
+
+    @property
+    def conditioned_profile_copy(self):
+        """Returns a copy of the original conditioned profile that was created."""
+
+        condprof_copy = os.path.join(tempfile.mkdtemp(), "profile")
+        shutil.copytree(
+            self.conditionedProfileDir,
+            condprof_copy,
+            ignore=shutil.ignore_patterns("lock"),
+        )
+        self.log.info("Created a conditioned-profile copy: %s" % condprof_copy)
+        return condprof_copy
+
+    def buildCmdTestFile(self, name):
+        """
+        Build the command line arguments for the test file.
+        On a remote system, this may be overloaded to use a remote path structure.
+        """
+        return ["-e", 'const _TEST_FILE = ["%s"];' % name.replace("\\", "/")]
+
+    def setupTempDir(self):
+        tempDir = mkdtemp(prefix="xpc-other-", dir=self._rootTempDir)
+        self.env["XPCSHELL_TEST_TEMP_DIR"] = tempDir
+        if self.interactive:
+            self.log.info("temp dir is %s" % tempDir)
+        return tempDir
+
+    def setupProfileDir(self):
+        """
+        Create a temporary folder for the profile and set appropriate environment variables.
+        When running check-interactive and check-one, the directory is well-defined and
+        retained for inspection once the tests complete.
+
+        On a remote system, this may be overloaded to use a remote path structure.
+        """
+        if self.conditionedProfileDir:
+            profileDir = self.conditioned_profile_copy
+        elif self.interactive or self.singleFile:
+            profileDir = os.path.join(gettempdir(), self.profileName, "xpcshellprofile")
+            try:
+                # This could be left over from previous runs
+                self.removeDir(profileDir)
+            except Exception:
+                pass
+            os.makedirs(profileDir)
+        else:
+            profileDir = mkdtemp(prefix="xpc-profile-", dir=self._rootTempDir)
+        self.env["XPCSHELL_TEST_PROFILE_DIR"] = profileDir
+        if self.interactive or self.singleFile:
+            self.log.info("profile dir is %s" % profileDir)
+        return profileDir
+
+    def setupMozinfoJS(self):
+        mozInfoJSPath = os.path.join(self.profileDir, "mozinfo.json")
+        mozInfoJSPath = mozInfoJSPath.replace("\\", "\\\\")
+        mozinfo.output_to_file(mozInfoJSPath)
+        return mozInfoJSPath
+
+    def buildCmdHead(self):
+        """
+        Build the command line arguments for the head files,
+        along with the address of the webserver which some tests require.
+
+        On a remote system, this is overloaded to resolve quoting issues over a
+        secondary command line.
+        """
+        headfiles = self.getHeadFiles(self.test_object)
+        cmdH = ", ".join(['"' + f.replace("\\", "/") + '"' for f in headfiles])
+
+        dbgport = 0 if self.jsDebuggerInfo is None else self.jsDebuggerInfo.port
+
+        return [
+            "-e",
+            "const _HEAD_FILES = [%s];" % cmdH,
+            "-e",
+            "const _JSDEBUGGER_PORT = %d;" % dbgport,
+        ]
+
+    def getHeadFiles(self, test):
+        """Obtain lists of head- files.  Returns a list of head files."""
+
+        def sanitize_list(s, kind):
+            for f in s.strip().split(" "):
+                f = f.strip()
+                if len(f) < 1:
+                    continue
+
+                path = os.path.normpath(os.path.join(test["here"], f))
+                if not os.path.exists(path):
+                    raise Exception("%s file does not exist: %s" % (kind, path))
+
+                if not os.path.isfile(path):
+                    raise Exception("%s file is not a file: %s" % (kind, path))
+
+                yield path
+
+        headlist = test.get("head", "")
+        return list(sanitize_list(headlist, "head"))
+
+    def buildXpcsCmd(self):
+        """
+        Load the root head.js file as the first file in our test path, before other head,
+        and test files. On a remote system, we overload this to add additional command
+        line arguments, so this gets overloaded.
+        """
+        # - NOTE: if you rename/add any of the constants set here, update
+        #   do_load_child_test_harness() in head.js
+        if not self.appPath:
+            self.appPath = self.xrePath
+
+        if self.app_binary:
+            xpcsCmd = [
+                self.app_binary,
+                "--xpcshell",
+            ]
+        else:
+            xpcsCmd = [
+                self.xpcshell,
+            ]
+
+        xpcsCmd += [
+            "-g",
+            self.xrePath,
+            "-a",
+            self.appPath,
+            "-m",
+            "-e",
+            'const _HEAD_JS_PATH = "%s";' % self.headJSPath,
+            "-e",
+            'const _MOZINFO_JS_PATH = "%s";' % self.mozInfoJSPath,
+            "-e",
+            'const _PREFS_FILE = "%s";' % self.prefsFile.replace("\\", "\\\\"),
+        ]
+
+        if self.testingModulesDir:
+            # Escape backslashes in string literal.
+            sanitized = self.testingModulesDir.replace("\\", "\\\\")
+            xpcsCmd.extend(["-e", 'const _TESTING_MODULES_DIR = "%s";' % sanitized])
+
+        xpcsCmd.extend(["-f", os.path.join(self.testharnessdir, "head.js")])
+
+        if self.debuggerInfo:
+            xpcsCmd = [self.debuggerInfo.path] + self.debuggerInfo.args + xpcsCmd
+
+        return xpcsCmd
+
+    def cleanupDir(self, directory, name):
+        if not os.path.exists(directory):
+            return
+
+        # up to TRY_LIMIT attempts (one every second), because
+        # the Windows filesystem is slow to react to the changes
+        TRY_LIMIT = 25
+        try_count = 0
+        while try_count < TRY_LIMIT:
+            try:
+                self.removeDir(directory)
+            except OSError:
+                self.log.info("Failed to remove directory: %s. Waiting." % directory)
+                # We suspect the filesystem may still be making changes. Wait a
+                # little bit and try again.
+                time.sleep(1)
+                try_count += 1
+            else:
+                # removed fine
+                return
+
+        # we try cleaning up again later at the end of the run
+        self.cleanup_dir_list.append(directory)
+
+    def clean_temp_dirs(self, name):
+        # We don't want to delete the profile when running check-interactive
+        # or check-one.
+        if self.profileDir and not self.interactive and not self.singleFile:
+            self.cleanupDir(self.profileDir, name)
+
+        self.cleanupDir(self.tempDir, name)
+
+    def parse_output(self, output):
+        """Parses process output for structured messages and saves output as it is
+        read. Sets self.has_failure_output in case of evidence of a failure"""
+        for line_string in output.splitlines():
+            self.process_line(line_string)
+
+        if self.saw_proc_start and not self.saw_proc_end:
+            self.has_failure_output = True
+
+    def fix_text_output(self, line):
+        line = cleanup_encoding(line)
+        if self.stack_fixer_function is not None:
+            line = self.stack_fixer_function(line)
+
+        if isinstance(line, bytes):
+            line = line.decode("utf-8")
+        return line
+
+    def log_line(self, line):
+        """Log a line of output (either a parser json object or text output from
+        the test process"""
+        if isinstance(line, six.string_types) or isinstance(line, bytes):
+            line = self.fix_text_output(line).rstrip("\r\n")
+            self.log.process_output(self.proc_ident, line, command=self.command)
+        else:
+            if "message" in line:
+                line["message"] = self.fix_text_output(line["message"])
+            if "xpcshell_process" in line:
+                line["thread"] = " ".join(
+                    [current_thread().name, line["xpcshell_process"]]
+                )
+            else:
+                line["thread"] = current_thread().name
+            self.log.log_raw(line)
+
+    def log_full_output(self):
+        """Logs any buffered output from the test process, and clears the buffer."""
+        if not self.output_lines:
+            return
+        self.log.info(">>>>>>>")
+        for line in self.output_lines:
+            self.log_line(line)
+        self.log.info("<<<<<<<")
+        self.output_lines = []
+
+    def report_message(self, message):
+        """Stores or logs a json log message in mozlog format."""
+        if self.verbose:
+            self.log_line(message)
+        else:
+            self.output_lines.append(message)
+
+    def process_line(self, line_string):
+        """Parses a single line of output, determining its significance and
+        reporting a message.
+        """
+        if isinstance(line_string, bytes):
+            # Transform binary to string representation
+            line_string = line_string.decode(sys.stdout.encoding, errors="replace")
+
+        if not line_string.strip():
+            return
+
+        try:
+            line_object = json.loads(line_string)
+            if not isinstance(line_object, dict):
+                self.report_message(line_string)
+                return
+        except ValueError:
+            self.report_message(line_string)
+            return
+
+        if (
+            "action" not in line_object
+            or line_object["action"] not in EXPECTED_LOG_ACTIONS
+        ):
+            # The test process output JSON.
+            self.report_message(line_string)
+            return
+
+        action = line_object["action"]
+
+        self.has_failure_output = (
+            self.has_failure_output
+            or "expected" in line_object
+            or action == "log"
+            and line_object["level"] == "ERROR"
+        )
+
+        self.report_message(line_object)
+
+        if action == "log" and line_object["message"] == "CHILD-TEST-STARTED":
+            self.saw_proc_start = True
+        elif action == "log" and line_object["message"] == "CHILD-TEST-COMPLETED":
+            self.saw_proc_end = True
+
+    def run_test(self):
+        """Run an individual xpcshell test."""
+        global gotSIGINT
+
+        name = self.test_object["id"]
+        path = self.test_object["path"]
+
+        # Check for skipped tests
+        if "disabled" in self.test_object:
+            message = self.test_object["disabled"]
+            if not message:
+                message = "disabled from xpcshell manifest"
+            self.log.test_start(name)
+            self.log.test_end(name, "SKIP", message=message)
+
+            self.retry = False
+            self.keep_going = True
+            return
+
+        # Check for known-fail tests
+        expect_pass = self.test_object["expected"] == "pass"
+
+        # By default self.appPath will equal the gre dir. If specified in the
+        # xpcshell.ini file, set a different app dir for this test.
+        if self.app_dir_key and self.app_dir_key in self.test_object:
+            rel_app_dir = self.test_object[self.app_dir_key]
+            rel_app_dir = os.path.join(self.xrePath, rel_app_dir)
+            self.appPath = os.path.abspath(rel_app_dir)
+        else:
+            self.appPath = None
+
+        test_dir = os.path.dirname(path)
+
+        # Create a profile and a temp dir that the JS harness can stick
+        # a profile and temporary data in
+        self.profileDir = self.setupProfileDir()
+        self.tempDir = self.setupTempDir()
+        self.mozInfoJSPath = self.setupMozinfoJS()
+
+        # Setup per-manifest prefs and write them into the tempdir.
+        self.prefsFile = self.updateTestPrefsFile()
+
+        # The order of the command line is important:
+        # 1) Arguments for xpcshell itself
+        self.command = self.buildXpcsCmd()
+
+        # 2) Arguments for the head files
+        self.command.extend(self.buildCmdHead())
+
+        # 3) Arguments for the test file
+        self.command.extend(self.buildCmdTestFile(path))
+        self.command.extend(["-e", 'const _TEST_NAME = "%s";' % name])
+
+        # 4) Arguments for code coverage
+        if self.jscovdir:
+            self.command.extend(
+                ["-e", 'const _JSCOV_DIR = "%s";' % self.jscovdir.replace("\\", "/")]
+            )
+
+        # 5) Runtime arguments
+        if "debug" in self.test_object:
+            self.command.append("-d")
+
+        self.command.extend(self.xpcsRunArgs)
+
+        if self.test_object.get("dmd") == "true":
+            self.env["PYTHON"] = sys.executable
+            self.env["BREAKPAD_SYMBOLS_PATH"] = self.symbolsPath
+
+        if self.test_object.get("snap") == "true":
+            self.env["SNAP_NAME"] = "firefox"
+            self.env["SNAP_INSTANCE_NAME"] = "firefox"
+
+        if self.test_object.get("subprocess") == "true":
+            self.env["PYTHON"] = sys.executable
+
+        if (
+            self.test_object.get("headless", "true" if self.headless else None)
+            == "true"
+        ):
+            self.env["MOZ_HEADLESS"] = "1"
+            self.env["DISPLAY"] = "77"  # Set a fake display.
+
+        testTimeoutInterval = self.harness_timeout
+        # Allow a test to request a multiple of the timeout if it is expected to take long
+        if "requesttimeoutfactor" in self.test_object:
+            testTimeoutInterval *= int(self.test_object["requesttimeoutfactor"])
+
+        testTimer = None
+        if not self.interactive and not self.debuggerInfo and not self.jsDebuggerInfo:
+            testTimer = Timer(testTimeoutInterval, lambda: self.testTimeout(proc))
+            testTimer.start()
+
+        proc = None
+        process_output = None
+
+        try:
+            self.log.test_start(name)
+            if self.verbose:
+                self.logCommand(name, self.command, test_dir)
+
+            proc = self.launchProcess(
+                self.command,
+                stdout=self.pStdout,
+                stderr=self.pStderr,
+                env=self.env,
+                cwd=test_dir,
+                timeout=testTimeoutInterval,
+                test_name=name,
+            )
+
+            if hasattr(proc, "pid"):
+                self.proc_ident = proc.pid
+            else:
+                # On mobile, "proc" is just a file.
+                self.proc_ident = name
+
+            if self.interactive:
+                self.log.info("%s | Process ID: %d" % (name, self.proc_ident))
+
+            # Communicate returns a tuple of (stdout, stderr), however we always
+            # redirect stderr to stdout, so the second element is ignored.
+            process_output, _ = self.communicate(proc)
+
+            if self.interactive:
+                # Not sure what else to do here...
+                self.keep_going = True
+                return
+
+            if testTimer:
+                testTimer.cancel()
+
+            if process_output:
+                # For the remote case, stdout is not yet depleted, so we parse
+                # it here all at once.
+                self.parse_output(process_output)
+
+            return_code = self.getReturnCode(proc)
+
+            # TSan'd processes return 66 if races are detected.  This isn't
+            # good in the sense that there's no way to distinguish between
+            # a process that would normally have returned zero but has races,
+            # and a race-free process that returns 66.  But I don't see how
+            # to do better.  This ambiguity is at least constrained to the
+            # with-TSan case.  It doesn't affect normal builds.
+            #
+            # This also assumes that the magic value 66 isn't overridden by
+            # a TSAN_OPTIONS=exitcode=<number> environment variable setting.
+            #
+            TSAN_EXIT_CODE_WITH_RACES = 66
+
+            return_code_ok = return_code == 0 or (
+                self.usingTSan and return_code == TSAN_EXIT_CODE_WITH_RACES
+            )
+            passed = (not self.has_failure_output) and return_code_ok
+
+            status = "PASS" if passed else "FAIL"
+            expected = "PASS" if expect_pass else "FAIL"
+            message = "xpcshell return code: %d" % return_code
+
+            if self.timedout:
+                return
+
+            if status != expected:
+                if self.retry:
+                    self.log.test_end(
+                        name,
+                        status,
+                        expected=status,
+                        message="Test failed or timed out, will retry",
+                    )
+                    self.clean_temp_dirs(path)
+                    if self.verboseIfFails and not self.verbose:
+                        self.log_full_output()
+                    return
+
+                self.log.test_end(name, status, expected=expected, message=message)
+                self.log_full_output()
+
+                self.failCount += 1
+
+                if self.failureManifest:
+                    with open(self.failureManifest, "a") as f:
+                        f.write("[%s]\n" % self.test_object["path"])
+                        for k, v in self.test_object.items():
+                            f.write("%s = %s\n" % (k, v))
+
+            else:
+                # If TSan reports a race, dump the output, else we can't
+                # diagnose what the problem was.  See comments above about
+                # the significance of TSAN_EXIT_CODE_WITH_RACES.
+                if self.usingTSan and return_code == TSAN_EXIT_CODE_WITH_RACES:
+                    self.log_full_output()
+
+                self.log.test_end(name, status, expected=expected, message=message)
+                if self.verbose:
+                    self.log_full_output()
+
+                self.retry = False
+
+                if expect_pass:
+                    self.passCount = 1
+                else:
+                    self.todoCount = 1
+
+            if self.checkForCrashes(self.tempDir, self.symbolsPath, test_name=name):
+                if self.retry:
+                    self.clean_temp_dirs(path)
+                    return
+
+                # If we assert during shutdown there's a chance the test has passed
+                # but we haven't logged full output, so do so here.
+                self.log_full_output()
+                self.failCount = 1
+
+            if self.logfiles and process_output:
+                self.createLogFile(name, process_output)
+
+        finally:
+            self.postCheck(proc)
+            self.clean_temp_dirs(path)
+
+        if gotSIGINT:
+            self.log.error("Received SIGINT (control-C) during test execution")
+            if self.keep_going:
+                gotSIGINT = False
+            else:
+                self.keep_going = False
+                return
+
+        self.keep_going = True
+
+
+class XPCShellTests(object):
+    def __init__(self, log=None):
+        """Initializes node status and logger."""
+        self.log = log
+        self.harness_timeout = HARNESS_TIMEOUT
+        self.nodeProc = {}
+        self.http3Server = None
+        self.conditioned_profile_dir = None
+
+    def getTestManifest(self, manifest):
+        if isinstance(manifest, TestManifest):
+            return manifest
+        elif manifest is not None:
+            manifest = os.path.normpath(os.path.abspath(manifest))
+            if os.path.isfile(manifest):
+                return TestManifest([manifest], strict=True)
+            else:
+                ini_path = os.path.join(manifest, "xpcshell.ini")
+        else:
+            ini_path = os.path.join(SCRIPT_DIR, "tests", "xpcshell.ini")
+
+        if os.path.exists(ini_path):
+            return TestManifest([ini_path], strict=True)
+        else:
+            self.log.error(
+                "Failed to find manifest at %s; use --manifest "
+                "to set path explicitly." % ini_path
+            )
+            sys.exit(1)
+
+    def normalizeTest(self, root, test_object):
+        path = test_object.get("file_relpath", test_object["relpath"])
+        if "dupe-manifest" in test_object and "ancestor_manifest" in test_object:
+            test_object["id"] = "%s:%s" % (
+                os.path.basename(test_object["ancestor_manifest"]),
+                path,
+            )
+        else:
+            test_object["id"] = path
+
+        if root:
+            test_object["manifest"] = os.path.relpath(test_object["manifest"], root)
+
+        if os.sep != "/":
+            for key in ("id", "manifest"):
+                test_object[key] = test_object[key].replace(os.sep, "/")
+
+        return test_object
+
+    def buildTestList(self, test_tags=None, test_paths=None, verify=False):
+        """Reads the xpcshell.ini manifest and set self.alltests to an array.
+
+        Given the parameters, this method compiles a list of tests to be run
+        that matches the criteria set by parameters.
+
+        If any chunking of tests are to occur, it is also done in this method.
+
+        If no tests are added to the list of tests to be run, an error
+        is logged. A sys.exit() signal is sent to the caller.
+
+        Args:
+            test_tags (list, optional): list of strings.
+            test_paths (list, optional): list of strings derived from the command
+                                         line argument provided by user, specifying
+                                         tests to be run.
+            verify (bool, optional): boolean value.
+        """
+        if test_paths is None:
+            test_paths = []
+
+        mp = self.getTestManifest(self.manifest)
+
+        root = mp.rootdir
+        if build and not root:
+            root = build.topsrcdir
+        normalize = partial(self.normalizeTest, root)
+
+        filters = []
+        if test_tags:
+            filters.append(tags(test_tags))
+
+        path_filter = None
+        if test_paths:
+            path_filter = pathprefix(test_paths)
+            filters.append(path_filter)
+
+        noDefaultFilters = False
+        if self.runFailures:
+            filters.append(failures(self.runFailures))
+            noDefaultFilters = True
+
+        if self.totalChunks > 1:
+            filters.append(chunk_by_slice(self.thisChunk, self.totalChunks))
+        try:
+            self.alltests = list(
+                map(
+                    normalize,
+                    mp.active_tests(
+                        filters=filters,
+                        noDefaultFilters=noDefaultFilters,
+                        **mozinfo.info,
+                    ),
+                )
+            )
+        except TypeError:
+            sys.stderr.write("*** offending mozinfo.info: %s\n" % repr(mozinfo.info))
+            raise
+
+        if path_filter and path_filter.missing:
+            self.log.warning(
+                "The following path(s) didn't resolve any tests:\n  {}".format(
+                    "  \n".join(sorted(path_filter.missing))
+                )
+            )
+
+        if len(self.alltests) == 0:
+            if (
+                test_paths
+                and path_filter.missing == set(test_paths)
+                and os.environ.get("MOZ_AUTOMATION") == "1"
+            ):
+                # This can happen in CI when a manifest doesn't exist due to a
+                # build config variable in moz.build traversal. Don't generate
+                # an error in this case. Adding a todo count avoids mozharness
+                # raising an error.
+                self.todoCount += len(path_filter.missing)
+            else:
+                self.log.error(
+                    "no tests to run using specified "
+                    "combination of filters: {}".format(mp.fmt_filters())
+                )
+                sys.exit(1)
+
+        if len(self.alltests) == 1 and not verify:
+            self.singleFile = os.path.basename(self.alltests[0]["path"])
+        else:
+            self.singleFile = None
+
+        if self.dump_tests:
+            self.dump_tests = os.path.expanduser(self.dump_tests)
+            assert os.path.exists(os.path.dirname(self.dump_tests))
+            with open(self.dump_tests, "w") as dumpFile:
+                dumpFile.write(json.dumps({"active_tests": self.alltests}))
+
+            self.log.info("Dumping active_tests to %s file." % self.dump_tests)
+            sys.exit()
+
+    def setAbsPath(self):
+        """
+        Set the absolute path for xpcshell, httpdjspath and xrepath. These 3 variables
+        depend on input from the command line and we need to allow for absolute paths.
+        This function is overloaded for a remote solution as os.path* won't work remotely.
+        """
+        self.testharnessdir = os.path.dirname(os.path.abspath(__file__))
+        self.headJSPath = self.testharnessdir.replace("\\", "/") + "/head.js"
+        if self.xpcshell is not None:
+            self.xpcshell = os.path.abspath(self.xpcshell)
+
+        if self.app_binary is not None:
+            self.app_binary = os.path.abspath(self.app_binary)
+
+        if self.xrePath is None:
+            binary_path = self.app_binary or self.xpcshell
+            self.xrePath = os.path.dirname(binary_path)
+            if mozinfo.isMac:
+                # Check if we're run from an OSX app bundle and override
+                # self.xrePath if we are.
+                appBundlePath = os.path.join(
+                    os.path.dirname(os.path.dirname(self.xpcshell)), "Resources"
+                )
+                if os.path.exists(os.path.join(appBundlePath, "application.ini")):
+                    self.xrePath = appBundlePath
+        else:
+            self.xrePath = os.path.abspath(self.xrePath)
+
+        # httpd.js belongs in xrePath/components, which is Contents/Resources on mac
+        self.httpdJSPath = os.path.join(self.xrePath, "components", "httpd.js")
+        self.httpdJSPath = self.httpdJSPath.replace("\\", "/")
+
+        if self.mozInfo is None:
+            self.mozInfo = os.path.join(self.testharnessdir, "mozinfo.json")
+
+    def buildPrefsFile(self, extraPrefs):
+        # Create the prefs.js file
+
+        # In test packages used in CI, the profile_data directory is installed
+        # in the SCRIPT_DIR.
+        profile_data_dir = os.path.join(SCRIPT_DIR, "profile_data")
+        # If possible, read profile data from topsrcdir. This prevents us from
+        # requiring a re-build to pick up newly added extensions in the
+        # <profile>/extensions directory.
+        if build:
+            path = os.path.join(build.topsrcdir, "testing", "profiles")
+            if os.path.isdir(path):
+                profile_data_dir = path
+        # Still not found? Look for testing/profiles relative to testing/xpcshell.
+        if not os.path.isdir(profile_data_dir):
+            path = os.path.abspath(os.path.join(SCRIPT_DIR, "..", "profiles"))
+            if os.path.isdir(path):
+                profile_data_dir = path
+
+        with open(os.path.join(profile_data_dir, "profiles.json"), "r") as fh:
+            base_profiles = json.load(fh)["xpcshell"]
+
+        # values to use when interpolating preferences
+        interpolation = {
+            "server": "dummyserver",
+        }
+
+        profile = Profile(profile=self.tempDir, restore=False)
+        prefsFile = os.path.join(profile.profile, "user.js")
+
+        # Empty the user.js file in case the file existed before.
+        with open(prefsFile, "w"):
+            pass
+
+        for name in base_profiles:
+            path = os.path.join(profile_data_dir, name)
+            profile.merge(path, interpolation=interpolation)
+
+        # add command line prefs
+        prefs = parse_preferences(extraPrefs)
+        profile.set_preferences(prefs)
+
+        self.prefsFile = prefsFile
+        return prefs
+
+    def buildCoreEnvironment(self):
+        """
+        Add environment variables likely to be used across all platforms, including
+        remote systems.
+        """
+        # Make assertions fatal
+        self.env["XPCOM_DEBUG_BREAK"] = "stack-and-abort"
+        # Crash reporting interferes with debugging
+        if not self.debuggerInfo:
+            self.env["MOZ_CRASHREPORTER"] = "1"
+        # Don't launch the crash reporter client
+        self.env["MOZ_CRASHREPORTER_NO_REPORT"] = "1"
+        # Don't permit remote connections by default.
+        # MOZ_DISABLE_NONLOCAL_CONNECTIONS can be set to "0" to temporarily
+        # enable non-local connections for the purposes of local testing.
+        # Don't override the user's choice here.  See bug 1049688.
+        self.env.setdefault("MOZ_DISABLE_NONLOCAL_CONNECTIONS", "1")
+        if self.mozInfo.get("topsrcdir") is not None:
+            self.env["MOZ_DEVELOPER_REPO_DIR"] = self.mozInfo["topsrcdir"]
+        if self.mozInfo.get("topobjdir") is not None:
+            self.env["MOZ_DEVELOPER_OBJ_DIR"] = self.mozInfo["topobjdir"]
+
+        # Disable the content process sandbox for the xpcshell tests. They
+        # currently attempt to do things like bind() sockets, which is not
+        # compatible with the sandbox.
+        self.env["MOZ_DISABLE_CONTENT_SANDBOX"] = "1"
+        if os.getenv("MOZ_FETCHES_DIR", None):
+            self.env["MOZ_FETCHES_DIR"] = os.getenv("MOZ_FETCHES_DIR", None)
+
+        if self.mozInfo.get("socketprocess_networking"):
+            self.env["MOZ_FORCE_USE_SOCKET_PROCESS"] = "1"
+        else:
+            self.env["MOZ_DISABLE_SOCKET_PROCESS"] = "1"
+
+    def buildEnvironment(self):
+        """
+        Create and returns a dictionary of self.env to include all the appropriate env
+        variables and values. On a remote system, we overload this to set different
+        values and are missing things like os.environ and PATH.
+        """
+        self.env = dict(os.environ)
+        self.buildCoreEnvironment()
+        if sys.platform == "win32":
+            self.env["PATH"] = self.env["PATH"] + ";" + self.xrePath
+        elif sys.platform in ("os2emx", "os2knix"):
+            os.environ["BEGINLIBPATH"] = self.xrePath + ";" + self.env["BEGINLIBPATH"]
+            os.environ["LIBPATHSTRICT"] = "T"
+        elif sys.platform == "osx" or sys.platform == "darwin":
+            self.env["DYLD_LIBRARY_PATH"] = os.path.join(
+                os.path.dirname(self.xrePath), "MacOS"
+            )
+        else:  # unix or linux?
+            if "LD_LIBRARY_PATH" not in self.env or self.env["LD_LIBRARY_PATH"] is None:
+                self.env["LD_LIBRARY_PATH"] = self.xrePath
+            else:
+                self.env["LD_LIBRARY_PATH"] = ":".join(
+                    [self.xrePath, self.env["LD_LIBRARY_PATH"]]
+                )
+
+        usingASan = "asan" in self.mozInfo and self.mozInfo["asan"]
+        usingTSan = "tsan" in self.mozInfo and self.mozInfo["tsan"]
+        if usingASan or usingTSan:
+            # symbolizer support
+            if "ASAN_SYMBOLIZER_PATH" in self.env and os.path.isfile(
+                self.env["ASAN_SYMBOLIZER_PATH"]
+            ):
+                llvmsym = self.env["ASAN_SYMBOLIZER_PATH"]
+            else:
+                llvmsym = os.path.join(
+                    self.xrePath, "llvm-symbolizer" + self.mozInfo["bin_suffix"]
+                )
+            if os.path.isfile(llvmsym):
+                if usingASan:
+                    self.env["ASAN_SYMBOLIZER_PATH"] = llvmsym
+                else:
+                    oldTSanOptions = self.env.get("TSAN_OPTIONS", "")
+                    self.env["TSAN_OPTIONS"] = "external_symbolizer_path={} {}".format(
+                        llvmsym, oldTSanOptions
+                    )
+                self.log.info("runxpcshelltests.py | using symbolizer at %s" % llvmsym)
+            else:
+                self.log.error(
+                    "TEST-UNEXPECTED-FAIL | runxpcshelltests.py | "
+                    "Failed to find symbolizer at %s" % llvmsym
+                )
+
+        return self.env
+
+    def getPipes(self):
+        """
+        Determine the value of the stdout and stderr for the test.
+        Return value is a list (pStdout, pStderr).
+        """
+        if self.interactive:
+            pStdout = None
+            pStderr = None
+        else:
+            if self.debuggerInfo and self.debuggerInfo.interactive:
+                pStdout = None
+                pStderr = None
+            else:
+                if sys.platform == "os2emx":
+                    pStdout = None
+                else:
+                    pStdout = PIPE
+                pStderr = STDOUT
+        return pStdout, pStderr
+
+    def verifyDirPath(self, dirname):
+        """
+        Simple wrapper to get the absolute path for a given directory name.
+        On a remote system, we need to overload this to work on the remote filesystem.
+        """
+        return os.path.abspath(dirname)
+
+    def trySetupNode(self):
+        """
+        Run node for HTTP/2 tests, if available, and updates mozinfo as appropriate.
+        """
+        if os.getenv("MOZ_ASSUME_NODE_RUNNING", None):
+            self.log.info("Assuming required node servers are already running")
+            if not os.getenv("MOZHTTP2_PORT", None):
+                self.log.warning(
+                    "MOZHTTP2_PORT environment variable not set. "
+                    "Tests requiring http/2 will fail."
+                )
+            return
+
+        # We try to find the node executable in the path given to us by the user in
+        # the MOZ_NODE_PATH environment variable
+        nodeBin = os.getenv("MOZ_NODE_PATH", None)
+        if not nodeBin and build:
+            nodeBin = build.substs.get("NODEJS")
+        if not nodeBin:
+            self.log.warning(
+                "MOZ_NODE_PATH environment variable not set. "
+                "Tests requiring http/2 will fail."
+            )
+            return
+
+        if not os.path.exists(nodeBin) or not os.path.isfile(nodeBin):
+            error = "node not found at MOZ_NODE_PATH %s" % (nodeBin)
+            self.log.error(error)
+            raise IOError(error)
+
+        self.log.info("Found node at %s" % (nodeBin,))
+
+        def startServer(name, serverJs):
+            if not os.path.exists(serverJs):
+                error = "%s not found at %s" % (name, serverJs)
+                self.log.error(error)
+                raise IOError(error)
+
+            # OK, we found our server, let's try to get it running
+            self.log.info("Found %s at %s" % (name, serverJs))
+            try:
+                # We pipe stdin to node because the server will exit when its
+                # stdin reaches EOF
+                with popenCleanupHack():
+                    process = Popen(
+                        [nodeBin, serverJs],
+                        stdin=PIPE,
+                        stdout=PIPE,
+                        stderr=PIPE,
+                        env=self.env,
+                        cwd=os.getcwd(),
+                        universal_newlines=True,
+                    )
+                self.nodeProc[name] = process
+
+                # Check to make sure the server starts properly by waiting for it to
+                # tell us it's started
+                msg = process.stdout.readline()
+                if "server listening" in msg:
+                    searchObj = re.search(
+                        r"HTTP2 server listening on ports ([0-9]+),([0-9]+)", msg, 0
+                    )
+                    if searchObj:
+                        self.env["MOZHTTP2_PORT"] = searchObj.group(1)
+                        self.env["MOZNODE_EXEC_PORT"] = searchObj.group(2)
+            except OSError as e:
+                # This occurs if the subprocess couldn't be started
+                self.log.error("Could not run %s server: %s" % (name, str(e)))
+                raise
+
+        myDir = os.path.split(os.path.abspath(__file__))[0]
+        startServer("moz-http2", os.path.join(myDir, "moz-http2", "moz-http2.js"))
+
+    def shutdownNode(self):
+        """
+        Shut down our node process, if it exists
+        """
+        for name, proc in six.iteritems(self.nodeProc):
+            self.log.info("Node %s server shutting down ..." % name)
+            if proc.poll() is not None:
+                self.log.info("Node server %s already dead %s" % (name, proc.poll()))
+            else:
+                proc.terminate()
+
+            def dumpOutput(fd, label):
+                firstTime = True
+                for msg in fd:
+                    if firstTime:
+                        firstTime = False
+                        self.log.info("Process %s" % label)
+                    self.log.info(msg)
+
+            dumpOutput(proc.stdout, "stdout")
+            dumpOutput(proc.stderr, "stderr")
+        self.nodeProc = {}
+
+    def startHttp3Server(self):
+        """
+        Start a Http3 test server.
+        """
+        binSuffix = ""
+        if sys.platform == "win32":
+            binSuffix = ".exe"
+        http3ServerPath = self.http3ServerPath
+        if not http3ServerPath:
+            http3ServerPath = os.path.join(
+                SCRIPT_DIR, "http3server", "http3server" + binSuffix
+            )
+            if build:
+                http3ServerPath = os.path.join(
+                    build.topobjdir, "dist", "bin", "http3server" + binSuffix
+                )
+        dbPath = os.path.join(SCRIPT_DIR, "http3server", "http3serverDB")
+        if build:
+            dbPath = os.path.join(build.topsrcdir, "netwerk", "test", "http3serverDB")
+        options = {}
+        options["http3ServerPath"] = http3ServerPath
+        options["profilePath"] = dbPath
+        options["isMochitest"] = False
+        options["isWin"] = sys.platform == "win32"
+        self.http3Server = Http3Server(options, self.env, self.log)
+        self.http3Server.start()
+        for key, value in self.http3Server.ports().items():
+            self.env[key] = value
+        self.env["MOZHTTP3_ECH"] = self.http3Server.echConfig()
+
+    def shutdownHttp3Server(self):
+        if self.http3Server is None:
+            return
+        self.http3Server.stop()
+        self.http3Server = None
+
+    def buildXpcsRunArgs(self):
+        """
+        Add arguments to run the test or make it interactive.
+        """
+        if self.interactive:
+            self.xpcsRunArgs = [
+                "-e",
+                'print("To start the test, type |_execute_test();|.");',
+                "-i",
+            ]
+        else:
+            self.xpcsRunArgs = ["-e", "_execute_test(); quit(0);"]
+
+    def addTestResults(self, test):
+        self.passCount += test.passCount
+        self.failCount += test.failCount
+        self.todoCount += test.todoCount
+
+    def updateMozinfo(self, prefs, options):
+        # Handle filenames in mozInfo
+        if not isinstance(self.mozInfo, dict):
+            mozInfoFile = self.mozInfo
+            if not os.path.isfile(mozInfoFile):
+                self.log.error(
+                    "Error: couldn't find mozinfo.json at '%s'. Perhaps you "
+                    "need to use --build-info-json?" % mozInfoFile
+                )
+                return False
+            self.mozInfo = json.load(open(mozInfoFile))
+
+        # mozinfo.info is used as kwargs.  Some builds are done with
+        # an older Python that can't handle Unicode keys in kwargs.
+        # All of the keys in question should be ASCII.
+        fixedInfo = {}
+        for k, v in self.mozInfo.items():
+            if isinstance(k, bytes):
+                k = k.decode("utf-8")
+            fixedInfo[k] = v
+        self.mozInfo = fixedInfo
+
+        self.mozInfo["fission"] = prefs.get("fission.autostart", True)
+        self.mozInfo["sessionHistoryInParent"] = self.mozInfo[
+            "fission"
+        ] or not prefs.get("fission.disableSessionHistoryInParent", False)
+
+        self.mozInfo["serviceworker_e10s"] = True
+
+        self.mozInfo["verify"] = options.get("verify", False)
+
+        self.mozInfo["socketprocess_networking"] = prefs.get(
+            "network.http.network_access_on_socket_process.enabled", False
+        )
+
+        self.mozInfo["condprof"] = options.get("conditionedProfile", False)
+
+        self.mozInfo["msix"] = options.get(
+            "app_binary"
+        ) is not None and "WindowsApps" in options.get("app_binary", "")
+
+        mozinfo.update(self.mozInfo)
+
+        return True
+
+    @property
+    def conditioned_profile_copy(self):
+        """Returns a copy of the original conditioned profile that was created."""
+        condprof_copy = os.path.join(tempfile.mkdtemp(), "profile")
+        shutil.copytree(
+            self.conditioned_profile_dir,
+            condprof_copy,
+            ignore=shutil.ignore_patterns("lock"),
+        )
+        self.log.info("Created a conditioned-profile copy: %s" % condprof_copy)
+        return condprof_copy
+
+    def downloadConditionedProfile(self, profile_scenario, app):
+        from condprof.client import get_profile
+        from condprof.util import get_current_platform, get_version
+
+        if self.conditioned_profile_dir:
+            # We already have a directory, so provide a copy that
+            # will get deleted after it's done with
+            return self.conditioned_profile_dir
+
+        # create a temp file to help ensure uniqueness
+        temp_download_dir = tempfile.mkdtemp()
+        self.log.info(
+            "Making temp_download_dir from inside get_conditioned_profile {}".format(
+                temp_download_dir
+            )
+        )
+        # call condprof's client API to yield our platform-specific
+        # conditioned-profile binary
+        platform = get_current_platform()
+        version = None
+        if isinstance(app, str):
+            version = get_version(app)
+
+        if not profile_scenario:
+            profile_scenario = "settled"
+        try:
+            cond_prof_target_dir = get_profile(
+                temp_download_dir,
+                platform,
+                profile_scenario,
+                repo="mozilla-central",
+                version=version,
+                retries=2,
+            )
+        except Exception:
+            if version is None:
+                # any other error is a showstopper
+                self.log.critical("Could not get the conditioned profile")
+                traceback.print_exc()
+                raise
+            version = None
+            try:
+                self.log.info("Retrying a profile with no version specified")
+                cond_prof_target_dir = get_profile(
+                    temp_download_dir,
+                    platform,
+                    profile_scenario,
+                    repo="mozilla-central",
+                    version=version,
+                )
+            except Exception:
+                self.log.critical("Could not get the conditioned profile")
+                traceback.print_exc()
+                raise
+
+        # now get the full directory path to our fetched conditioned profile
+        self.conditioned_profile_dir = os.path.join(
+            temp_download_dir, cond_prof_target_dir
+        )
+        if not os.path.exists(cond_prof_target_dir):
+            self.log.critical(
+                "Can't find target_dir {}, from get_profile()"
+                "temp_download_dir {}, platform {}, scenario {}".format(
+                    cond_prof_target_dir, temp_download_dir, platform, profile_scenario
+                )
+            )
+            raise OSError
+
+        self.log.info(
+            "Original self.conditioned_profile_dir is now set: {}".format(
+                self.conditioned_profile_dir
+            )
+        )
+        return self.conditioned_profile_copy
+
+    def runSelfTest(self):
+        import unittest
+
+        import selftest
+
+        this = self
+
+        class XPCShellTestsTests(selftest.XPCShellTestsTests):
+            def __init__(self, name):
+                unittest.TestCase.__init__(self, name)
+                self.testing_modules = this.testingModulesDir
+                self.xpcshellBin = this.xpcshell
+                self.app_binary = this.app_binary
+                self.utility_path = this.utility_path
+                self.symbols_path = this.symbolsPath
+
+        old_info = dict(mozinfo.info)
+        try:
+            suite = unittest.TestLoader().loadTestsFromTestCase(XPCShellTestsTests)
+            return unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful()
+        finally:
+            # The self tests modify mozinfo, so we need to reset it.
+            mozinfo.info.clear()
+            mozinfo.update(old_info)
+
+    def runTests(self, options, testClass=XPCShellTestThread, mobileArgs=None):
+        """
+        Run xpcshell tests.
+        """
+        global gotSIGINT
+
+        # Number of times to repeat test(s) in --verify mode
+        VERIFY_REPEAT = 10
+
+        if isinstance(options, Namespace):
+            options = vars(options)
+
+        # Try to guess modules directory.
+        # This somewhat grotesque hack allows the buildbot machines to find the
+        # modules directory without having to configure the buildbot hosts. This
+        # code path should never be executed in local runs because the build system
+        # should always set this argument.
+        if not options.get("testingModulesDir"):
+            possible = os.path.join(here, os.path.pardir, "modules")
+
+            if os.path.isdir(possible):
+                testingModulesDir = possible
+
+        if options.get("rerun_failures"):
+            if os.path.exists(options.get("failure_manifest")):
+                rerun_manifest = os.path.join(
+                    os.path.dirname(options["failure_manifest"]), "rerun.ini"
+                )
+                shutil.copyfile(options["failure_manifest"], rerun_manifest)
+                os.remove(options["failure_manifest"])
+            else:
+                self.log.error("No failures were found to re-run.")
+                sys.exit(1)
+
+        if options.get("testingModulesDir"):
+            # The resource loader expects native paths. Depending on how we were
+            # invoked, a UNIX style path may sneak in on Windows. We try to
+            # normalize that.
+            testingModulesDir = os.path.normpath(options["testingModulesDir"])
+
+            if not os.path.isabs(testingModulesDir):
+                testingModulesDir = os.path.abspath(testingModulesDir)
+
+            if not testingModulesDir.endswith(os.path.sep):
+                testingModulesDir += os.path.sep
+
+        self.debuggerInfo = None
+
+        if options.get("debugger"):
+            self.debuggerInfo = mozdebug.get_debugger_info(
+                options.get("debugger"),
+                options.get("debuggerArgs"),
+                options.get("debuggerInteractive"),
+            )
+
+        self.jsDebuggerInfo = None
+        if options.get("jsDebugger"):
+            # A namedtuple let's us keep .port instead of ['port']
+            JSDebuggerInfo = namedtuple("JSDebuggerInfo", ["port"])
+            self.jsDebuggerInfo = JSDebuggerInfo(port=options["jsDebuggerPort"])
+
+        self.app_binary = options.get("app_binary")
+        self.xpcshell = options.get("xpcshell")
+        self.http3ServerPath = options.get("http3server")
+        self.xrePath = options.get("xrePath")
+        self.utility_path = options.get("utility_path")
+        self.appPath = options.get("appPath")
+        self.symbolsPath = options.get("symbolsPath")
+        self.tempDir = os.path.normpath(options.get("tempDir") or tempfile.gettempdir())
+        self.manifest = options.get("manifest")
+        self.dump_tests = options.get("dump_tests")
+        self.interactive = options.get("interactive")
+        self.verbose = options.get("verbose")
+        self.verboseIfFails = options.get("verboseIfFails")
+        self.keepGoing = options.get("keepGoing")
+        self.logfiles = options.get("logfiles")
+        self.totalChunks = options.get("totalChunks", 1)
+        self.thisChunk = options.get("thisChunk")
+        self.profileName = options.get("profileName") or "xpcshell"
+        self.mozInfo = options.get("mozInfo")
+        self.testingModulesDir = testingModulesDir
+        self.sequential = options.get("sequential")
+        self.failure_manifest = options.get("failure_manifest")
+        self.threadCount = options.get("threadCount") or NUM_THREADS
+        self.jscovdir = options.get("jscovdir")
+        self.headless = options.get("headless")
+        self.runFailures = options.get("runFailures")
+        self.timeoutAsPass = options.get("timeoutAsPass")
+        self.crashAsPass = options.get("crashAsPass")
+        self.conditionedProfile = options.get("conditionedProfile")
+        self.repeat = options.get("repeat")
+
+        self.testCount = 0
+        self.passCount = 0
+        self.failCount = 0
+        self.todoCount = 0
+
+        if self.conditionedProfile:
+            self.conditioned_profile_dir = self.downloadConditionedProfile(
+                "full", self.appPath
+            )
+            options["self_test"] = False
+            if not options["test_tags"]:
+                options["test_tags"] = []
+            options["test_tags"].append("condprof")
+
+        self.setAbsPath()
+
+        eprefs = options.get("extraPrefs") or []
+        # enable fission by default
+        if options.get("disableFission"):
+            eprefs.append("fission.autostart=false")
+        else:
+            # should be by default, just in case
+            eprefs.append("fission.autostart=true")
+
+        prefs = self.buildPrefsFile(eprefs)
+        self.buildXpcsRunArgs()
+
+        self.event = Event()
+
+        if not self.updateMozinfo(prefs, options):
+            return False
+
+        self.log.info(
+            "These variables are available in the mozinfo environment and "
+            "can be used to skip tests conditionally:"
+        )
+        for info in sorted(self.mozInfo.items(), key=lambda item: item[0]):
+            self.log.info("    {key}: {value}".format(key=info[0], value=info[1]))
+
+        if options.get("self_test"):
+            if not self.runSelfTest():
+                return False
+
+        if (
+            ("tsan" in self.mozInfo and self.mozInfo["tsan"])
+            or ("asan" in self.mozInfo and self.mozInfo["asan"])
+        ) and not options.get("threadCount"):
+            # TSan/ASan require significantly more memory, so reduce the amount of parallel
+            # tests we run to avoid OOMs and timeouts. We always keep a minimum of 2 for
+            # non-sequential execution.
+            # pylint --py3k W1619
+            self.threadCount = max(self.threadCount / 2, 2)
+
+        self.stack_fixer_function = None
+        if self.utility_path and os.path.exists(self.utility_path):
+            self.stack_fixer_function = get_stack_fixer_function(
+                self.utility_path, self.symbolsPath
+            )
+
+        # buildEnvironment() needs mozInfo, so we call it after mozInfo is initialized.
+        self.buildEnvironment()
+
+        # The appDirKey is a optional entry in either the default or individual test
+        # sections that defines a relative application directory for test runs. If
+        # defined we pass 'grePath/$appDirKey' for the -a parameter of the xpcshell
+        # test harness.
+        appDirKey = None
+        if "appname" in self.mozInfo:
+            appDirKey = self.mozInfo["appname"] + "-appdir"
+
+        # We have to do this before we run tests that depend on having the node
+        # http/2 server.
+        self.trySetupNode()
+
+        self.startHttp3Server()
+
+        pStdout, pStderr = self.getPipes()
+
+        self.buildTestList(
+            options.get("test_tags"), options.get("testPaths"), options.get("verify")
+        )
+        if self.singleFile:
+            self.sequential = True
+
+        if options.get("shuffle"):
+            random.shuffle(self.alltests)
+
+        self.cleanup_dir_list = []
+
+        kwargs = {
+            "appPath": self.appPath,
+            "xrePath": self.xrePath,
+            "utility_path": self.utility_path,
+            "testingModulesDir": self.testingModulesDir,
+            "debuggerInfo": self.debuggerInfo,
+            "jsDebuggerInfo": self.jsDebuggerInfo,
+            "httpdJSPath": self.httpdJSPath,
+            "headJSPath": self.headJSPath,
+            "tempDir": self.tempDir,
+            "testharnessdir": self.testharnessdir,
+            "profileName": self.profileName,
+            "singleFile": self.singleFile,
+            "env": self.env,  # making a copy of this in the testthreads
+            "symbolsPath": self.symbolsPath,
+            "logfiles": self.logfiles,
+            "app_binary": self.app_binary,
+            "xpcshell": self.xpcshell,
+            "xpcsRunArgs": self.xpcsRunArgs,
+            "failureManifest": self.failure_manifest,
+            "jscovdir": self.jscovdir,
+            "harness_timeout": self.harness_timeout,
+            "stack_fixer_function": self.stack_fixer_function,
+            "event": self.event,
+            "cleanup_dir_list": self.cleanup_dir_list,
+            "pStdout": pStdout,
+            "pStderr": pStderr,
+            "keep_going": self.keepGoing,
+            "log": self.log,
+            "interactive": self.interactive,
+            "app_dir_key": appDirKey,
+            "rootPrefsFile": self.prefsFile,
+            "extraPrefs": options.get("extraPrefs") or [],
+            "verboseIfFails": self.verboseIfFails,
+            "headless": self.headless,
+            "runFailures": self.runFailures,
+            "timeoutAsPass": self.timeoutAsPass,
+            "crashAsPass": self.crashAsPass,
+            "conditionedProfileDir": self.conditioned_profile_dir,
+            "repeat": self.repeat,
+        }
+
+        if self.sequential:
+            # Allow user to kill hung xpcshell subprocess with SIGINT
+            # when we are only running tests sequentially.
+            signal.signal(signal.SIGINT, markGotSIGINT)
+
+        if self.debuggerInfo:
+            # Force a sequential run
+            self.sequential = True
+
+            # If we have an interactive debugger, disable SIGINT entirely.
+            if self.debuggerInfo.interactive:
+                signal.signal(signal.SIGINT, lambda signum, frame: None)
+
+            if "lldb" in self.debuggerInfo.path:
+                # Ask people to start debugging using 'process launch', see bug 952211.
+                self.log.info(
+                    "It appears that you're using LLDB to debug this test.  "
+                    + "Please use the 'process launch' command instead of "
+                    "the 'run' command to start xpcshell."
+                )
+
+        if self.jsDebuggerInfo:
+            # The js debugger magic needs more work to do the right thing
+            # if debugging multiple files.
+            if len(self.alltests) != 1:
+                self.log.error(
+                    "Error: --jsdebugger can only be used with a single test!"
+                )
+                return False
+
+        # The test itself needs to know whether it is a tsan build, since
+        # that has an effect on interpretation of the process return value.
+        usingTSan = "tsan" in self.mozInfo and self.mozInfo["tsan"]
+
+        # create a queue of all tests that will run
+        tests_queue = deque()
+        # also a list for the tests that need to be run sequentially
+        sequential_tests = []
+        status = None
+
+        if options.get("repeat") > 0:
+            self.sequential = True
+
+        if not options.get("verify"):
+            for test_object in self.alltests:
+                # Test identifiers are provided for the convenience of logging. These
+                # start as path names but are rewritten in case tests from the same path
+                # are re-run.
+
+                path = test_object["path"]
+
+                if self.singleFile and not path.endswith(self.singleFile):
+                    continue
+
+                # if we have --repeat, duplicate the tests as needed
+                for i in range(0, options.get("repeat") + 1):
+                    self.testCount += 1
+
+                    test = testClass(
+                        test_object,
+                        verbose=self.verbose or test_object.get("verbose") == "true",
+                        usingTSan=usingTSan,
+                        mobileArgs=mobileArgs,
+                        **kwargs,
+                    )
+                    if "run-sequentially" in test_object or self.sequential:
+                        sequential_tests.append(test)
+                    else:
+                        tests_queue.append(test)
+
+            status = self.runTestList(
+                tests_queue, sequential_tests, testClass, mobileArgs, **kwargs
+            )
+        else:
+            #
+            # Test verification: Run each test many times, in various configurations,
+            # in hopes of finding intermittent failures.
+            #
+
+            def step1():
+                # Run tests sequentially. Parallel mode would also work, except that
+                # the logging system gets confused when 2 or more tests with the same
+                # name run at the same time.
+                sequential_tests = []
+                for i in range(VERIFY_REPEAT):
+                    self.testCount += 1
+                    test = testClass(
+                        test_object, retry=False, mobileArgs=mobileArgs, **kwargs
+                    )
+                    sequential_tests.append(test)
+                status = self.runTestList(
+                    tests_queue, sequential_tests, testClass, mobileArgs, **kwargs
+                )
+                return status
+
+            def step2():
+                # Run tests sequentially, with MOZ_CHAOSMODE enabled.
+                sequential_tests = []
+                self.env["MOZ_CHAOSMODE"] = "0xfb"
+                # chaosmode runs really slow, allow tests extra time to pass
+                self.harness_timeout = self.harness_timeout * 2
+                for i in range(VERIFY_REPEAT):
+                    self.testCount += 1
+                    test = testClass(
+                        test_object, retry=False, mobileArgs=mobileArgs, **kwargs
+                    )
+                    sequential_tests.append(test)
+                status = self.runTestList(
+                    tests_queue, sequential_tests, testClass, mobileArgs, **kwargs
+                )
+                self.harness_timeout = self.harness_timeout / 2
+                return status
+
+            steps = [
+                ("1. Run each test %d times, sequentially." % VERIFY_REPEAT, step1),
+                (
+                    "2. Run each test %d times, sequentially, in chaos mode."
+                    % VERIFY_REPEAT,
+                    step2,
+                ),
+            ]
+            startTime = datetime.now()
+            maxTime = timedelta(seconds=options["verifyMaxTime"])
+            for test_object in self.alltests:
+                stepResults = {}
+                for (descr, step) in steps:
+                    stepResults[descr] = "not run / incomplete"
+                finalResult = "PASSED"
+                for (descr, step) in steps:
+                    if (datetime.now() - startTime) > maxTime:
+                        self.log.info(
+                            "::: Test verification is taking too long: Giving up!"
+                        )
+                        self.log.info(
+                            "::: So far, all checks passed, but not "
+                            "all checks were run."
+                        )
+                        break
+                    self.log.info(":::")
+                    self.log.info('::: Running test verification step "%s"...' % descr)
+                    self.log.info(":::")
+                    status = step()
+                    if status is not True:
+                        stepResults[descr] = "FAIL"
+                        finalResult = "FAILED!"
+                        break
+                    stepResults[descr] = "Pass"
+                self.log.info(":::")
+                self.log.info(
+                    "::: Test verification summary for: %s" % test_object["path"]
+                )
+                self.log.info(":::")
+                for descr in sorted(stepResults.keys()):
+                    self.log.info("::: %s : %s" % (descr, stepResults[descr]))
+                self.log.info(":::")
+                self.log.info("::: Test verification %s" % finalResult)
+                self.log.info(":::")
+
+        self.shutdownNode()
+        self.shutdownHttp3Server()
+
+        return status
+
+    def start_test(self, test):
+        test.start()
+
+    def test_ended(self, test):
+        pass
+
+    def runTestList(
+        self, tests_queue, sequential_tests, testClass, mobileArgs, **kwargs
+    ):
+        if self.sequential:
+            self.log.info("Running tests sequentially.")
+        else:
+            self.log.info("Using at most %d threads." % self.threadCount)
+
+        # keep a set of threadCount running tests and start running the
+        # tests in the queue at most threadCount at a time
+        running_tests = set()
+        keep_going = True
+        infra_abort = False
+        exceptions = []
+        tracebacks = []
+        self.try_again_list = []
+
+        tests_by_manifest = defaultdict(list)
+        for test in self.alltests:
+            group = test["manifest"]
+            if "ancestor_manifest" in test:
+                ancestor_manifest = normsep(test["ancestor_manifest"])
+                # Only change the group id if ancestor is not the generated root manifest.
+                if "/" in ancestor_manifest:
+                    group = "{}:{}".format(ancestor_manifest, group)
+            tests_by_manifest[group].append(test["id"])
+
+        self.log.suite_start(tests_by_manifest, name="xpcshell")
+
+        while tests_queue or running_tests:
+            # if we're not supposed to continue and all of the running tests
+            # are done, stop
+            if not keep_going and not running_tests:
+                break
+
+            # if there's room to run more tests, start running them
+            while (
+                keep_going and tests_queue and (len(running_tests) < self.threadCount)
+            ):
+                test = tests_queue.popleft()
+                running_tests.add(test)
+                self.start_test(test)
+
+            # queue is full (for now) or no more new tests,
+            # process the finished tests so far
+
+            # wait for at least one of the tests to finish
+            self.event.wait(1)
+            self.event.clear()
+
+            # find what tests are done (might be more than 1)
+            done_tests = set()
+            for test in running_tests:
+                if test.done:
+                    self.test_ended(test)
+                    done_tests.add(test)
+                    test.join(
+                        1
+                    )  # join with timeout so we don't hang on blocked threads
+                    # if the test had trouble, we will try running it again
+                    # at the end of the run
+                    if test.retry or test.is_alive():
+                        # if the join call timed out, test.is_alive => True
+                        self.try_again_list.append(test.test_object)
+                        continue
+                    # did the test encounter any exception?
+                    if test.exception:
+                        exceptions.append(test.exception)
+                        tracebacks.append(test.traceback)
+                        # we won't add any more tests, will just wait for
+                        # the currently running ones to finish
+                        keep_going = False
+                    infra_abort = infra_abort and test.infra
+                    keep_going = keep_going and test.keep_going
+                    self.addTestResults(test)
+
+            # make room for new tests to run
+            running_tests.difference_update(done_tests)
+
+        if infra_abort:
+            return TBPL_RETRY  # terminate early
+
+        if keep_going:
+            # run the other tests sequentially
+            for test in sequential_tests:
+                if not keep_going:
+                    self.log.error(
+                        "TEST-UNEXPECTED-FAIL | Received SIGINT (control-C), so "
+                        "stopped run. (Use --keep-going to keep running tests "
+                        "after killing one with SIGINT)"
+                    )
+                    break
+                self.start_test(test)
+                test.join()
+                self.test_ended(test)
+                if (test.failCount > 0 or test.passCount <= 0) and os.environ.get(
+                    "MOZ_AUTOMATION", 0
+                ) != 0:
+                    self.try_again_list.append(test.test_object)
+                    continue
+                self.addTestResults(test)
+                # did the test encounter any exception?
+                if test.exception:
+                    exceptions.append(test.exception)
+                    tracebacks.append(test.traceback)
+                    break
+                keep_going = test.keep_going
+
+        # retry tests that failed when run in parallel
+        if self.try_again_list:
+            self.log.info("Retrying tests that failed when run in parallel.")
+        for test_object in self.try_again_list:
+            test = testClass(
+                test_object,
+                retry=False,
+                verbose=self.verbose,
+                mobileArgs=mobileArgs,
+                **kwargs,
+            )
+            self.start_test(test)
+            test.join()
+            self.test_ended(test)
+            self.addTestResults(test)
+            # did the test encounter any exception?
+            if test.exception:
+                exceptions.append(test.exception)
+                tracebacks.append(test.traceback)
+                break
+            keep_going = test.keep_going
+
+        # restore default SIGINT behaviour
+        signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+        # Clean up any slacker directories that might be lying around
+        # Some might fail because of windows taking too long to unlock them.
+        # We don't do anything if this fails because the test machines will have
+        # their $TEMP dirs cleaned up on reboot anyway.
+        for directory in self.cleanup_dir_list:
+            try:
+                shutil.rmtree(directory)
+            except Exception:
+                self.log.info("%s could not be cleaned up." % directory)
+
+        if exceptions:
+            self.log.info("Following exceptions were raised:")
+            for t in tracebacks:
+                self.log.error(t)
+            raise exceptions[0]
+
+        if self.testCount == 0 and os.environ.get("MOZ_AUTOMATION") != "1":
+            self.log.error("No tests run. Did you pass an invalid --test-path?")
+            self.failCount = 1
+
+        # doing this allows us to pass the mozharness parsers that
+        # report an orange job for failCount>0
+        if self.runFailures:
+            passed = self.passCount
+            self.passCount = self.failCount
+            self.failCount = passed
+
+        self.log.info("INFO | Result summary:")
+        self.log.info("INFO | Passed: %d" % self.passCount)
+        self.log.info("INFO | Failed: %d" % self.failCount)
+        self.log.info("INFO | Todo: %d" % self.todoCount)
+        self.log.info("INFO | Retried: %d" % len(self.try_again_list))
+
+        if gotSIGINT and not keep_going:
+            self.log.error(
+                "TEST-UNEXPECTED-FAIL | Received SIGINT (control-C), so stopped run. "
+                "(Use --keep-going to keep running tests after "
+                "killing one with SIGINT)"
+            )
+            return False
+
+        self.log.suite_end()
+        return self.runFailures or self.failCount == 0
+
+
+def main():
+    parser = parser_desktop()
+    options = parser.parse_args()
+
+    log = commandline.setup_logging("XPCShell", options, {"tbpl": sys.stdout})
+
+    if options.xpcshell is None and options.app_binary is None:
+        log.error(
+            "Must provide path to xpcshell using --xpcshell or Firefox using --app-binary"
+        )
+        sys.exit(1)
+
+    if options.xpcshell is not None and options.app_binary is not None:
+        log.error(
+            "Cannot provide --xpcshell and --app-binary - they are mutually exclusive options. Choose one."
+        )
+        sys.exit(1)
+
+    xpcsh = XPCShellTests(log)
+
+    if options.interactive and not options.testPath:
+        log.error("Error: You must specify a test filename in interactive mode!")
+        sys.exit(1)
+
+    result = xpcsh.runTests(options)
+    if result == TBPL_RETRY:
+        sys.exit(4)
+
+    if not result:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()