summaryrefslogtreecommitdiffstats
path: root/testing/mochitest/mochitest_options.py
diff options
context:
space:
mode:
Diffstat (limited to 'testing/mochitest/mochitest_options.py')
-rw-r--r--testing/mochitest/mochitest_options.py1442
1 files changed, 1442 insertions, 0 deletions
diff --git a/testing/mochitest/mochitest_options.py b/testing/mochitest/mochitest_options.py
new file mode 100644
index 0000000000..f69e10da7b
--- /dev/null
+++ b/testing/mochitest/mochitest_options.py
@@ -0,0 +1,1442 @@
+# 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 json
+import os
+import sys
+import tempfile
+from abc import ABCMeta, abstractmethod, abstractproperty
+from argparse import SUPPRESS, ArgumentParser
+from distutils import spawn
+from distutils.util import strtobool
+from itertools import chain
+
+import mozinfo
+import mozlog
+import moznetwork
+import six
+from mozprofile import DEFAULT_PORTS
+from six.moves.urllib.parse import urlparse
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+try:
+ from mozbuild.base import MachCommandConditions as conditions
+ from mozbuild.base import MozbuildObject
+
+ build_obj = MozbuildObject.from_environment(cwd=here)
+except ImportError:
+ build_obj = None
+ conditions = None
+
+
+# Maps test flavors to data needed to run them
+ALL_FLAVORS = {
+ "mochitest": {
+ "suite": "plain",
+ "aliases": ("plain", "mochitest"),
+ "enabled_apps": ("firefox", "android"),
+ "extra_args": {
+ "flavor": "plain",
+ },
+ "install_subdir": "tests",
+ },
+ "chrome": {
+ "suite": "chrome",
+ "aliases": ("chrome", "mochitest-chrome"),
+ "enabled_apps": ("firefox"),
+ "extra_args": {
+ "flavor": "chrome",
+ },
+ },
+ "browser-chrome": {
+ "suite": "browser",
+ "aliases": ("browser", "browser-chrome", "mochitest-browser-chrome", "bc"),
+ "enabled_apps": ("firefox", "thunderbird"),
+ "extra_args": {
+ "flavor": "browser",
+ },
+ },
+ "a11y": {
+ "suite": "a11y",
+ "aliases": ("a11y", "mochitest-a11y", "accessibility"),
+ "enabled_apps": ("firefox",),
+ "extra_args": {
+ "flavor": "a11y",
+ },
+ },
+}
+SUPPORTED_FLAVORS = list(
+ chain.from_iterable([f["aliases"] for f in ALL_FLAVORS.values()])
+)
+CANONICAL_FLAVORS = sorted([f["aliases"][0] for f in ALL_FLAVORS.values()])
+
+
+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-pc-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-pc-linux-gnu.sup"))
+ rv.append(os.path.join(supps_path, "cross-architecture.sup"))
+
+ return rv
+
+
+@six.add_metaclass(ABCMeta)
+class ArgumentContainer:
+ @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."""
+
+ 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"],
+ {
+ "choices": SUPPORTED_FLAVORS,
+ "metavar": "{{{}}}".format(", ".join(CANONICAL_FLAVORS)),
+ "default": None,
+ "help": "Only run tests of this flavor.",
+ },
+ ],
+ [
+ ["--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", # NOQA: E501
+ "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-manifest"],
+ {
+ "action": "store_true",
+ "dest": "runByManifest",
+ "help": "Run each manifest in a single browser instance with a fresh profile.",
+ "default": False,
+ "suppress": True,
+ },
+ ],
+ [
+ ["--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,
+ },
+ ],
+ [
+ ["--conditioned-profile"],
+ {
+ "dest": "conditionedProfile",
+ "action": "store_true",
+ "default": False,
+ "help": "Download and run with a full conditioned profile.",
+ },
+ ],
+ [
+ ["--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.",
+ },
+ ],
+ [
+ ["--httpd-path"],
+ {
+ "dest": "httpdPath",
+ "default": None,
+ "help": "Path to the httpd.js file.",
+ "suppress": True,
+ },
+ ],
+ [
+ ["--use-http3-server"],
+ {
+ "dest": "useHttp3Server",
+ "default": False,
+ "help": "Whether to use the Http3 server",
+ "action": "store_true",
+ },
+ ],
+ [
+ ["--setpref"],
+ {
+ "action": "append",
+ "metavar": "PREF=VALUE",
+ "default": [],
+ "dest": "extraPrefs",
+ "help": "Defines an extra user preference.",
+ },
+ ],
+ [
+ ["--jsconsole"],
+ {
+ "action": "store_true",
+ "default": False,
+ "help": "Open the Browser Console.",
+ },
+ ],
+ [
+ ["--jsdebugger"],
+ {
+ "action": "store_true",
+ "default": False,
+ "help": "Start the browser JS debugger before running the test.",
+ },
+ ],
+ [
+ ["--jsdebugger-path"],
+ {
+ "default": None,
+ "dest": "jsdebuggerPath",
+ "help": "Path to a Firefox binary that will be used to run the toolbox. Should "
+ "be used together with --jsdebugger.",
+ },
+ ],
+ [
+ ["--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.",
+ },
+ ],
+ [
+ ["--enable-a11y-checks"],
+ {
+ "action": "store_true",
+ "default": False,
+ "dest": "a11y_checks",
+ "help": "Run tests with accessibility checks disabled.",
+ },
+ ],
+ [
+ ["--disable-fission"],
+ {
+ "action": "store_true",
+ "default": False,
+ "dest": "disable_fission",
+ "help": "Run tests with fission (site isolation) disabled.",
+ },
+ ],
+ [
+ ["--enable-xorigin-tests"],
+ {
+ "action": "store_true",
+ "default": False,
+ "dest": "xOriginTests",
+ "help": "Run tests in a cross origin iframe.",
+ },
+ ],
+ [
+ ["--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,
+ },
+ ],
+ [
+ ["--dmd"],
+ {
+ "action": "store_true",
+ "default": False,
+ "help": "Run tests with DMD active.",
+ },
+ ],
+ [
+ ["--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 (and an accompanying about:memory log) after each test. "
+ "These will be dumped into your default temp directory, NOT the directory "
+ "specified by --dump-output-directory. The logs are numbered by test, and "
+ "each test will include output that indicates the DMD output filename.",
+ },
+ ],
+ [
+ ["--screenshot-on-fail"],
+ {
+ "action": "store_true",
+ "default": False,
+ "dest": "screenshotOnFail",
+ "help": "Take screenshots on all test failures. Set $MOZ_UPLOAD_DIR to a directory " # NOQA: E501
+ "for storing the screenshots.",
+ },
+ ],
+ [
+ ["--quiet"],
+ {
+ "action": "store_true",
+ "dest": "quiet",
+ "default": False,
+ "help": "Do not print test log lines unless a failure occurs.",
+ },
+ ],
+ [
+ ["--headless"],
+ {
+ "action": "store_true",
+ "dest": "headless",
+ "default": False,
+ "help": "Run tests in headless mode.",
+ },
+ ],
+ [
+ ["--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.",
+ },
+ ],
+ [
+ ["--marionette"],
+ {
+ "default": None,
+ "help": "host:port to use when connecting to Marionette",
+ },
+ ],
+ [
+ ["--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.",
+ },
+ ],
+ [
+ ["--failure-pattern-file"],
+ {
+ "default": None,
+ "dest": "failure_pattern_file",
+ "help": "File describes all failure patterns of the tests.",
+ "suppress": True,
+ },
+ ],
+ [
+ ["--sandbox-read-whitelist"],
+ {
+ "default": [],
+ "dest": "sandboxReadWhitelist",
+ "action": "append",
+ "help": "Path to add to the sandbox whitelist.",
+ "suppress": True,
+ },
+ ],
+ [
+ ["--verify"],
+ {
+ "action": "store_true",
+ "default": False,
+ "help": "Run tests in verification mode: Run many times in different "
+ "ways, to see if there are intermittent failures.",
+ },
+ ],
+ [
+ ["--verify-fission"],
+ {
+ "action": "store_true",
+ "default": False,
+ "help": "Run tests once without Fission, once with Fission",
+ },
+ ],
+ [
+ ["--verify-max-time"],
+ {
+ "type": int,
+ "default": 3600,
+ "help": "Maximum time, in seconds, to run in --verify mode.",
+ },
+ ],
+ [
+ ["--profiler"],
+ {
+ "action": "store_true",
+ "dest": "profiler",
+ "default": False,
+ "help": "Run the Firefox Profiler and get a performance profile of the "
+ "mochitest. This is useful to find performance issues, and also "
+ "to see what exactly the test is doing. To get profiler options run: "
+ "`MOZ_PROFILER_HELP=1 ./mach run`",
+ },
+ ],
+ [
+ ["--profiler-save-only"],
+ {
+ "action": "store_true",
+ "dest": "profilerSaveOnly",
+ "default": False,
+ "help": "Run the Firefox Profiler and save it to the path specified by the "
+ "MOZ_UPLOAD_DIR environment variable.",
+ },
+ ],
+ [
+ ["--run-failures"],
+ {
+ "action": "store",
+ "dest": "runFailures",
+ "default": "",
+ "help": "Run fail-if/skip-if tests that match a keyword given.",
+ },
+ ],
+ [
+ ["--timeout-as-pass"],
+ {
+ "action": "store_true",
+ "dest": "timeoutAsPass",
+ "default": False,
+ "help": "treat harness level timeouts as passing (used for quarantine jobs).",
+ },
+ ],
+ [
+ ["--crash-as-pass"],
+ {
+ "action": "store_true",
+ "dest": "crashAsPass",
+ "default": False,
+ "help": "treat harness level crashes as passing (used for quarantine jobs).",
+ },
+ ],
+ [
+ ["--compare-preferences"],
+ {
+ "action": "store_true",
+ "dest": "comparePrefs",
+ "default": False,
+ "help": "Compare preferences at the end of each test and report changed ones as failures.",
+ },
+ ],
+ ]
+
+ defaults = {
+ # Bug 1065098 - The gmplugin process fails to produce a leak
+ # log for some reason.
+ "ignoreMissingLeaks": ["gmplugin"],
+ "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."""
+
+ # and android doesn't use 'app' the same way, so skip validation
+ if parser.app != "android":
+ if options.app is None:
+ if build_obj:
+ from mozbuild.base import BinaryNotFoundException
+
+ try:
+ options.app = build_obj.get_binary_path()
+ except BinaryNotFoundException as e:
+ print("{}\n\n{}\n".format(e, e.help()))
+ sys.exit(1)
+ 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.flavor is None:
+ options.flavor = "plain"
+
+ for value in ALL_FLAVORS.values():
+ if options.flavor in value["aliases"]:
+ options.flavor = value["suite"]
+ break
+
+ 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.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.debugOnFailure and not options.jsdebugger:
+ parser.error("--debug-on-failure requires --jsdebugger.")
+
+ if options.jsdebuggerPath and not options.jsdebugger:
+ parser.error("--jsdebugger-path 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_startup_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:
+ # Try to guess the testing modules directory.
+ possible = [os.path.join(here, os.path.pardir, "modules")]
+ if build_obj:
+ possible.insert(
+ 0, os.path.join(build_obj.topobjdir, "_tests", "modules")
+ )
+
+ for p in possible:
+ if os.path.isdir(p):
+ options.testingModulesDir = p
+ break
+
+ # Paths to specialpowers and mochijar from the tests archive.
+ options.stagedAddons = [
+ os.path.join(here, "extensions", "specialpowers"),
+ os.path.join(here, "mochijar"),
+ ]
+ if build_obj:
+ objdir_xpi_stage = os.path.join(build_obj.distdir, "xpi-stage")
+ if os.path.isdir(objdir_xpi_stage):
+ options.stagedAddons = [
+ os.path.join(objdir_xpi_stage, "specialpowers"),
+ os.path.join(objdir_xpi_stage, "mochijar"),
+ ]
+ plugins_dir = os.path.join(build_obj.distdir, "plugins")
+ if (
+ os.path.isdir(plugins_dir)
+ and 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.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"
+ )
+
+ gst01 = spawn.find_executable("gst-launch-0.1")
+ gst010 = spawn.find_executable("gst-launch-0.10")
+ gst10 = spawn.find_executable("gst-launch-1.0")
+ pactl = spawn.find_executable("pactl")
+
+ if not (gst01 or gst10 or gst010):
+ parser.error(
+ "Missing gst-launch-{0.1,0.10,1.0}, required for "
+ "--use-test-media-devices"
+ )
+
+ if not pactl:
+ parser.error(
+ "Missing binary pactl required for " "--use-test-media-devices"
+ )
+
+ # The a11y and chrome flavors can't run with e10s.
+ if options.flavor in ("a11y", "chrome") and options.e10s:
+ parser.error(
+ "mochitest-{} does not support e10s, try again with "
+ "--disable-e10s.".format(options.flavor)
+ )
+
+ # If e10s explicitly disabled and no fission option specified, disable fission
+ if (not options.e10s) and (not options.disable_fission):
+ options.disable_fission = True
+
+ options.leakThresholds = {
+ "default": options.defaultLeakThreshold,
+ "tab": options.defaultLeakThreshold,
+ "forkserver": options.defaultLeakThreshold,
+ # GMP rarely gets a log, but when it does, it leaks a little.
+ "gmplugin": 20000,
+ }
+
+ # See the dependencies of bug 1401764.
+ if mozinfo.isWin:
+ options.leakThresholds["tab"] = 1000
+
+ # 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 = [
+ [
+ ["--no-install"],
+ {
+ "action": "store_true",
+ "default": False,
+ "help": "Skip the installation of the APK.",
+ },
+ ],
+ [
+ ["--aab"],
+ {
+ "action": "store_true",
+ "default": False,
+ "help": "Install the test_runner app using AAB.",
+ },
+ ],
+ [
+ ["--deviceSerial"],
+ {
+ "dest": "deviceSerial",
+ "help": "adb serial number of remote device. This is required "
+ "when more than one device is connected to the host. "
+ "Use 'adb devices' to see connected devices.",
+ "default": None,
+ },
+ ],
+ [
+ ["--adbpath"],
+ {
+ "dest": "adbPath",
+ "default": None,
+ "help": "Path to adb binary.",
+ "suppress": True,
+ },
+ ],
+ [
+ ["--remote-webserver"],
+ {
+ "dest": "remoteWebServer",
+ "default": None,
+ "help": "IP address of the remote web server.",
+ },
+ ],
+ [
+ ["--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,
+ },
+ ],
+ [
+ ["--remoteTestRoot"],
+ {
+ "dest": "remoteTestRoot",
+ "default": None,
+ "help": "Remote directory to use as test root "
+ "(eg. /data/local/tmp/test_root).",
+ "suppress": True,
+ },
+ ],
+ [
+ ["--enable-coverage"],
+ {
+ "action": "store_true",
+ "default": False,
+ "help": "Enable collecting code coverage information when running "
+ "junit tests.",
+ },
+ ],
+ [
+ ["--coverage-output-dir"],
+ {
+ "action": "store",
+ "default": None,
+ "help": "When using --enable-java-coverage, save the code coverage report "
+ "files to this directory.",
+ },
+ ],
+ ]
+
+ defaults = {
+ # 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 = "-"
+
+ objdir_xpi_stage = os.path.join(build_obj.distdir, "xpi-stage")
+ if os.path.isdir(objdir_xpi_stage):
+ options.extensionsToInstall = [
+ os.path.join(objdir_xpi_stage, "mochijar"),
+ os.path.join(objdir_xpi_stage, "specialpowers"),
+ ]
+
+ if options.remoteWebServer is None:
+ options.remoteWebServer = moznetwork.get_ip()
+
+ options.webServer = options.remoteWebServer
+
+ if options.app is None:
+ options.app = "org.mozilla.geckoview.test_runner"
+
+ 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 build_obj:
+ options.topsrcdir = build_obj.topsrcdir
+
+ if options.pidFile != "":
+ f = open(options.pidFile, "w")
+ f.write("%s" % os.getpid())
+ f.close()
+
+ if options.coverage_output_dir and not options.enable_coverage:
+ parser.error("--coverage-output-dir must be used with --enable-coverage")
+ if options.enable_coverage:
+ if not options.autorun:
+ parser.error("--enable-coverage cannot be used with --no-autorun")
+ if not options.coverage_output_dir:
+ parser.error(
+ "--coverage-output-dir must be specified when using --enable-coverage"
+ )
+ parent_dir = os.path.dirname(options.coverage_output_dir)
+ if not os.path.isdir(options.coverage_output_dir):
+ parser.error(
+ "The directory for the coverage output does not exist: %s"
+ % parent_dir
+ )
+
+ # allow us to keep original application around for cleanup while
+ # running tests
+ 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
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-02 12:05:55 +0000