Android: first step into making "perf tests" reuse the functional test infra.

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.
@@ skipping 10 matching lines @@
 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.perf import setup as perf_setup
+from pylib.perf import test_options as perf_test_options
+from pylib.perf import test_runner as perf_test_runner
 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 370 matching lines @@
       options.verbose_count,
       options.package_name,
       options.activity_name,
       options.event_count,
       category,
       options.throttle,
       options.seed,
       options.extra_args)
 
 
+def AddPerfTestOptions(option_parser):
+  """Adds perf test options to |option_parser|."""
+
+  option_parser.usage = '%prog perf [options]'
+  option_parser.command_list = []
+  option_parser.example = ('%prog perf --steps perf_steps.json')
+
+  option_parser.add_option('--steps', help='JSON file containing the list '
+      'of perf steps to run.')
+  option_parser.add_option('--flaky-steps',
+                           help='A JSON file containing steps that are flaky '
+                                'and will have its exit code ignored.')
+  option_parser.add_option('--print-step', help='The name of a previously '
+      'executed perf step to print.')
+
+  AddCommonOptions(option_parser)
+
+
+def ProcessPerfTestOptions(options, error_func):
+  """Processes all perf test options.
+
+  Args:
+    options: optparse.Options object.
+    error_func: Function to call with the error message in case of an error.
+
+  Returns:
+    A PerfOptions named tuple which contains all options relevant to
+    perf tests.
+  """
+  if not options.steps and not options.print_step:
+    error_func('Please specify --steps or --print-step')
+  return perf_test_options.PerfOptions(
+      options.steps, options.flaky_steps, options.print_step)
+
+
+
 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 115 matching lines @@
 
   report_results.LogFull(
       results=results,
       test_type='Monkey',
       test_package='Monkey',
       build_type=options.build_type)
 
   return exit_code
 
 
+def _RunPerfTests(options, error_func):
+  """Subcommand of RunTestsCommands which runs perf tests."""
+  perf_options = ProcessPerfTestOptions(options, error_func)
+    # Just print the results from a single previously executed step.
+  if perf_options.print_step:
+    return perf_test_runner.PrintTestOutput(perf_options.print_step)
+
+  runner_factory, tests = perf_setup.Setup(perf_options)
+
+  results, exit_code = test_dispatcher.RunTests(
+      tests, runner_factory, False, None, shard=True, test_timeout=None)
+
+  report_results.LogFull(
+      results=results,
+      test_type='Perf',
+      test_package='Perf',
+      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 14 matching lines @@
   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)
+  elif command == 'perf':
+    return _RunPerfTests(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 38 matching lines @@
 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),
+    'perf': CommandFunctionTuple(
+        AddPerfTestOptions, 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 27 matching lines @@
     option_parser.error('Invalid command.')
   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))