Bug 1050715 - Update the description of the various tests targed proposed by './mach help' r=jmaher
authorSylvestre Ledru <sledru@mozilla.com>
Sat, 09 Aug 2014 15:37:29 +0200
changeset 198768 7a51faeb82d838892b939cbed5c3def50421da0c
parent 198767 0d22e48a95012deeae5745c86fe82aab1bb1d7af
child 198769 ad8cb646fad6841c5d48dda77e374498e56f8d71
push id1
push userroot
push dateMon, 20 Oct 2014 17:29:22 +0000
reviewersjmaher
bugs1050715
milestone34.0a1
Bug 1050715 - Update the description of the various tests targed proposed by './mach help' r=jmaher
addon-sdk/mach_commands.py
build/valgrind/mach_commands.py
dom/bindings/mach_commands.py
layout/tools/reftest/mach_commands.py
python/mozbuild/mozbuild/mach_commands.py
testing/mach_commands.py
testing/marionette/mach_commands.py
testing/mochitest/mach_commands.py
testing/talos/mach_commands.py
testing/xpcshell/mach_commands.py
--- a/addon-sdk/mach_commands.py
+++ b/addon-sdk/mach_commands.py
@@ -21,17 +21,17 @@ from mach.decorators import (
 class JetpackRunner(MozbuildObject):
     """Run jetpack tests."""
     def run_tests(self, **kwargs):
         self._run_make(target='jetpack-tests')
 
 @CommandProvider
 class MachCommands(MachCommandBase):
     @Command('jetpack-test', category='testing',
-        description='Runs the jetpack test suite.')
+        description='Runs the jetpack test suite (Add-on SDK).')
     def run_jetpack_test(self, **params):
         # We should probably have a utility function to ensure the tree is
         # ready to run tests. Until then, we just create the state dir (in
         # case the tree wasn't built with mach).
         self._ensure_state_subdir_exists('.')
 
         jetpack = self._spawn(JetpackRunner)
 
--- a/build/valgrind/mach_commands.py
+++ b/build/valgrind/mach_commands.py
@@ -30,17 +30,17 @@ class MachCommands(MachCommandBase):
     '''
     Run Valgrind tests.
     '''
     def __init__(self, context):
         MachCommandBase.__init__(self, context)
 
     @Command('valgrind-test', category='testing',
         conditions=[conditions.is_firefox, is_valgrind_build],
-        description='Run the Valgrind test job.')
+        description='Run the Valgrind test job (memory-related errors).')
     @CommandArgument('--suppressions', default=[], action='append',
         metavar='FILENAME',
         help='Specify a suppression file for Valgrind to use. Use '
             '--suppression multiple times to specify multiple suppression '
             'files.')
     def valgrind_test(self, suppressions):
         import json
         import sys
--- a/dom/bindings/mach_commands.py
+++ b/dom/bindings/mach_commands.py
@@ -25,17 +25,17 @@ class WebIDLProvider(MachCommandBase):
     def webidl_example(self, interface):
         from mozwebidlcodegen import BuildSystemWebIDL
 
         manager = self._spawn(BuildSystemWebIDL).manager
         for i in interface:
             manager.generate_example_files(i)
 
     @Command('webidl-parser-test', category='testing',
-        description='Run WebIDL tests.')
+        description='Run WebIDL tests (Interface Browser parser).')
     @CommandArgument('--verbose', '-v', action='store_true',
         help='Run tests in verbose mode.')
     def webidl_test(self, verbose=False):
         sys.path.insert(0, os.path.join(self.topsrcdir, 'other-licenses',
             'ply'))
 
         # Make sure we drop our cached grammar bits in the objdir, not
         # wherever we happen to be running from.
--- a/layout/tools/reftest/mach_commands.py
+++ b/layout/tools/reftest/mach_commands.py
@@ -385,41 +385,41 @@ def B2GCommand(func):
             'executed.')
     func = path(func)
 
     return func
 
 
 @CommandProvider
 class MachCommands(MachCommandBase):
-    @Command('reftest', category='testing', description='Run reftests.')
+    @Command('reftest', category='testing', description='Run reftests (layout and graphics correctness).')
     @ReftestCommand
     def run_reftest(self, test_file, **kwargs):
         return self._run_reftest(test_file, suite='reftest', **kwargs)
 
     @Command('jstestbrowser', category='testing',
         description='Run js/src/tests in the browser.')
     @ReftestCommand
     def run_jstestbrowser(self, test_file, **kwargs):
         return self._run_reftest(test_file, suite='jstestbrowser', **kwargs)
 
     @Command('reftest-ipc', category='testing',
-        description='Run IPC reftests.')
+        description='Run IPC reftests (layout and graphics correctness, separate process).')
     @ReftestCommand
     def run_ipc(self, test_file, **kwargs):
         return self._run_reftest(test_file, suite='reftest-ipc', **kwargs)
 
     @Command('crashtest', category='testing',
-        description='Run crashtests.')
+        description='Run crashtests (Check if crashes on a page).')
     @ReftestCommand
     def run_crashtest(self, test_file, **kwargs):
         return self._run_reftest(test_file, suite='crashtest', **kwargs)
 
     @Command('crashtest-ipc', category='testing',
-        description='Run IPC crashtests.')
+        description='Run IPC crashtests (Check if crashes on a page, separate process).')
     @ReftestCommand
     def run_crashtest_ipc(self, test_file, **kwargs):
         return self._run_reftest(test_file, suite='crashtest-ipc', **kwargs)
 
     def _run_reftest(self, test_file=None, suite=None, **kwargs):
         reftest = self._spawn(ReftestRunner)
         return reftest.run_desktop_test(test_file, suite=suite, **kwargs)
 
@@ -435,31 +435,31 @@ def is_emulator(cls):
 class B2GCommands(MachCommandBase):
     def __init__(self, context):
         MachCommandBase.__init__(self, context)
 
         for attr in ('b2g_home', 'xre_path', 'device_name'):
             setattr(self, attr, getattr(context, attr, None))
 
     @Command('reftest-remote', category='testing',
-        description='Run a remote reftest.',
+        description='Run a remote reftest (b2g layout and graphics correctness, remote device).',
         conditions=[conditions.is_b2g, is_emulator])
     @B2GCommand
     def run_reftest_remote(self, test_file, **kwargs):
         return self._run_reftest(test_file, suite='reftest', **kwargs)
 
     @Command('reftest-b2g-desktop', category='testing',
-        description='Run a b2g desktop reftest.',
+        description='Run a b2g desktop reftest (b2g desktop layout and graphics correctness).',
         conditions=[conditions.is_b2g_desktop])
     @B2GCommand
     def run_reftest_b2g_desktop(self, test_file, **kwargs):
         return self._run_reftest(test_file, suite='reftest', **kwargs)
 
     @Command('crashtest-remote', category='testing',
-        description='Run a remote crashtest.',
+        description='Run a remote crashtest (Check if b2g crashes on a page, remote device).',
         conditions=[conditions.is_b2g, is_emulator])
     @B2GCommand
     def run_crashtest_remote(self, test_file, **kwargs):
         return self._run_reftest(test_file, suite='crashtest', **kwargs)
 
     def _run_reftest(self, test_file=None, suite=None, **kwargs):
         if self.device_name:
             if self.device_name.startswith('emulator'):
--- a/python/mozbuild/mozbuild/mach_commands.py
+++ b/python/mozbuild/mozbuild/mach_commands.py
@@ -613,17 +613,17 @@ class Warnings(MachCommandBase):
                     warning['column'], warning['flag'], warning['message']))
             else:
                 print('%s:%d [%s] %s' % (filename, warning['line'],
                     warning['flag'], warning['message']))
 
 @CommandProvider
 class GTestCommands(MachCommandBase):
     @Command('gtest', category='testing',
-        description='Run GTest unit tests.')
+        description='Run GTest unit tests (C++ tests).')
     @CommandArgument('gtest_filter', default=b"*", nargs='?', metavar='gtest_filter',
         help="test_filter is a ':'-separated list of wildcard patterns (called the positive patterns),"
              "optionally followed by a '-' and another ':'-separated pattern list (called the negative patterns).")
     @CommandArgument('--jobs', '-j', default='1', nargs='?', metavar='jobs', type=int,
         help='Run the tests in parallel using multiple processes.')
     @CommandArgument('--tbpl-parser', '-t', action='store_true',
         help='Output test results in a format that can be parsed by TBPL.')
     @CommandArgument('--shuffle', '-s', action='store_true',
--- a/testing/mach_commands.py
+++ b/testing/mach_commands.py
@@ -160,17 +160,17 @@ name or suite alias.
 
 The following test suites and aliases are supported: %s
 ''' % ', '.join(sorted(TEST_SUITES))
 TEST_HELP = TEST_HELP.strip()
 
 
 @CommandProvider
 class Test(MachCommandBase):
-    @Command('test', category='testing', description='Run tests.')
+    @Command('test', category='testing', description='Run tests (detects the kind of test and runs it).')
     @CommandArgument('what', default=None, nargs='*', help=TEST_HELP)
     def test(self, what):
         from mozbuild.testing import TestResolver
 
         # Parse arguments and assemble a test "plan."
         run_suites = set()
         run_tests = []
         resolver = self._spawn(TestResolver)
@@ -241,17 +241,17 @@ class Test(MachCommandBase):
                 status = res
 
         return status
 
 
 @CommandProvider
 class MachCommands(MachCommandBase):
     @Command('cppunittest', category='testing',
-        description='Run cpp unit tests.')
+        description='Run cpp unit tests (C++ tests).')
     @CommandArgument('test_files', nargs='*', metavar='N',
         help='Test to run. Can be specified as one or more files or ' \
             'directories, or omitted. If omitted, the entire test suite is ' \
             'executed.')
 
     def run_cppunit_test(self, **params):
         import runcppunittests as cppunittests
         import logging
@@ -275,17 +275,17 @@ class MachCommands(MachCommandBase):
                 {'exception': str(e)},
                 'Caught exception running cpp unit tests: {exception}')
             result = False
 
         return 0 if result else 1
 
 @CommandProvider
 class CheckSpiderMonkeyCommand(MachCommandBase):
-    @Command('check-spidermonkey', category='testing', description='Run SpiderMonkey tests.')
+    @Command('check-spidermonkey', category='testing', description='Run SpiderMonkey tests (JavaScript engine).')
     @CommandArgument('--valgrind', action='store_true', help='Run jit-test suite with valgrind flag')
 
     def run_checkspidermonkey(self, **params):
         import subprocess
         import sys
 
         bin_suffix = ''
         if sys.platform.startswith('win'):
--- a/testing/marionette/mach_commands.py
+++ b/testing/marionette/mach_commands.py
@@ -76,17 +76,17 @@ def run_marionette(tests, b2g_path=None,
 @CommandProvider
 class B2GCommands(MachCommandBase):
     def __init__(self, context):
         MachCommandBase.__init__(self, context)
 
         for attr in ('b2g_home', 'device_name'):
             setattr(self, attr, getattr(context, attr, None))
     @Command('marionette-webapi', category='testing',
-        description='Run a Marionette webapi test',
+        description='Run a Marionette webapi test (test WebAPIs using marionette).',
         conditions=[conditions.is_b2g])
     @CommandArgument('--type', dest='testtype',
         help='Test type, usually one of: browser, b2g, b2g-qemu.',
         default='b2g')
     @CommandArgument('tests', nargs='*', metavar='TESTS',
         help='Path to test(s) to run.')
     def run_marionette_webapi(self, tests, testtype=None):
         emulator = None
@@ -101,17 +101,17 @@ class B2GCommands(MachCommandBase):
             return 1
 
         return run_marionette(tests, b2g_path=self.b2g_home, emulator=emulator,
             testtype=testtype, topsrcdir=self.topsrcdir, address=None)
 
 @CommandProvider
 class MachCommands(MachCommandBase):
     @Command('marionette-test', category='testing',
-        description='Run a Marionette test.',
+        description='Run a Marionette test (Check UI or the internal JavaScript using marionette).',
         conditions=[conditions.is_firefox],
         parser=_parser,
     )
     @CommandArgument('--address',
         help='host:port of running Gecko instance to connect to.')
     @CommandArgument('--type', dest='testtype',
         help='Test type, usually one of: browser, b2g, b2g-qemu.',
         default='browser')
--- a/testing/mochitest/mach_commands.py
+++ b/testing/mochitest/mach_commands.py
@@ -602,73 +602,73 @@ def B2GCommand(func):
     return func
 
 
 
 @CommandProvider
 class MachCommands(MachCommandBase):
     @Command('mochitest-plain', category='testing',
         conditions=[conditions.is_firefox_or_mulet],
-        description='Run a plain mochitest.')
+        description='Run a plain mochitest (integration test, plain web page).')
     @MochitestCommand
     def run_mochitest_plain(self, test_paths, **kwargs):
         return self.run_mochitest(test_paths, 'plain', **kwargs)
 
     @Command('mochitest-chrome', category='testing',
         conditions=[conditions.is_firefox],
-        description='Run a chrome mochitest.')
+        description='Run a chrome mochitest (integration test with some XUL).')
     @MochitestCommand
     def run_mochitest_chrome(self, test_paths, **kwargs):
         return self.run_mochitest(test_paths, 'chrome', **kwargs)
 
     @Command('mochitest-browser', category='testing',
         conditions=[conditions.is_firefox],
-        description='Run a mochitest with browser chrome.')
+        description='Run a mochitest with browser chrome (integration test with a standard browser).')
     @MochitestCommand
     def run_mochitest_browser(self, test_paths, **kwargs):
         return self.run_mochitest(test_paths, 'browser', **kwargs)
 
     @Command('mochitest-devtools', category='testing',
         conditions=[conditions.is_firefox],
-        description='Run a devtools mochitest with browser chrome.')
+        description='Run a devtools mochitest with browser chrome (integration test with a standard browser with the devtools frame).')
     @MochitestCommand
     def run_mochitest_devtools(self, test_paths, **kwargs):
         return self.run_mochitest(test_paths, 'devtools', **kwargs)
 
     @Command('mochitest-metro', category='testing',
         conditions=[conditions.is_firefox],
-        description='Run a mochitest with metro browser chrome.')
+        description='Run a mochitest with metro browser chrome (tests for Windows touch interface).')
     @MochitestCommand
     def run_mochitest_metro(self, test_paths, **kwargs):
         return self.run_mochitest(test_paths, 'metro', **kwargs)
 
     @Command('mochitest-a11y', category='testing',
         conditions=[conditions.is_firefox],
-        description='Run an a11y mochitest.')
+        description='Run an a11y mochitest (accessibility tests).')
     @MochitestCommand
     def run_mochitest_a11y(self, test_paths, **kwargs):
         return self.run_mochitest(test_paths, 'a11y', **kwargs)
 
     @Command('webapprt-test-chrome', category='testing',
         conditions=[conditions.is_firefox],
-        description='Run a webapprt chrome mochitest.')
+        description='Run a webapprt chrome mochitest (Web App Runtime with the browser chrome).')
     @MochitestCommand
     def run_mochitest_webapprt_chrome(self, test_paths, **kwargs):
         return self.run_mochitest(test_paths, 'webapprt-chrome', **kwargs)
 
     @Command('webapprt-test-content', category='testing',
         conditions=[conditions.is_firefox],
-        description='Run a webapprt content mochitest.')
+        description='Run a webapprt content mochitest (Content rendering of the Web App Runtime).')
     @MochitestCommand
     def run_mochitest_webapprt_content(self, test_paths, **kwargs):
         return self.run_mochitest(test_paths, 'webapprt-content', **kwargs)
 
     @Command('mochitest', category='testing',
         conditions=[conditions.is_firefox],
-        description='Run any flavor of mochitest.')
+        description='Run any flavor of mochitest (integration test).')
     @MochitestCommand
     @CommandArgument('-f', '--flavor', choices=FLAVORS.keys(),
         help='Only run tests of this flavor.')
     def run_mochitest_general(self, test_paths, flavor=None, test_objects=None,
             **kwargs):
         self._preruntest()
 
         from mozbuild.testing import TestResolver
@@ -748,17 +748,17 @@ class B2GCommands(MachCommandBase):
     """
     def __init__(self, context):
         MachCommandBase.__init__(self, context)
 
         for attr in ('b2g_home', 'xre_path', 'device_name', 'get_build_var'):
             setattr(self, attr, getattr(context, attr, None))
 
     @Command('mochitest-remote', category='testing',
-        description='Run a remote mochitest.',
+        description='Run a remote mochitest (integration test for fennec/android).',
         conditions=[conditions.is_b2g, is_emulator])
     @B2GCommand
     def run_mochitest_remote(self, test_paths, **kwargs):
         if self.get_build_var:
             host_webapps_dir = os.path.join(self.get_build_var('TARGET_OUT_DATA'),
                                             'local', 'webapps')
             if not os.path.isdir(os.path.join(host_webapps_dir,
                                               'test-container.gaiamobile.org')):
@@ -779,17 +779,17 @@ class B2GCommands(MachCommandBase):
         driver.install_tests(remove=False)
 
         mochitest = self._spawn(MochitestRunner)
         return mochitest.run_b2g_test(b2g_home=self.b2g_home,
                 xre_path=self.xre_path, test_paths=test_paths, **kwargs)
 
     @Command('mochitest-b2g-desktop', category='testing',
         conditions=[conditions.is_b2g_desktop],
-        description='Run a b2g desktop mochitest.')
+        description='Run a b2g desktop mochitest (same as mochitest-plain but for b2g desktop).')
     @B2GCommand
     def run_mochitest_b2g_desktop(self, test_paths, **kwargs):
         kwargs['profile'] = kwargs.get('profile') or os.environ.get('GAIA_PROFILE')
         if not kwargs['profile'] or not os.path.isdir(kwargs['profile']):
             print(GAIA_PROFILE_NOT_FOUND % 'mochitest-b2g-desktop')
             return 1
 
         if os.path.isfile(os.path.join(kwargs['profile'], 'extensions',
--- a/testing/talos/mach_commands.py
+++ b/testing/talos/mach_commands.py
@@ -127,17 +127,17 @@ class TalosRunner(MozbuildObject):
         return talos_mh.run()
 
 @CommandProvider
 class MachCommands(MachCommandBase):
     mozharness_repo = 'https://hg.mozilla.org/build/mozharness'
     mozharness_rev = 'production'
 
     @Command('talos-test', category='testing',
-             description='Run talos tests.')
+             description='Run talos tests (performance testing).')
     @CommandArgument('suite', help='Talos test suite to run. Valid suites are '
                                    'chromez, dirtypaint, dromaeojs, other,'
                                    'svgr, rafx, tpn, tp5o, xperf.')
     @CommandArgument('--repo', default=mozharness_repo,
                      help='The mozharness repository to clone from. '
                           'Defaults to http://hg.mozilla.org/build/mozharness')
     @CommandArgument('--rev', default=mozharness_rev,
                      help='The mozharness revision to clone. Defaults to '
--- a/testing/xpcshell/mach_commands.py
+++ b/testing/xpcshell/mach_commands.py
@@ -411,17 +411,17 @@ class MachCommands(MachCommandBase):
     def __init__(self, context):
         MachCommandBase.__init__(self, context)
 
         for attr in ('b2g_home', 'device_name'):
             setattr(self, attr, getattr(context, attr, None))
 
     @Command('xpcshell-test', category='testing',
         conditions=[is_platform_supported],
-        description='Run XPCOM Shell tests.')
+        description='Run XPCOM Shell tests (API direct unit testing)')
     @CommandArgument('test_paths', default='all', nargs='*', metavar='TEST',
         help='Test to run. Can be specified as a single JS file, a directory, '
              'or omitted. If omitted, the entire test suite is executed.')
     @CommandArgument("--debugger", default=None, metavar='DEBUGGER',
                      help = "Run xpcshell under the given debugger.")
     @CommandArgument("--debugger-args", default=None, metavar='ARGS', type=str,
                      dest = "debuggerArgs",
                      help = "pass the given args to the debugger _before_ "