The Tor Browser: testing/mochitest/mochitest_options.py@6474c204b198 (annotated)

testing/mochitest/mochitest_options.py@6474c204b198 (annotated)

testing/mochitest/mochitest_options.py

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 # 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 mozinfo
 import moznetwork
 import optparse
 import os
 import tempfile
 from automationutils import addCommonOptions, isURL
 from mozprofile import DEFAULT_PORTS
 here = os.path.abspath(os.path.dirname(__file__))
 try:
     from mozbuild.base import MozbuildObject
     build_obj = MozbuildObject.from_environment(cwd=here)
 except ImportError:
     build_obj = None
 __all__ = ["MochitestOptions", "B2GOptions"]
 VMWARE_RECORDING_HELPER_BASENAME = "vmwarerecordinghelper"
 class MochitestOptions(optparse.OptionParser):
     """Usage instructions for runtests.py.
     All arguments are optional.
     If --chrome is specified, chrome tests will be run instead of web content tests.
     If --browser-chrome is specified, browser-chrome tests will be run instead of web content tests.
     See <http://mochikit.com/doc/html/MochiKit/Logging.html> for details on the logging levels.
     """
     LOG_LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR", "FATAL")
     LEVEL_STRING = ", ".join(LOG_LEVELS)
     mochitest_options = [
         [["--close-when-done"],
         { "action": "store_true",
           "dest": "closeWhenDone",
           "default": False,
           "help": "close the application when tests are done running",
         }],
         [["--appname"],
         { "action": "store",
           "type": "string",
           "dest": "app",
           "default": None,
           "help": "absolute path to application, overriding default",
         }],
         [["--utility-path"],
         { "action": "store",
           "type": "string",
           "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)",
         }],
         [["--certificate-path"],
         { "action": "store",
           "type": "string",
           "dest": "certPath",
           "help": "absolute path to directory containing certificate store to use testing profile",
           "default": os.path.join(build_obj.topsrcdir, 'build', 'pgo', 'certs') if build_obj is not None else None,
         }],
         [["--log-file"],
         { "action": "store",
           "type": "string",
           "dest": "logFile",
           "metavar": "FILE",
           "help": "file to which logging occurs",
           "default": "",
         }],
         [["--hide-subtests"],
         { "action": "store_true",
           "dest": "hide_subtests",
           "help": "only show subtest log output if there was a failure",
           "default": False,
         }],
         [["--autorun"],
         { "action": "store_true",
           "dest": "autorun",
           "help": "start running tests when the application starts",
           "default": False,
         }],
         [["--timeout"],
         { "type": "int",
           "dest": "timeout",
           "help": "per-test timeout in seconds",
           "default": None,
         }],
         [["--total-chunks"],
         { "type": "int",
           "dest": "totalChunks",
           "help": "how many chunks to split the tests up into",
           "default": None,
         }],
         [["--this-chunk"],
         { "type": "int",
           "dest": "thisChunk",
           "help": "which chunk to run",
           "default": None,
         }],
         [["--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,
         }],
         [["--shuffle"],
         { "dest": "shuffle",
           "action": "store_true",
           "help": "randomize test order",
           "default": False,
         }],
         [["--console-level"],
         { "action": "store",
           "type": "choice",
           "dest": "consoleLevel",
           "choices": LOG_LEVELS,
           "metavar": "LEVEL",
           "help": "one of %s to determine the level of console "
                   "logging" % LEVEL_STRING,
           "default": None,
         }],
         [["--file-level"],
         { "action": "store",
           "type": "choice",
           "dest": "fileLevel",
           "choices": LOG_LEVELS,
           "metavar": "LEVEL",
           "help": "one of %s to determine the level of file "
                  "logging if a file has been specified, defaulting "
                  "to INFO" % LEVEL_STRING,
           "default": "INFO",
         }],
         [["--chrome"],
         { "action": "store_true",
           "dest": "chrome",
           "help": "run chrome Mochitests",
           "default": False,
         }],
         [["--ipcplugins"],
         { "action": "store_true",
           "dest": "ipcplugins",
           "help": "run ipcplugins Mochitests",
           "default": False,
         }],
         [["--test-path"],
         { "action": "store",
           "type": "string",
           "dest": "testPath",
           "help": "start in the given directory's tests",
           "default": "",
         }],
         [["--start-at"],
         { "action": "store",
           "type": "string",
           "dest": "startAt",
           "help": "skip over tests until reaching the given test",
           "default": "",
         }],
         [["--end-at"],
         { "action": "store",
           "type": "string",
           "dest": "endAt",
           "help": "don't run any tests after the given one",
           "default": "",
         }],
         [["--browser-chrome"],
         { "action": "store_true",
           "dest": "browserChrome",
           "help": "run browser chrome Mochitests",
           "default": False,
         }],
         [["--subsuite"],
         { "action": "store",
           "dest": "subsuite",
           "help": "subsuite of tests to run",
           "default": "",
         }],
         [["--webapprt-content"],
         { "action": "store_true",
           "dest": "webapprtContent",
           "help": "run WebappRT content tests",
           "default": False,
         }],
         [["--webapprt-chrome"],
         { "action": "store_true",
           "dest": "webapprtChrome",
           "help": "run WebappRT chrome tests",
           "default": False,
         }],
         [["--a11y"],
         { "action": "store_true",
           "dest": "a11y",
           "help": "run accessibility Mochitests",
           "default": False,
         }],
         [["--setenv"],
         { "action": "append",
           "type": "string",
           "dest": "environment",
           "metavar": "NAME=VALUE",
           "help": "sets the given variable in the application's "
                  "environment",
           "default": [],
         }],
         [["--exclude-extension"],
         { "action": "append",
           "type": "string",
           "dest": "extensionsToExclude",
           "help": "excludes the given extension from being installed "
                  "in the test profile",
           "default": [],
         }],
         [["--browser-arg"],
         { "action": "append",
           "type": "string",
           "dest": "browserArgs",
           "metavar": "ARG",
           "help": "provides an argument to the test application",
           "default": [],
         }],
         [["--leak-threshold"],
         { "action": "store",
           "type": "int",
           "dest": "leakThreshold",
           "metavar": "THRESHOLD",
           "help": "fail if the number of bytes leaked through "
                  "refcounted objects (or bytes in classes with "
                  "MOZ_COUNT_CTOR and MOZ_COUNT_DTOR) is greater "
                  "than the given number",
           "default": 0,
         }],
         [["--fatal-assertions"],
         { "action": "store_true",
           "dest": "fatalAssertions",
           "help": "abort testing whenever an assertion is hit "
                  "(requires a debug build to be effective)",
           "default": False,
         }],
         [["--extra-profile-file"],
         { "action": "append",
           "dest": "extraProfileFiles",
           "help": "copy specified files/dirs to testing profile",
           "default": [],
         }],
         [["--install-extension"],
         { "action": "append",
           "dest": "extensionsToInstall",
           "help": "install the specified extension in the testing profile."
                  "The extension file's name should be <id>.xpi where <id> is"
                  "the extension's id as indicated in its install.rdf."
                  "An optional path can be specified too.",
           "default": [],
         }],
         [["--profile-path"],
         { "action": "store",
           "type": "string",
           "dest": "profilePath",
           "help": "Directory where the profile will be stored."
                  "This directory will be deleted after the tests are finished",
           "default": tempfile.mkdtemp(),
         }],
         [["--testing-modules-dir"],
         { "action": "store",
           "type": "string",
           "dest": "testingModulesDir",
           "help": "Directory where testing-only JS modules are located.",
           "default": None,
         }],
         [["--use-vmware-recording"],
         { "action": "store_true",
           "dest": "vmwareRecording",
           "help": "enables recording while the application is running "
                  "inside a VMware Workstation 7.0 or later VM",
           "default": False,
         }],
         [["--repeat"],
         { "action": "store",
           "type": "int",
           "dest": "repeat",
           "metavar": "REPEAT",
           "help": "repeats the test or set of tests the given number of times, ie: repeat: 1 will run the test twice.",
           "default": 0,
         }],
         [["--run-until-failure"],
         { "action": "store_true",
           "dest": "runUntilFailure",
           "help": "Run tests repeatedly and stops on the first time a test fails. "
                 "Default cap is 30 runs, which can be overwritten with the --repeat parameter.",
           "default": False,
         }],
         [["--run-only-tests"],
         { "action": "store",
           "type": "string",
           "dest": "runOnlyTests",
           "help": "JSON list of tests that we only want to run. [DEPRECATED- please use --test-manifest]",
           "default": None,
         }],
         [["--test-manifest"],
         { "action": "store",
           "type": "string",
           "dest": "testManifest",
           "help": "JSON list of tests to specify 'runtests'. Old format for mobile specific tests",
           "default": None,
         }],
         [["--manifest"],
         { "action": "store",
           "type": "string",
           "dest": "manifestFile",
           "help": ".ini format of tests to run.",
           "default": None,
         }],
         [["--failure-file"],
         { "action": "store",
           "type": "string",
           "dest": "failureFile",
           "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.",
           "default": None,
         }],
         [["--run-slower"],
         { "action": "store_true",
           "dest": "runSlower",
           "help": "Delay execution between test files.",
           "default": False,
         }],
         [["--metro-immersive"],
         { "action": "store_true",
           "dest": "immersiveMode",
           "help": "launches tests in immersive browser",
           "default": False,
         }],
         [["--httpd-path"],
         { "action": "store",
           "type": "string",
           "dest": "httpdPath",
           "default": None,
           "help": "path to the httpd.js file",
         }],
         [["--setpref"],
         { "action": "append",
           "type": "string",
           "default": [],
           "dest": "extraPrefs",
           "metavar": "PREF=VALUE",
           "help": "defines an extra user preference",
         }],
         [["--jsdebugger"],
         { "action": "store_true",
           "default": False,
           "dest": "jsdebugger",
           "help": "open the browser debugger",
         }],
         [["--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."
         }],
         [["--e10s"],
         { "action": "store_true",
           "default": False,
           "dest": "e10s",
           "help": "Run tests with electrolysis preferences and test filtering enabled.",
         }],
         [["--dmd-path"],
          { "action": "store",
            "default": None,
            "dest": "dmdPath",
            "help": "Specifies the path to the directory containing the shared library for DMD.",
         }],
         [["--dump-output-directory"],
          { "action": "store",
            "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": "Produce an about:memory dump after each test in the directory specified "
                   "by --dump-output-directory."
         }],
         [["--dump-dmd-after-test"],
          { "action": "store_true",
            "default": False,
            "dest": "dumpDMDAfterTest",
            "help": "Produce a DMD dump after each test in the directory specified "
                   "by --dump-output-directory."
         }],
         [["--slowscript"],
          { "action": "store_true",
            "default": False,
            "dest": "slowscript",
            "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",
            "default": False,
            "dest": "quiet",
            "help": "Do not print test log lines unless a failure occurs."
          }],
         [["--pidfile"],
         { "action": "store",
           "type": "string",
           "dest": "pidFile",
           "help": "name of the pidfile to generate",
           "default": "",
         }],
     ]
     def __init__(self, **kwargs):
         optparse.OptionParser.__init__(self, **kwargs)
         for option, value in self.mochitest_options:
             self.add_option(*option, **value)
         addCommonOptions(self)
         self.set_usage(self.__doc__)
     def verifyOptions(self, options, mochitest):
         """ verify correct options and cleanup paths """
         mozinfo.update({"e10s": options.e10s}) # for test manifest parsing.
         if options.app is None:
             if build_obj is not None:
                 options.app = build_obj.get_binary_path()
             else:
                 self.error("could not find the application path, --appname must be specified")
         if options.totalChunks is not None and options.thisChunk is None:
             self.error("thisChunk must be specified when totalChunks is specified")
         if options.totalChunks:
             if not 1 <= options.thisChunk <= options.totalChunks:
                 self.error("thisChunk must be between 1 and totalChunks")
         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 != self.defaults['app']:
                 options.xrePath = os.path.dirname(options.app)
             elif build_obj is not None:
                 # otherwise default to dist/bin
                 options.xrePath = build_obj.bindir
             else:
                 self.error("could not find xre directory, --xre-path must be specified")
         # allow relative paths
         options.xrePath = mochitest.getFullPath(options.xrePath)
         options.profilePath = mochitest.getFullPath(options.profilePath)
         options.app = mochitest.getFullPath(options.app)
         if options.dmdPath is not None:
             options.dmdPath = mochitest.getFullPath(options.dmdPath)
         if not os.path.exists(options.app):
             msg = """\
             Error: Path %(app)s doesn't exist.
             Are you executing $objdir/_tests/testing/mochitest/runtests.py?"""
             self.error(msg % {"app": options.app})
             return None
         if options.utilityPath:
             options.utilityPath = mochitest.getFullPath(options.utilityPath)
         if options.certPath:
             options.certPath = mochitest.getFullPath(options.certPath)
         if options.symbolsPath and not isURL(options.symbolsPath):
             options.symbolsPath = mochitest.getFullPath(options.symbolsPath)
         # Set server information on the options object
         options.webServer = '127.0.0.1'
         options.httpPort = DEFAULT_PORTS['http']
         options.sslPort = DEFAULT_PORTS['https']
         #        options.webSocketPort = DEFAULT_PORTS['ws']
         options.webSocketPort = str(9988) # <- http://hg.mozilla.org/mozilla-central/file/b871dfb2186f/build/automation.py.in#l30
         # 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
         if options.vmwareRecording:
             if not mozinfo.isWin:
                 self.error("use-vmware-recording is only supported on Windows.")
             mochitest.vmwareHelperPath = os.path.join(
                 options.utilityPath, VMWARE_RECORDING_HELPER_BASENAME + ".dll")
             if not os.path.exists(mochitest.vmwareHelperPath):
                 self.error("%s not found, cannot automate VMware recording." %
                            mochitest.vmwareHelperPath)
         if options.testManifest and options.runOnlyTests:
             self.error("Please use --test-manifest only and not --run-only-tests")
         if options.runOnlyTests:
             if not os.path.exists(os.path.abspath(os.path.join(here, options.runOnlyTests))):
                 self.error("unable to find --run-only-tests file '%s'" % options.runOnlyTests)
             options.runOnly = True
             options.testManifest = options.runOnlyTests
             options.runOnlyTests = None
         if options.manifestFile and options.testManifest:
             self.error("Unable to support both --manifest and --test-manifest/--run-only-tests at the same time")
         if options.webapprtContent and options.webapprtChrome:
             self.error("Only one of --webapprt-content and --webapprt-chrome may be given.")
         if options.jsdebugger:
             options.extraPrefs += [
                 "devtools.debugger.remote-enabled=true",
                 "devtools.debugger.chrome-enabled=true",
                 "devtools.chrome.enabled=true",
                 "devtools.debugger.prompt-connection=false"
             ]
             options.autorun = False
         if options.debugOnFailure and not options.jsdebugger:
           self.error("--debug-on-failure should be used together with --jsdebugger.")
         # 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.
         if options.testingModulesDir is None:
             possible = os.path.join(here, os.path.pardir, 'modules')
             if os.path.isdir(possible):
                 options.testingModulesDir = possible
         # 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):
                 self.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:
                 self.error("immersive is only supported on Windows 8 and up.")
             mochitest.immersiveHelperPath = os.path.join(
                 options.utilityPath, "metrotestharness.exe")
             if not os.path.exists(mochitest.immersiveHelperPath):
                 self.error("%s not found, cannot launch immersive tests." %
                            mochitest.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):
                 self.error('--dump-output-directory not a directory: %s' %
                            options.dumpOutputDirectory)
         return options
 class B2GOptions(MochitestOptions):
     b2g_options = [
         [["--b2gpath"],
         { "action": "store",
           "type": "string",
           "dest": "b2gPath",
           "help": "path to B2G repo or qemu dir",
           "default": None,
         }],
         [["--desktop"],
         { "action": "store_true",
           "dest": "desktop",
           "help": "Run the tests on a B2G desktop build",
           "default": False,
         }],
         [["--marionette"],
         { "action": "store",
           "type": "string",
           "dest": "marionette",
           "help": "host:port to use when connecting to Marionette",
           "default": None,
         }],
         [["--emulator"],
         { "action": "store",
           "type": "string",
           "dest": "emulator",
           "help": "Architecture of emulator to use: x86 or arm",
           "default": None,
         }],
         [["--wifi"],
         { "action": "store",
           "type": "string",
           "dest": "wifi",
           "help": "Devine wifi configuration for on device mochitest",
           "default": False,
         }],
         [["--sdcard"],
         { "action": "store",
           "type": "string",
           "dest": "sdcard",
           "help": "Define size of sdcard: 1MB, 50MB...etc",
           "default": "10MB",
         }],
         [["--no-window"],
         { "action": "store_true",
           "dest": "noWindow",
           "help": "Pass --no-window to the emulator",
           "default": False,
         }],
         [["--adbpath"],
         { "action": "store",
           "type": "string",
           "dest": "adbPath",
           "help": "path to adb",
           "default": "adb",
         }],
         [["--deviceIP"],
         { "action": "store",
           "type": "string",
           "dest": "deviceIP",
           "help": "ip address of remote device to test",
           "default": None,
         }],
         [["--devicePort"],
         { "action": "store",
           "type": "string",
           "dest": "devicePort",
           "help": "port of remote device to test",
           "default": 20701,
         }],
         [["--remote-logfile"],
         { "action": "store",
           "type": "string",
           "dest": "remoteLogFile",
           "help": "Name of log file on the device relative to the device root. \
                   PLEASE ONLY USE A FILENAME.",
           "default" : None,
         }],
         [["--remote-webserver"],
         { "action": "store",
           "type": "string",
           "dest": "remoteWebServer",
           "help": "ip address where the remote web server is hosted at",
           "default": None,
         }],
         [["--http-port"],
         { "action": "store",
           "type": "string",
           "dest": "httpPort",
           "help": "ip address where the remote web server is hosted at",
           "default": None,
         }],
         [["--ssl-port"],
         { "action": "store",
           "type": "string",
           "dest": "sslPort",
           "help": "ip address where the remote web server is hosted at",
           "default": None,
         }],
         [["--gecko-path"],
         { "action": "store",
           "type": "string",
           "dest": "geckoPath",
           "help": "the path to a gecko distribution that should \
                    be installed on the emulator prior to test",
           "default": None,
         }],
         [["--profile"],
         { "action": "store",
           "type": "string",
           "dest": "profile",
           "help": "for desktop testing, the path to the \
                    gaia profile to use",
           "default": None,
         }],
         [["--logcat-dir"],
         { "action": "store",
           "type": "string",
           "dest": "logcat_dir",
           "help": "directory to store logcat dump files",
           "default": None,
         }],
         [['--busybox'],
         { "action": 'store',
           "type": 'string',
           "dest": 'busybox',
           "help": "Path to busybox binary to install on device",
           "default": None,
         }],
         [['--profile-data-dir'],
         { "action": 'store',
           "type": 'string',
           "dest": 'profile_data_dir',
           "help": "Path to a directory containing preference and other \
                    data to be installed into the profile",
           "default": os.path.join(here, 'profile_data'),
         }],
     ]
     def __init__(self):
         MochitestOptions.__init__(self)
         for option in self.b2g_options:
             self.add_option(*option[0], **option[1])
         defaults = {}
         defaults["httpPort"] = DEFAULT_PORTS['http']
         defaults["sslPort"] = DEFAULT_PORTS['https']
         defaults["remoteTestRoot"] = "/data/local/tests"
         defaults["logFile"] = "mochitest.log"
         defaults["autorun"] = True
         defaults["closeWhenDone"] = True
         defaults["testPath"] = ""
         defaults["extensionsToExclude"] = ["specialpowers"]
         self.set_defaults(**defaults)
     def verifyRemoteOptions(self, options):
         if options.remoteWebServer == None:
             if os.name != "nt":
                 options.remoteWebServer = moznetwork.get_ip()
             else:
                 self.error("You must specify a --remote-webserver=<ip address>")
         options.webServer = options.remoteWebServer
         if options.geckoPath and not options.emulator:
             self.error("You must specify --emulator if you specify --gecko-path")
         if options.logcat_dir and not options.emulator:
             self.error("You must specify --emulator if you specify --logcat-dir")
         if not os.path.isdir(options.xrePath):
             self.error("--xre-path '%s' is not a directory" % options.xrePath)
         xpcshell = os.path.join(options.xrePath, 'xpcshell')
         if not os.access(xpcshell, os.F_OK):
             self.error('xpcshell not found at %s' % xpcshell)
         if self.elf_arm(xpcshell):
             self.error('--xre-path points to an ARM version of xpcshell; it '
                        'should instead point to a version that can run on '
                        'your desktop')
         if options.pidFile != "":
             f = open(options.pidFile, 'w')
             f.write("%s" % os.getpid())
             f.close()
         return options
     def verifyOptions(self, options, mochitest):
         # since we are reusing verifyOptions, it will exit if App is not found
         temp = options.app
         options.app = __file__
         tempPort = options.httpPort
         tempSSL = options.sslPort
         tempIP = options.webServer
         options = MochitestOptions.verifyOptions(self, options, mochitest)
         options.webServer = tempIP
         options.app = temp
         options.sslPort = tempSSL
         options.httpPort = tempPort
         return options
     def elf_arm(self, filename):
         data = open(filename, 'rb').read(20)
         return data[:4] == "\x7fELF" and ord(data[18]) == 40 # EM_ARM

The Tor Browser / annotate

testing/mochitest/mochitest_options.py@6474c204b198 (annotated)

testing/mochitest/mochitest_options.py