Add m-esr52 at 52.6.0

1 files changed, 1060 insertions, 0 deletions

diff --git a/testing/mochitest/mochitest_options.py b/testing/mochitest/mochitest_options.py
new file mode 100644
index 000000000..9e61670a5
--- /dev/null
+++ b/testing/mochitest/mochitest_options.py
@@ -0,0 +1,1060 @@
+# 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/.
+
+from abc import ABCMeta, abstractmethod, abstractproperty
+from argparse import ArgumentParser, SUPPRESS
+from distutils.util import strtobool
+from urlparse import urlparse
+import json
+import os
+import tempfile
+
+from mozdevice import DroidADB, DroidSUT
+from mozprofile import DEFAULT_PORTS
+import mozinfo
+import mozlog
+import moznetwork
+
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+try:
+    from mozbuild.base import (
+        MozbuildObject,
+        MachCommandConditions as conditions,
+    )
+    build_obj = MozbuildObject.from_environment(cwd=here)
+except ImportError:
+    build_obj = None
+    conditions = None
+
+
+def get_default_valgrind_suppression_files():
+    # We are trying to locate files in the source tree.  So if we
+    # don't know where the source tree is, we must give up.
+    #
+    # When this is being run by |mach mochitest --valgrind ...|, it is
+    # expected that |build_obj| is not None, and so the logic below will
+    # select the correct suppression files.
+    #
+    # When this is run from mozharness, |build_obj| is None, and we expect
+    # that testing/mozharness/configs/unittests/linux_unittests.py will
+    # select the correct suppression files (and paths to them) and
+    # will specify them using the --valgrind-supp-files= flag.  Hence this
+    # function will not get called when running from mozharness.
+    #
+    # Note: keep these Valgrind .sup file names consistent with those
+    # in testing/mozharness/configs/unittests/linux_unittest.py.
+    if build_obj is None or build_obj.topsrcdir is None:
+        return []
+
+    supps_path = os.path.join(build_obj.topsrcdir, "build", "valgrind")
+
+    rv = []
+    if mozinfo.os == "linux":
+        if mozinfo.processor == "x86_64":
+            rv.append(os.path.join(supps_path, "x86_64-redhat-linux-gnu.sup"))
+            rv.append(os.path.join(supps_path, "cross-architecture.sup"))
+        elif mozinfo.processor == "x86":
+            rv.append(os.path.join(supps_path, "i386-redhat-linux-gnu.sup"))
+            rv.append(os.path.join(supps_path, "cross-architecture.sup"))
+
+    return rv
+
+
+class ArgumentContainer():
+    __metaclass__ = ABCMeta
+
+    @abstractproperty
+    def args(self):
+        pass
+
+    @abstractproperty
+    def defaults(self):
+        pass
+
+    @abstractmethod
+    def validate(self, parser, args, context):
+        pass
+
+    def get_full_path(self, path, cwd):
+        """Get an absolute path relative to cwd."""
+        return os.path.normpath(os.path.join(cwd, os.path.expanduser(path)))
+
+
+class MochitestArguments(ArgumentContainer):
+    """General mochitest arguments."""
+
+    FLAVORS = ('a11y', 'browser', 'chrome', 'jetpack-addon', 'jetpack-package', 'plain')
+    LOG_LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR", "FATAL")
+
+    args = [
+        [["test_paths"],
+         {"nargs": "*",
+          "metavar": "TEST",
+          "default": [],
+          "help": "Test to run. Can be a single test file or a directory of tests "
+                  "(to run recursively). If omitted, the entire suite is run.",
+          }],
+        [["-f", "--flavor"],
+         {"default": "plain",
+          "choices": FLAVORS,
+          "help": "Mochitest flavor to run, one of {}. Defaults to 'plain'.".format(FLAVORS),
+          "suppress": build_obj is not None,
+          }],
+        [["--keep-open"],
+         {"nargs": "?",
+          "type": strtobool,
+          "const": "true",
+          "default": None,
+          "help": "Always keep the browser open after tests complete. Or always close the "
+                  "browser with --keep-open=false",
+          }],
+        [["--appname"],
+         {"dest": "app",
+          "default": None,
+          "help": "Override the default binary used to run tests with the path provided, e.g "
+                  "/usr/bin/firefox. If you have run ./mach package beforehand, you can "
+                  "specify 'dist' to run tests against the distribution bundle's binary.",
+          }],
+        [["--utility-path"],
+         {"dest": "utilityPath",
+          "default": build_obj.bindir if build_obj is not None else None,
+          "help": "absolute path to directory containing utility programs "
+                  "(xpcshell, ssltunnel, certutil)",
+          "suppress": True,
+          }],
+        [["--certificate-path"],
+         {"dest": "certPath",
+          "default": None,
+          "help": "absolute path to directory containing certificate store to use testing profile",
+          "suppress": True,
+          }],
+        [["--no-autorun"],
+         {"action": "store_false",
+          "dest": "autorun",
+          "default": True,
+          "help": "Do not start running tests automatically.",
+          }],
+        [["--timeout"],
+         {"type": int,
+          "default": None,
+          "help": "The per-test timeout in seconds (default: 60 seconds).",
+          }],
+        [["--max-timeouts"],
+         {"type": int,
+          "dest": "maxTimeouts",
+          "default": None,
+          "help": "The maximum number of timeouts permitted before halting testing.",
+          }],
+        [["--total-chunks"],
+         {"type": int,
+          "dest": "totalChunks",
+          "help": "Total number of chunks to split tests into.",
+          "default": None,
+          }],
+        [["--this-chunk"],
+         {"type": int,
+          "dest": "thisChunk",
+          "help": "If running tests by chunks, the chunk number to run.",
+          "default": None,
+          }],
+        [["--chunk-by-runtime"],
+         {"action": "store_true",
+          "dest": "chunkByRuntime",
+          "help": "Group tests such that each chunk has roughly the same runtime.",
+          "default": False,
+          }],
+        [["--chunk-by-dir"],
+         {"type": int,
+          "dest": "chunkByDir",
+          "help": "Group tests together in the same chunk that are in the same top "
+                  "chunkByDir directories.",
+          "default": 0,
+          }],
+        [["--run-by-dir"],
+         {"action": "store_true",
+          "dest": "runByDir",
+          "help": "Run each directory in a single browser instance with a fresh profile.",
+          "default": False,
+          }],
+        [["--shuffle"],
+         {"action": "store_true",
+          "help": "Shuffle execution order of tests.",
+          "default": False,
+          }],
+        [["--console-level"],
+         {"dest": "consoleLevel",
+          "choices": LOG_LEVELS,
+          "default": "INFO",
+          "help": "One of {} to determine the level of console logging.".format(
+                  ', '.join(LOG_LEVELS)),
+          "suppress": True,
+          }],
+        [["--bisect-chunk"],
+         {"dest": "bisectChunk",
+          "default": None,
+          "help": "Specify the failing test name to find the previous tests that may be "
+                  "causing the failure.",
+          }],
+        [["--start-at"],
+         {"dest": "startAt",
+          "default": "",
+          "help": "Start running the test sequence at this test.",
+          }],
+        [["--end-at"],
+         {"dest": "endAt",
+          "default": "",
+          "help": "Stop running the test sequence at this test.",
+          }],
+        [["--subsuite"],
+         {"default": None,
+          "help": "Subsuite of tests to run. Unlike tags, subsuites also remove tests from "
+                  "the default set. Only one can be specified at once.",
+          }],
+        [["--setenv"],
+         {"action": "append",
+          "dest": "environment",
+          "metavar": "NAME=VALUE",
+          "default": [],
+          "help": "Sets the given variable in the application's environment.",
+          }],
+        [["--exclude-extension"],
+         {"action": "append",
+          "dest": "extensionsToExclude",
+          "default": [],
+          "help": "Excludes the given extension from being installed in the test profile.",
+          "suppress": True,
+          }],
+        [["--browser-arg"],
+         {"action": "append",
+          "dest": "browserArgs",
+          "default": [],
+          "help": "Provides an argument to the test application (e.g Firefox).",
+          "suppress": True,
+          }],
+        [["--leak-threshold"],
+         {"type": int,
+          "dest": "defaultLeakThreshold",
+          "default": 0,
+          "help": "Fail if the number of bytes leaked in default processes through "
+                  "refcounted objects (or bytes in classes with MOZ_COUNT_CTOR and "
+                  "MOZ_COUNT_DTOR) is greater than the given number.",
+          "suppress": True,
+          }],
+        [["--fatal-assertions"],
+         {"action": "store_true",
+          "dest": "fatalAssertions",
+          "default": False,
+          "help": "Abort testing whenever an assertion is hit (requires a debug build to "
+                  "be effective).",
+          "suppress": True,
+          }],
+        [["--extra-profile-file"],
+         {"action": "append",
+          "dest": "extraProfileFiles",
+          "default": [],
+          "help": "Copy specified files/dirs to testing profile. Can be specified more "
+                  "than once.",
+          "suppress": True,
+          }],
+        [["--install-extension"],
+         {"action": "append",
+          "dest": "extensionsToInstall",
+          "default": [],
+          "help": "Install the specified extension in the testing profile. Can be a path "
+                  "to a .xpi file.",
+          }],
+        [["--profile-path"],
+         {"dest": "profilePath",
+          "default": None,
+          "help": "Directory where the profile will be stored. This directory will be "
+                  "deleted after the tests are finished.",
+          "suppress": True,
+          }],
+        [["--testing-modules-dir"],
+         {"dest": "testingModulesDir",
+          "default": None,
+          "help": "Directory where testing-only JS modules are located.",
+          "suppress": True,
+          }],
+        [["--repeat"],
+         {"type": int,
+          "default": 0,
+          "help": "Repeat the tests the given number of times.",
+          }],
+        [["--run-until-failure"],
+         {"action": "store_true",
+          "dest": "runUntilFailure",
+          "default": False,
+          "help": "Run tests repeatedly but stop the first time a test fails. Default cap "
+                  "is 30 runs, which can be overridden with the --repeat parameter.",
+          }],
+        [["--manifest"],
+         {"dest": "manifestFile",
+          "default": None,
+          "help": "Path to a manifestparser (.ini formatted) manifest of tests to run.",
+          "suppress": True,
+          }],
+        [["--extra-mozinfo-json"],
+         {"dest": "extra_mozinfo_json",
+          "default": None,
+          "help": "Filter tests based on a given mozinfo file.",
+          "suppress": True,
+          }],
+        [["--testrun-manifest-file"],
+         {"dest": "testRunManifestFile",
+          "default": 'tests.json',
+          "help": "Overrides the default filename of the tests.json manifest file that is "
+                  "generated by the harness and used by SimpleTest. Only useful when running "
+                  "multiple test runs simulatenously on the same machine.",
+          "suppress": True,
+          }],
+        [["--dump-tests"],
+         {"dest": "dump_tests",
+          "default": None,
+          "help": "Specify path to a filename to dump all the tests that will be run",
+          "suppress": True,
+          }],
+        [["--failure-file"],
+         {"dest": "failureFile",
+          "default": None,
+          "help": "Filename of the output file where we can store a .json list of failures "
+                  "to be run in the future with --run-only-tests.",
+          "suppress": True,
+          }],
+        [["--run-slower"],
+         {"action": "store_true",
+          "dest": "runSlower",
+          "default": False,
+          "help": "Delay execution between tests.",
+          }],
+        [["--metro-immersive"],
+         {"action": "store_true",
+          "dest": "immersiveMode",
+          "default": False,
+          "help": "Launches tests in an immersive browser.",
+          "suppress": True,
+          }],
+        [["--httpd-path"],
+         {"dest": "httpdPath",
+          "default": None,
+          "help": "Path to the httpd.js file.",
+          "suppress": True,
+          }],
+        [["--setpref"],
+         {"action": "append",
+          "metavar": "PREF=VALUE",
+          "default": [],
+          "dest": "extraPrefs",
+          "help": "Defines an extra user preference.",
+          }],
+        [["--jsdebugger"],
+         {"action": "store_true",
+          "default": False,
+          "help": "Start the browser JS debugger before running the test. Implies --no-autorun.",
+          }],
+        [["--debug-on-failure"],
+         {"action": "store_true",
+          "default": False,
+          "dest": "debugOnFailure",
+          "help": "Breaks execution and enters the JS debugger on a test failure. Should "
+                  "be used together with --jsdebugger."
+          }],
+        [["--disable-e10s"],
+         {"action": "store_false",
+          "default": True,
+          "dest": "e10s",
+          "help": "Run tests with electrolysis preferences and test filtering disabled.",
+          }],
+        [["--store-chrome-manifest"],
+         {"action": "store",
+          "help": "Destination path to write a copy of any chrome manifest "
+                  "written by the harness.",
+          "default": None,
+          "suppress": True,
+          }],
+        [["--jscov-dir-prefix"],
+         {"action": "store",
+          "help": "Directory to store per-test line coverage data as json "
+                  "(browser-chrome only). To emit lcov formatted data, set "
+                  "JS_CODE_COVERAGE_OUTPUT_DIR in the environment.",
+          "default": None,
+          "suppress": True,
+          }],
+        [["--strict-content-sandbox"],
+         {"action": "store_true",
+          "default": False,
+          "dest": "strictContentSandbox",
+          "help": "Run tests with a more strict content sandbox (Windows only).",
+          "suppress": not mozinfo.isWin,
+          }],
+        [["--nested_oop"],
+         {"action": "store_true",
+          "default": False,
+          "help": "Run tests with nested_oop preferences and test filtering enabled.",
+          }],
+        [["--dmd"],
+         {"action": "store_true",
+          "default": False,
+          "help": "Run tests with DMD active.",
+          }],
+        [["--dmd-path"],
+         {"default": None,
+          "dest": "dmdPath",
+          "help": "Specifies the path to the directory containing the shared library for DMD.",
+          "suppress": True,
+          }],
+        [["--dump-output-directory"],
+         {"default": None,
+          "dest": "dumpOutputDirectory",
+          "help": "Specifies the directory in which to place dumped memory reports.",
+          }],
+        [["--dump-about-memory-after-test"],
+         {"action": "store_true",
+          "default": False,
+          "dest": "dumpAboutMemoryAfterTest",
+          "help": "Dump an about:memory log after each test in the directory specified "
+                  "by --dump-output-directory.",
+          }],
+        [["--dump-dmd-after-test"],
+         {"action": "store_true",
+          "default": False,
+          "dest": "dumpDMDAfterTest",
+          "help": "Dump a DMD log after each test in the directory specified "
+                  "by --dump-output-directory.",
+          }],
+        [["--slowscript"],
+         {"action": "store_true",
+          "default": False,
+          "help": "Do not set the JS_DISABLE_SLOW_SCRIPT_SIGNALS env variable; "
+                  "when not set, recoverable but misleading SIGSEGV instances "
+                  "may occur in Ion/Odin JIT code.",
+          }],
+        [["--screenshot-on-fail"],
+         {"action": "store_true",
+          "default": False,
+          "dest": "screenshotOnFail",
+          "help": "Take screenshots on all test failures. Set $MOZ_UPLOAD_DIR to a directory "
+                  "for storing the screenshots."
+          }],
+        [["--quiet"],
+         {"action": "store_true",
+          "dest": "quiet",
+          "default": False,
+          "help": "Do not print test log lines unless a failure occurs.",
+          }],
+        [["--pidfile"],
+         {"dest": "pidFile",
+          "default": "",
+          "help": "Name of the pidfile to generate.",
+          "suppress": True,
+          }],
+        [["--use-test-media-devices"],
+         {"action": "store_true",
+          "default": False,
+          "dest": "useTestMediaDevices",
+          "help": "Use test media device drivers for media testing.",
+          }],
+        [["--gmp-path"],
+         {"default": None,
+          "help": "Path to fake GMP plugin. Will be deduced from the binary if not passed.",
+          "suppress": True,
+          }],
+        [["--xre-path"],
+         {"dest": "xrePath",
+          "default": None,    # individual scripts will set a sane default
+          "help": "Absolute path to directory containing XRE (probably xulrunner).",
+          "suppress": True,
+          }],
+        [["--symbols-path"],
+         {"dest": "symbolsPath",
+          "default": None,
+          "help": "Absolute path to directory containing breakpad symbols, or the URL of a "
+                  "zip file containing symbols",
+          "suppress": True,
+          }],
+        [["--debugger"],
+         {"default": None,
+          "help": "Debugger binary to run tests in. Program name or path.",
+          }],
+        [["--debugger-args"],
+         {"dest": "debuggerArgs",
+          "default": None,
+          "help": "Arguments to pass to the debugger.",
+          }],
+        [["--valgrind"],
+         {"default": None,
+          "help": "Valgrind binary to run tests with. Program name or path.",
+          }],
+        [["--valgrind-args"],
+         {"dest": "valgrindArgs",
+          "default": None,
+          "help": "Comma-separated list of extra arguments to pass to Valgrind.",
+          }],
+        [["--valgrind-supp-files"],
+         {"dest": "valgrindSuppFiles",
+          "default": None,
+          "help": "Comma-separated list of suppression files to pass to Valgrind.",
+          }],
+        [["--debugger-interactive"],
+         {"action": "store_true",
+          "dest": "debuggerInteractive",
+          "default": None,
+          "help": "Prevents the test harness from redirecting stdout and stderr for "
+                  "interactive debuggers.",
+          "suppress": True,
+          }],
+        [["--tag"],
+         {"action": "append",
+          "dest": "test_tags",
+          "default": None,
+          "help": "Filter out tests that don't have the given tag. Can be used multiple "
+                  "times in which case the test must contain at least one of the given tags.",
+          }],
+        [["--enable-cpow-warnings"],
+         {"action": "store_true",
+          "dest": "enableCPOWWarnings",
+          "help": "Enable logging of unsafe CPOW usage, which is disabled by default for tests",
+          "suppress": True,
+          }],
+        [["--marionette"],
+         {"default": None,
+          "help": "host:port to use when connecting to Marionette",
+          }],
+        [["--marionette-port-timeout"],
+         {"default": None,
+          "help": "Timeout while waiting for the marionette port to open.",
+          "suppress": True,
+          }],
+        [["--marionette-socket-timeout"],
+         {"default": None,
+          "help": "Timeout while waiting to receive a message from the marionette server.",
+          "suppress": True,
+          }],
+        [["--marionette-startup-timeout"],
+         {"default": None,
+          "help": "Timeout while waiting for marionette server startup.",
+          "suppress": True,
+          }],
+        [["--cleanup-crashes"],
+         {"action": "store_true",
+          "dest": "cleanupCrashes",
+          "default": False,
+          "help": "Delete pending crash reports before running tests.",
+          "suppress": True,
+          }],
+        [["--websocket-process-bridge-port"],
+         {"default": "8191",
+          "dest": "websocket_process_bridge_port",
+          "help": "Port for websocket/process bridge. Default 8191.",
+          }],
+    ]
+
+    defaults = {
+        # Bug 1065098 - The geckomediaplugin process fails to produce a leak
+        # log for some reason.
+        'ignoreMissingLeaks': ["geckomediaplugin"],
+        'extensionsToExclude': ['specialpowers'],
+        # Set server information on the args object
+        'webServer': '127.0.0.1',
+        'httpPort': DEFAULT_PORTS['http'],
+        'sslPort': DEFAULT_PORTS['https'],
+        'webSocketPort': '9988',
+        # The default websocket port is incorrect in mozprofile; it is
+        # set to the SSL proxy setting. See:
+        # see https://bugzilla.mozilla.org/show_bug.cgi?id=916517
+        # args.webSocketPort = DEFAULT_PORTS['ws']
+    }
+
+    def validate(self, parser, options, context):
+        """Validate generic options."""
+
+        # for test manifest parsing.
+        mozinfo.update({"strictContentSandbox": options.strictContentSandbox})
+        # for test manifest parsing.
+        mozinfo.update({"nested_oop": options.nested_oop})
+
+        # and android doesn't use 'app' the same way, so skip validation
+        if parser.app != 'android':
+            if options.app is None:
+                if build_obj:
+                    options.app = build_obj.get_binary_path()
+                else:
+                    parser.error(
+                        "could not find the application path, --appname must be specified")
+            elif options.app == "dist" and build_obj:
+                options.app = build_obj.get_binary_path(where='staged-package')
+
+            options.app = self.get_full_path(options.app, parser.oldcwd)
+            if not os.path.exists(options.app):
+                parser.error("Error: Path {} doesn't exist. Are you executing "
+                             "$objdir/_tests/testing/mochitest/runtests.py?".format(
+                                 options.app))
+
+        if options.gmp_path is None and options.app and build_obj:
+            # Need to fix the location of gmp_fake which might not be shipped in the binary
+            gmp_modules = (
+                ('gmp-fake', '1.0'),
+                ('gmp-clearkey', '0.1'),
+                ('gmp-fakeopenh264', '1.0')
+            )
+            options.gmp_path = os.pathsep.join(
+                os.path.join(build_obj.bindir, *p) for p in gmp_modules)
+
+        if options.totalChunks is not None and options.thisChunk is None:
+            parser.error(
+                "thisChunk must be specified when totalChunks is specified")
+
+        if options.extra_mozinfo_json:
+            if not os.path.isfile(options.extra_mozinfo_json):
+                parser.error("Error: couldn't find mozinfo.json at '%s'."
+                             % options.extra_mozinfo_json)
+
+            options.extra_mozinfo_json = json.load(open(options.extra_mozinfo_json))
+
+        if options.totalChunks:
+            if not 1 <= options.thisChunk <= options.totalChunks:
+                parser.error("thisChunk must be between 1 and totalChunks")
+
+        if options.chunkByDir and options.chunkByRuntime:
+            parser.error(
+                "can only use one of --chunk-by-dir or --chunk-by-runtime")
+
+        if options.xrePath is None:
+            # default xrePath to the app path if not provided
+            # but only if an app path was explicitly provided
+            if options.app != parser.get_default('app'):
+                options.xrePath = os.path.dirname(options.app)
+                if mozinfo.isMac:
+                    options.xrePath = os.path.join(
+                        os.path.dirname(
+                            options.xrePath),
+                        "Resources")
+            elif build_obj is not None:
+                # otherwise default to dist/bin
+                options.xrePath = build_obj.bindir
+            else:
+                parser.error(
+                    "could not find xre directory, --xre-path must be specified")
+
+        # allow relative paths
+        if options.xrePath:
+            options.xrePath = self.get_full_path(options.xrePath, parser.oldcwd)
+
+        if options.profilePath:
+            options.profilePath = self.get_full_path(options.profilePath, parser.oldcwd)
+
+        if options.dmdPath:
+            options.dmdPath = self.get_full_path(options.dmdPath, parser.oldcwd)
+
+        if options.dmd and not options.dmdPath:
+            if build_obj:
+                options.dmdPath = build_obj.bindir
+            else:
+                parser.error(
+                    "could not find dmd libraries, specify them with --dmd-path")
+
+        if options.utilityPath:
+            options.utilityPath = self.get_full_path(options.utilityPath, parser.oldcwd)
+
+        if options.certPath:
+            options.certPath = self.get_full_path(options.certPath, parser.oldcwd)
+        elif build_obj:
+            options.certPath = os.path.join(build_obj.topsrcdir, 'build', 'pgo', 'certs')
+
+        if options.symbolsPath and len(urlparse(options.symbolsPath).scheme) < 2:
+            options.symbolsPath = self.get_full_path(options.symbolsPath, parser.oldcwd)
+        elif not options.symbolsPath and build_obj:
+            options.symbolsPath = os.path.join(build_obj.distdir, 'crashreporter-symbols')
+
+        if options.jsdebugger:
+            options.extraPrefs += [
+                "devtools.debugger.remote-enabled=true",
+                "devtools.chrome.enabled=true",
+                "devtools.debugger.prompt-connection=false"
+            ]
+            options.autorun = False
+
+        if options.debugOnFailure and not options.jsdebugger:
+            parser.error(
+                "--debug-on-failure requires --jsdebugger.")
+
+        if options.debuggerArgs and not options.debugger:
+            parser.error(
+                "--debugger-args requires --debugger.")
+
+        if options.valgrind or options.debugger:
+            # valgrind and some debuggers may cause Gecko to start slowly. Make sure
+            # marionette waits long enough to connect.
+            options.marionette_port_timeout = 900
+            options.marionette_socket_timeout = 540
+
+        if options.store_chrome_manifest:
+            options.store_chrome_manifest = os.path.abspath(options.store_chrome_manifest)
+            if not os.path.isdir(os.path.dirname(options.store_chrome_manifest)):
+                parser.error(
+                    "directory for %s does not exist as a destination to copy a "
+                    "chrome manifest." % options.store_chrome_manifest)
+
+        if options.jscov_dir_prefix:
+            options.jscov_dir_prefix = os.path.abspath(options.jscov_dir_prefix)
+            if not os.path.isdir(options.jscov_dir_prefix):
+                parser.error(
+                    "directory %s does not exist as a destination for coverage "
+                    "data." % options.jscov_dir_prefix)
+
+        if options.testingModulesDir is None:
+            if build_obj:
+                options.testingModulesDir = os.path.join(
+                    build_obj.topobjdir, '_tests', 'modules')
+            else:
+                # Try to guess the testing modules directory.
+                # This somewhat grotesque hack allows the buildbot machines to find the
+                # modules directory without having to configure the buildbot hosts. This
+                # code should never be executed in local runs because the build system
+                # should always set the flag that populates this variable. If buildbot ever
+                # passes this argument, this code can be deleted.
+                possible = os.path.join(here, os.path.pardir, 'modules')
+
+                if os.path.isdir(possible):
+                    options.testingModulesDir = possible
+
+        if build_obj:
+            plugins_dir = os.path.join(build_obj.distdir, 'plugins')
+            if plugins_dir not in options.extraProfileFiles:
+                options.extraProfileFiles.append(plugins_dir)
+
+        # Even if buildbot is updated, we still want this, as the path we pass in
+        # to the app must be absolute and have proper slashes.
+        if options.testingModulesDir is not None:
+            options.testingModulesDir = os.path.normpath(
+                options.testingModulesDir)
+
+            if not os.path.isabs(options.testingModulesDir):
+                options.testingModulesDir = os.path.abspath(
+                    options.testingModulesDir)
+
+            if not os.path.isdir(options.testingModulesDir):
+                parser.error('--testing-modules-dir not a directory: %s' %
+                             options.testingModulesDir)
+
+            options.testingModulesDir = options.testingModulesDir.replace(
+                '\\',
+                '/')
+            if options.testingModulesDir[-1] != '/':
+                options.testingModulesDir += '/'
+
+        if options.immersiveMode:
+            if not mozinfo.isWin:
+                parser.error("immersive is only supported on Windows 8 and up.")
+            options.immersiveHelperPath = os.path.join(
+                options.utilityPath, "metrotestharness.exe")
+            if not os.path.exists(options.immersiveHelperPath):
+                parser.error("%s not found, cannot launch immersive tests." %
+                             options.immersiveHelperPath)
+
+        if options.runUntilFailure:
+            if not options.repeat:
+                options.repeat = 29
+
+        if options.dumpOutputDirectory is None:
+            options.dumpOutputDirectory = tempfile.gettempdir()
+
+        if options.dumpAboutMemoryAfterTest or options.dumpDMDAfterTest:
+            if not os.path.isdir(options.dumpOutputDirectory):
+                parser.error('--dump-output-directory not a directory: %s' %
+                             options.dumpOutputDirectory)
+
+        if options.useTestMediaDevices:
+            if not mozinfo.isLinux:
+                parser.error(
+                    '--use-test-media-devices is only supported on Linux currently')
+            for f in ['/usr/bin/gst-launch-0.10', '/usr/bin/pactl']:
+                if not os.path.isfile(f):
+                    parser.error(
+                        'Missing binary %s required for '
+                        '--use-test-media-devices' % f)
+
+        if options.nested_oop:
+            options.e10s = True
+
+        options.leakThresholds = {
+            "default": options.defaultLeakThreshold,
+            "tab": 10000,  # See dependencies of bug 1051230.
+            # GMP rarely gets a log, but when it does, it leaks a little.
+            "geckomediaplugin": 20000,
+        }
+
+        # XXX We can't normalize test_paths in the non build_obj case here,
+        # because testRoot depends on the flavor, which is determined by the
+        # mach command and therefore not finalized yet. Conversely, test paths
+        # need to be normalized here for the mach case.
+        if options.test_paths and build_obj:
+            # Normalize test paths so they are relative to test root
+            options.test_paths = [build_obj._wrap_path_argument(p).relpath()
+                                  for p in options.test_paths]
+
+        return options
+
+
+class AndroidArguments(ArgumentContainer):
+    """Android specific arguments."""
+
+    args = [
+        [["--remote-app-path"],
+         {"dest": "remoteAppPath",
+          "help": "Path to remote executable relative to device root using \
+                   only forward slashes. Either this or app must be specified \
+                   but not both.",
+          "default": None,
+          }],
+        [["--deviceIP"],
+         {"dest": "deviceIP",
+          "help": "ip address of remote device to test",
+          "default": None,
+          }],
+        [["--deviceSerial"],
+         {"dest": "deviceSerial",
+          "help": "ip address of remote device to test",
+          "default": None,
+          }],
+        [["--dm_trans"],
+         {"choices": ["adb", "sut"],
+          "default": "adb",
+          "help": "The transport to use for communication with the device [default: adb].",
+          "suppress": True,
+          }],
+        [["--adbpath"],
+         {"dest": "adbPath",
+          "default": None,
+          "help": "Path to adb binary.",
+          "suppress": True,
+          }],
+        [["--devicePort"],
+         {"dest": "devicePort",
+          "type": int,
+          "default": 20701,
+          "help": "port of remote device to test",
+          }],
+        [["--remote-product-name"],
+         {"dest": "remoteProductName",
+          "default": "fennec",
+          "help": "The executable's name of remote product to test - either \
+                   fennec or firefox, defaults to fennec",
+          "suppress": True,
+          }],
+        [["--remote-logfile"],
+         {"dest": "remoteLogFile",
+          "default": None,
+          "help": "Name of log file on the device relative to the device \
+                   root. PLEASE ONLY USE A FILENAME.",
+          }],
+        [["--remote-webserver"],
+         {"dest": "remoteWebServer",
+          "default": None,
+          "help": "ip address where the remote web server is hosted at",
+          }],
+        [["--http-port"],
+         {"dest": "httpPort",
+          "default": DEFAULT_PORTS['http'],
+          "help": "http port of the remote web server",
+          "suppress": True,
+          }],
+        [["--ssl-port"],
+         {"dest": "sslPort",
+          "default": DEFAULT_PORTS['https'],
+          "help": "ssl port of the remote web server",
+          "suppress": True,
+          }],
+        [["--robocop-ini"],
+         {"dest": "robocopIni",
+          "default": "",
+          "help": "name of the .ini file containing the list of tests to run",
+          }],
+        [["--robocop-apk"],
+         {"dest": "robocopApk",
+          "default": "",
+          "help": "name of the Robocop APK to use for ADB test running",
+          }],
+        [["--remoteTestRoot"],
+         {"dest": "remoteTestRoot",
+          "default": None,
+          "help": "remote directory to use as test root \
+                   (eg. /mnt/sdcard/tests or /data/local/tests)",
+          "suppress": True,
+          }],
+    ]
+
+    defaults = {
+        'dm': None,
+        # we don't want to exclude specialpowers on android just yet
+        'extensionsToExclude': [],
+        # mochijar doesn't get installed via marionette on android
+        'extensionsToInstall': [os.path.join(here, 'mochijar')],
+        'logFile': 'mochitest.log',
+        'utilityPath': None,
+    }
+
+    def validate(self, parser, options, context):
+        """Validate android options."""
+
+        if build_obj:
+            options.log_mach = '-'
+
+        device_args = {'deviceRoot': options.remoteTestRoot}
+        if options.dm_trans == "adb":
+            device_args['adbPath'] = options.adbPath
+            if options.deviceIP:
+                device_args['host'] = options.deviceIP
+                device_args['port'] = options.devicePort
+            elif options.deviceSerial:
+                device_args['deviceSerial'] = options.deviceSerial
+            options.dm = DroidADB(**device_args)
+        elif options.dm_trans == 'sut':
+            if options.deviceIP is None:
+                parser.error(
+                    "If --dm_trans = sut, you must provide a device IP")
+            device_args['host'] = options.deviceIP
+            device_args['port'] = options.devicePort
+            options.dm = DroidSUT(**device_args)
+
+        if not options.remoteTestRoot:
+            options.remoteTestRoot = options.dm.deviceRoot
+
+        if options.remoteWebServer is None:
+            if os.name != "nt":
+                options.remoteWebServer = moznetwork.get_ip()
+            else:
+                parser.error(
+                    "you must specify a --remote-webserver=<ip address>")
+
+        options.webServer = options.remoteWebServer
+
+        if options.remoteLogFile is None:
+            options.remoteLogFile = options.remoteTestRoot + \
+                '/logs/mochitest.log'
+
+        if options.remoteLogFile.count('/') < 1:
+            options.remoteLogFile = options.remoteTestRoot + \
+                '/' + options.remoteLogFile
+
+        if options.remoteAppPath and options.app:
+            parser.error(
+                "You cannot specify both the remoteAppPath and the app setting")
+        elif options.remoteAppPath:
+            options.app = options.remoteTestRoot + "/" + options.remoteAppPath
+        elif options.app is None:
+            if build_obj:
+                options.app = build_obj.substs['ANDROID_PACKAGE_NAME']
+            else:
+                # Neither remoteAppPath nor app are set -- error
+                parser.error("You must specify either appPath or app")
+
+        if build_obj and 'MOZ_HOST_BIN' in os.environ:
+            options.xrePath = os.environ['MOZ_HOST_BIN']
+
+        # Only reset the xrePath if it wasn't provided
+        if options.xrePath is None:
+            options.xrePath = options.utilityPath
+
+        if options.pidFile != "":
+            f = open(options.pidFile, 'w')
+            f.write("%s" % os.getpid())
+            f.close()
+
+        # Robocop specific options
+        if options.robocopIni != "":
+            if not os.path.exists(options.robocopIni):
+                parser.error(
+                    "Unable to find specified robocop .ini manifest '%s'" %
+                    options.robocopIni)
+            options.robocopIni = os.path.abspath(options.robocopIni)
+
+            if not options.robocopApk and build_obj:
+                options.robocopApk = os.path.join(build_obj.topobjdir, 'mobile', 'android',
+                                                  'tests', 'browser',
+                                                  'robocop', 'robocop-debug.apk')
+
+        if options.robocopApk != "":
+            if not os.path.exists(options.robocopApk):
+                parser.error(
+                    "Unable to find robocop APK '%s'" %
+                    options.robocopApk)
+            options.robocopApk = os.path.abspath(options.robocopApk)
+
+        # Disable e10s by default on Android because we don't run Android
+        # e10s jobs anywhere yet.
+        options.e10s = False
+        mozinfo.update({'e10s': options.e10s})
+
+        # allow us to keep original application around for cleanup while
+        # running robocop via 'am'
+        options.remoteappname = options.app
+        return options
+
+
+container_map = {
+    'generic': [MochitestArguments],
+    'android': [MochitestArguments, AndroidArguments],
+}
+
+
+class MochitestArgumentParser(ArgumentParser):
+    """%(prog)s [options] [test paths]"""
+
+    _containers = None
+    context = {}
+
+    def __init__(self, app=None, **kwargs):
+        ArgumentParser.__init__(self, usage=self.__doc__, conflict_handler='resolve', **kwargs)
+
+        self.oldcwd = os.getcwd()
+        self.app = app
+        if not self.app and build_obj:
+            if conditions.is_android(build_obj):
+                self.app = 'android'
+        if not self.app:
+            # platform can't be determined and app wasn't specified explicitly,
+            # so just use generic arguments and hope for the best
+            self.app = 'generic'
+
+        if self.app not in container_map:
+            self.error("Unrecognized app '{}'! Must be one of: {}".format(
+                self.app, ', '.join(container_map.keys())))
+
+        defaults = {}
+        for container in self.containers:
+            defaults.update(container.defaults)
+            group = self.add_argument_group(container.__class__.__name__, container.__doc__)
+
+            for cli, kwargs in container.args:
+                # Allocate new lists so references to original don't get mutated.
+                # allowing multiple uses within a single process.
+                if "default" in kwargs and isinstance(kwargs['default'], list):
+                    kwargs["default"] = []
+
+                if 'suppress' in kwargs:
+                    if kwargs['suppress']:
+                        kwargs['help'] = SUPPRESS
+                    del kwargs['suppress']
+
+                group.add_argument(*cli, **kwargs)
+
+        self.set_defaults(**defaults)
+        mozlog.commandline.add_logging_group(self)
+
+    @property
+    def containers(self):
+        if self._containers:
+            return self._containers
+
+        containers = container_map[self.app]
+        self._containers = [c() for c in containers]
+        return self._containers
+
+    def validate(self, args):
+        for container in self.containers:
+            args = container.validate(self, args, self.context)
+        return args