Switch monkey test to platform mode.

build/android/test_runner.py

 #!/usr/bin/env python
 #
 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Runs all types of tests from one unified interface."""
 
 import argparse
 import collections
@@ skipping 18 matching lines @@
 from pylib import constants
 from pylib.base import base_test_result
 from pylib.base import environment_factory
 from pylib.base import test_dispatcher
 from pylib.base import test_instance_factory
 from pylib.base import test_run_factory
 from pylib.constants import host_paths
 from pylib.linker import setup as linker_setup
 from pylib.junit import setup as junit_setup
 from pylib.junit import test_dispatcher as junit_dispatcher
-from pylib.monkey import setup as monkey_setup
-from pylib.monkey import test_options as monkey_test_options
 from pylib.results import json_results
 from pylib.results import report_results
 
 
 _DEVIL_STATIC_CONFIG_FILE = os.path.abspath(os.path.join(
     host_paths.DIR_SOURCE_ROOT, 'build', 'android', 'devil_config.json'))
 
 
 def AddCommonOptions(parser):
   """Adds all common options to |parser|."""
@@ skipping 365 matching lines @@
       '--coverage-dir', dest='coverage_dir', type=os.path.realpath,
       help='Directory to store coverage info.')
   AddCommonOptions(parser)
 
 
 def AddMonkeyTestOptions(parser):
   """Adds monkey test options to |parser|."""
 
   group = parser.add_argument_group('Monkey Test Options')
   group.add_argument(
-      '--package', required=True, choices=constants.PACKAGE_INFO.keys(),
-      metavar='PACKAGE', help='Package under test.')
+      '--browser', required=True, choices=constants.PACKAGE_INFO.keys(),
+      metavar='BROWSER', help='Browser under test.')
   group.add_argument(
       '--event-count', default=10000, type=int,
       help='Number of events to generate (default: %(default)s).')
   group.add_argument(
-      '--category', default='',
-      help='A list of allowed categories.')
+      '--category', nargs='*', dest='categories', default=[],
+      help='A list of allowed categories. Monkey will only visit activities '
+           'that are listed with one of the specified categories.')
   group.add_argument(
       '--throttle', default=100, type=int,
       help='Delay between events (ms) (default: %(default)s). ')
   group.add_argument(
       '--seed', type=int,
-      help=('Seed value for pseudo-random generator. Same seed value generates '
-            'the same sequence of events. Seed is randomized by default.'))
+      help='Seed value for pseudo-random generator. Same seed value generates '
+           'the same sequence of events. Seed is randomized by default.')
   group.add_argument(
-      '--extra-args', default='',
-      help=('String of other args to pass to the command verbatim.'))
-
+      '--repeat', dest='repeat', type=int, default=0,
+      help='Number of times to repeat the specified set of tests.')
+  group.add_argument(
+      '--break-on-failure', '--break_on_failure',
+      dest='break_on_failure', action='store_true',
+      help='Whether to break on failure.')
   AddCommonOptions(parser)
   AddDeviceOptions(parser)
 
-def ProcessMonkeyTestOptions(args):
-  """Processes all monkey test options.
-
-  Args:
-    args: argparse.Namespace object.
-
-  Returns:
-    A MonkeyOptions named tuple which contains all options relevant to
-    monkey tests.
-  """
-  # TODO(jbudorick): Handle this directly in argparse with nargs='+'
-  category = args.category
-  if category:
-    category = args.category.split(',')
-
-  # TODO(jbudorick): Get rid of MonkeyOptions.
-  return monkey_test_options.MonkeyOptions(
-      args.verbose_count,
-      args.package,
-      args.event_count,
-      category,
-      args.throttle,
-      args.seed,
-      args.extra_args)
-
 
 def AddPerfTestOptions(parser):
   """Adds perf test options to |parser|."""
 
   group = parser.add_argument_group('Perf Test Options')
 
   class SingleStepAction(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
       if values and not namespace.single_step:
         parser.error('single step command provided, '
@@ skipping 115 matching lines @@
       results=results,
       test_type='JUnit',
       test_package=args.test_suite)
 
   if args.json_results_file:
     json_results.GenerateJsonResultsFile([results], args.json_results_file)
 
   return exit_code
 
 
-def _RunMonkeyTests(args, devices):
-  """Subcommand of RunTestsCommands which runs monkey tests."""
-  monkey_options = ProcessMonkeyTestOptions(args)
-
-  runner_factory, tests = monkey_setup.Setup(monkey_options)
-
-  results, exit_code = test_dispatcher.RunTests(
-      tests, runner_factory, devices, shard=False, test_timeout=None,
-      num_retries=args.num_retries)
-
-  report_results.LogFull(
-      results=results,
-      test_type='Monkey',
-      test_package='Monkey')
-
-  if args.json_results_file:
-    json_results.GenerateJsonResultsFile([results], args.json_results_file)
-
-  return exit_code
-
-
 def _RunPythonTests(args):
   """Subcommand of RunTestsCommand which runs python unit tests."""
   suite_vars = constants.PYTHON_UNIT_TEST_SUITES[args.suite_name]
   suite_path = suite_vars['path']
   suite_test_modules = suite_vars['test_modules']
 
   sys.path = [suite_path] + sys.path
   try:
     suite = unittest.TestSuite()
     suite.addTests(unittest.defaultTestLoader.loadTestsFromName(m)
@@ skipping 29 matching lines @@
           'Did not find device %s among attached device. Attached devices: %s'
           % (test_device, ', '.join(attached_devices)))
     return test_device
 
   else:
     if not attached_devices:
       raise device_errors.NoDevicesError()
     return sorted(attached_devices)
 
 
-_DEFAULT_PLATFORM_MODE_TESTS = ['gtest', 'instrumentation', 'perf']
+_DEFAULT_PLATFORM_MODE_TESTS = ['gtest', 'instrumentation', 'monkey', 'perf']
 
 
 def RunTestsCommand(args): # pylint: disable=too-many-return-statements
   """Checks test type and dispatches to the appropriate function.
 
   Args:
     args: argparse.Namespace object.
 
   Returns:
     Integer indicated exit code.
@@ skipping 19 matching lines @@
   # pylint: enable=protected-access
 
   def get_devices():
     return _GetAttachedDevices(args.blacklist_file, args.test_device,
                                args.enable_device_cache, args.num_retries)
 
   if command == 'linker':
     return _RunLinkerTests(args, get_devices())
   elif command == 'junit':
     return _RunJUnitTests(args)
-  elif command == 'monkey':
-    return _RunMonkeyTests(args, get_devices())
   elif command == 'python':
     return _RunPythonTests(args)
   else:
     raise Exception('Unknown test type.')
 
 
 _SUPPORTED_IN_PLATFORM_MODE = [
   # TODO(jbudorick): Add support for more test types.
   'gtest',
   'instrumentation',
   'junit',
+  'monkey',
   'perf',
 ]
 
 
 def RunTestsInPlatformMode(args):
 
   def infra_error(message):
     logging.fatal(message)
     sys.exit(constants.INFRA_EXIT_CODE)
 
@@ skipping 138 matching lines @@
     if e.is_infra_error:
       return constants.INFRA_EXIT_CODE
     return constants.ERROR_EXIT_CODE
   except: # pylint: disable=W0702
     logging.exception('Unrecognized error occurred.')
     return constants.ERROR_EXIT_CODE
 
 
 if __name__ == '__main__':
   sys.exit(main())