Converts monkey test to its own test type

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.
 
 TODO(gkanwar):
 * Add options to run Monkey tests.
 """
 
 import collections
 import optparse
 import os
 import shutil
 import sys
 
 from pylib import constants
 from pylib import ports
 from pylib.base import base_test_result
 from pylib.base import test_dispatcher
 from pylib.gtest import gtest_config
 from pylib.gtest import setup as gtest_setup
 from pylib.gtest import test_options as gtest_test_options
 from pylib.host_driven import setup as host_driven_setup
 from pylib.instrumentation import setup as instrumentation_setup
 from pylib.instrumentation import test_options as instrumentation_test_options
+from pylib.monkey import setup as monkey_setup
+from pylib.monkey import test_options as monkey_test_options
 from pylib.uiautomator import setup as uiautomator_setup
 from pylib.uiautomator import test_options as uiautomator_test_options
 from pylib.utils import report_results
 from pylib.utils import run_tests_helper
 
 
 _SDK_OUT_DIR = os.path.join(constants.DIR_SOURCE_ROOT, 'out')
 
 
 def AddBuildTypeOption(option_parser):
@@ skipping 284 matching lines @@
 
 def ProcessUIAutomatorOptions(options, error_func):
   """Processes UIAutomator options/arguments.
 
   Args:
     options: optparse.Options object.
     error_func: Function to call with the error message in case of an error.
 
   Returns:
     A UIAutomatorOptions named tuple which contains all options relevant to
-    instrumentation tests.
+    uiautomator tests.
   """
 
   ProcessJavaTestOptions(options, error_func)
 
   if not options.package_name:
     error_func('--package-name must be specified.')
 
   if not options.test_jar:
     error_func('--test-jar must be specified.')
 
@@ skipping 18 matching lines @@
       options.test_filter,
       options.test_data,
       options.save_perf_json,
       options.screenshot_failures,
       options.disable_assertions,
       options.uiautomator_jar,
       options.uiautomator_info_jar,
       options.package_name)
 
 
+def AddMonkeyTestOptions(option_parser):
+  """Adds monkey test options to |option_parser|."""
+  option_parser.add_option('--package-name', help='Allowed package.')
+  option_parser.add_option(
+      '--activity-name', default='com.google.android.apps.chrome.Main',
+      help='Name of the activity to start [default: %default].')
+  option_parser.add_option(
+      '--event-count', default=10000, type='int',
+      help='Number of events to generate [default: %default].')
+  option_parser.add_option(
+      '--category', default='',
+      help='A list of allowed categories [default: %default].')
+  option_parser.add_option(
+      '--throttle', default=100, type='int',
+      help='Delay between events (ms) [default: %default]. ')
+  option_parser.add_option(
+      '--seed', type='int',
+      help=('Seed value for pseudo-random generator. Same seed value generates '
+            'the same sequence of events. Seed is randomized by default.'))
+  option_parser.add_option(
+      '--extra-args', default='',
+      help=('String of other args to pass to the command verbatim '
+            '[default: "%default"].'))
+
+  AddCommonOptions(option_parser)
+
+
+def ProcessMonkeyTestOptions(options, error_func):
+  """Processes all monkey test options.
+
+  Args:
+    options: optparse.Options object.
+    error_func: Function to call with the error message in case of an error.
+
+  Returns:
+    A MonkeyOptions named tuple which contains all options relevant to
+    monkey tests.
+  """
+  if not options.package_name:
+    error_func('Package name is required.')
+
+  category = options.category
+  if category:
+    category = options.category.split(',')
+
+  return monkey_test_options.MonkeyOptions(
+      options.build_type,
+      options.verbose_count,
+      options.package_name,
+      options.activity_name,
+      options.event_count,
+      category,
+      options.throttle,
+      options.seed,
+      options.extra_args)
+
+
 def _RunGTests(options, error_func):
   """Subcommand of RunTestsCommands which runs gtests."""
   ProcessGTestOptions(options)
 
   exit_code = 0
   for suite_name in options.suite_name:
     # TODO(gkanwar): Move this into ProcessGTestOptions once we require -s for
     # the gtest command.
     gtest_options = gtest_test_options.GTestOptions(
         options.build_type,
@@ skipping 77 matching lines @@
       build_type=options.build_type,
       flakiness_server=options.flakiness_dashboard_server)
 
   return exit_code
 
 
 def _RunUIAutomatorTests(options, error_func):
   """Subcommand of RunTestsCommands which runs uiautomator tests."""
   uiautomator_options = ProcessUIAutomatorOptions(options, error_func)
 
-  results = base_test_result.TestRunResults()
-  exit_code = 0
-
   runner_factory, tests = uiautomator_setup.Setup(uiautomator_options)
 
   results, exit_code = test_dispatcher.RunTests(
       tests, runner_factory, False, options.test_device,
       shard=True,
       build_type=options.build_type,
       test_timeout=None,
       num_retries=options.num_retries)
 
   report_results.LogFull(
       results=results,
       test_type='UIAutomator',
       test_package=os.path.basename(options.test_jar),
       annotation=options.annotations,
       build_type=options.build_type,
       flakiness_server=options.flakiness_dashboard_server)
 
   return exit_code
 
 
+def _RunMonkeyTests(options, error_func):
+  """Subcommand of RunTestsCommands which runs monkey tests."""
+  monkey_options = ProcessMonkeyTestOptions(options, error_func)
+
+  runner_factory, tests = monkey_setup.Setup(monkey_options)
+
+  results, exit_code = test_dispatcher.RunTests(
+      tests, runner_factory, False, None, shard=False)
+
+  report_results.LogFull(
+      results=results,
+      test_type='Monkey',
+      test_package='Monkey',
+      build_type=options.build_type)
+
+  return exit_code
+
+
+
 def RunTestsCommand(command, options, args, option_parser):
   """Checks test type and dispatches to the appropriate function.
 
   Args:
     command: String indicating the command that was received to trigger
         this function.
     options: optparse options dictionary.
     args: List of extra args from optparse.
     option_parser: optparse.OptionParser object.
 
@@ skipping 11 matching lines @@
     return constants.ERROR_EXIT_CODE
 
   ProcessCommonOptions(options)
 
   if command == 'gtest':
     return _RunGTests(options, option_parser.error)
   elif command == 'instrumentation':
     return _RunInstrumentationTests(options, option_parser.error)
   elif command == 'uiautomator':
     return _RunUIAutomatorTests(options, option_parser.error)
+  elif command == 'monkey':
+    return _RunMonkeyTests(options, option_parser.error)
   else:
     raise Exception('Unknown test type.')
 
 
 def HelpCommand(command, options, args, option_parser):
   """Display help for a certain command, or overall help.
 
   Args:
     command: String indicating the command that was received to trigger
         this function.
@@ skipping 36 matching lines @@
 # syntax is a bit prettier. The tuple is two functions: (add options, run
 # command).
 CommandFunctionTuple = collections.namedtuple(
     'CommandFunctionTuple', ['add_options_func', 'run_command_func'])
 VALID_COMMANDS = {
     'gtest': CommandFunctionTuple(AddGTestOptions, RunTestsCommand),
     'instrumentation': CommandFunctionTuple(
         AddInstrumentationTestOptions, RunTestsCommand),
     'uiautomator': CommandFunctionTuple(
         AddUIAutomatorTestOptions, RunTestsCommand),
+    'monkey': CommandFunctionTuple(
+        AddMonkeyTestOptions, RunTestsCommand),
     'help': CommandFunctionTuple(lambda option_parser: None, HelpCommand)
     }
 
 
 class CommandOptionParser(optparse.OptionParser):
   """Wrapper class for OptionParser to help with listing commands."""
 
   def __init__(self, *args, **kwargs):
     self.command_list = kwargs.pop('command_list', [])
     self.example = kwargs.pop('example', '')
@@ skipping 28 matching lines @@
     return 0
   command = argv[1]
   VALID_COMMANDS[command].add_options_func(option_parser)
   options, args = option_parser.parse_args(argv)
   return VALID_COMMANDS[command].run_command_func(
       command, options, args, option_parser)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))