Makes host driven tests use the common sharder.

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 sys
 
 from pylib import cmd_helper
 from pylib import constants
 from pylib import ports
 from pylib.base import base_test_result
 from pylib.browsertests import dispatch as browsertests_dispatch
 from pylib.gtest import dispatch as gtest_dispatch
-from pylib.host_driven import run_python_tests as python_dispatch
+from pylib.host_driven import run_python_tests as host_driven_dispatch
 from pylib.instrumentation import dispatch as instrumentation_dispatch
 from pylib.uiautomator import dispatch as uiautomator_dispatch
-from pylib.utils import emulator, report_results, run_tests_helper
+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):
   """Adds the build type option to |option_parser|."""
   default_build_type = 'Debug'
   if 'BUILDTYPE' in os.environ:
     default_build_type = os.environ['BUILDTYPE']
   option_parser.add_option('--debug', action='store_const', const='Debug',
                            dest='build_type', default=default_build_type,
                            help=('If set, run test suites under out/Debug. '
                                  'Default is env var BUILDTYPE or Debug.'))
   option_parser.add_option('--release', action='store_const',
                            const='Release', dest='build_type',
                            help=('If set, run test suites under out/Release.'
                                  ' Default is env var BUILDTYPE or Debug.'))
 
 
-def AddEmulatorOptions(option_parser):
-  """Adds all emulator-related options to |option_parser|."""
-
-  # TODO(gkanwar): Figure out what we're doing with the emulator setup
-  # and determine whether these options should be deprecated/removed.
-  option_parser.add_option('-e', '--emulator', dest='use_emulator',
-                           action='store_true',
-                           help='Run tests in a new instance of emulator.')
-  option_parser.add_option('-n', '--emulator-count',
-                           type='int', default=1,
-                           help=('Number of emulators to launch for '
-                                 'running the tests.'))
-  option_parser.add_option('--abi', default='armeabi-v7a',
-                           help='Platform of emulators to launch.')
-
-
-def ProcessEmulatorOptions(options):
-  """Processes emulator options."""
-  if options.use_emulator:
-    emulator.DeleteAllTempAVDs()
-
-
 def AddCommonOptions(option_parser):
   """Adds all common options to |option_parser|."""
 
   AddBuildTypeOption(option_parser)
 
   option_parser.add_option('--out-directory', dest='out_directory',
                            help=('Path to the out/ directory, irrespective of '
                                  'the build type. Only for non-Chromium uses.'))
   option_parser.add_option('-c', dest='cleanup_test_files',
                            help='Cleanup test files on the device after run',
@@ skipping 42 matching lines @@
 
 def AddCoreGTestOptions(option_parser, default_timeout=60):
   """Add options specific to the gtest framework to |option_parser|."""
 
   # TODO(gkanwar): Consolidate and clean up test filtering for gtests and
   # content_browsertests.
   option_parser.add_option('--gtest_filter', dest='test_filter',
                            help='Filter GTests by name.')
   option_parser.add_option('-a', '--test_arguments', dest='test_arguments',
                            help='Additional arguments to pass to the test.')
-  # TODO(gkanwar): Most likely deprecate/remove this option once we've pinned
-  # down what we're doing with the emulator setup.
-  option_parser.add_option('-x', '--xvfb', dest='use_xvfb',
-                           action='store_true',
-                           help='Use Xvfb around tests (ignored if not Linux).')
   # TODO(gkanwar): Possible deprecate this flag. Waiting on word from Peter
   # Beverloo.
   option_parser.add_option('--webkit', action='store_true',
                            help='Run the tests from a WebKit checkout.')
   option_parser.add_option('--exe', action='store_true',
                            help='If set, use the exe test runner instead of '
                            'the APK.')
   option_parser.add_option('-t', dest='timeout',
                            help='Timeout to wait for each test',
                            type='int',
@@ skipping 17 matching lines @@
   option_parser.usage = '%prog gtest [options]'
   option_parser.command_list = []
   option_parser.example = '%prog gtest -s base_unittests'
 
   option_parser.add_option('-s', '--suite', dest='test_suite',
                            help=('Executable name of the test suite to run '
                                  '(use -s help to list them).'))
   AddCoreGTestOptions(option_parser)
   # TODO(gkanwar): Move these to Common Options once we have the plumbing
   # in our other test types to handle these commands
-  AddEmulatorOptions(option_parser)
   AddCommonOptions(option_parser)
 
 
 def AddJavaTestOptions(option_parser):
   """Adds the Java test options to |option_parser|."""
 
   option_parser.add_option('-f', '--test_filter', dest='test_filter',
                            help=('Test filter (if not fully qualified, '
                                  'will run all matches).'))
   option_parser.add_option(
@@ skipping 180 matching lines @@
     Integer indicated exit code.
 
   Raises:
     Exception: Unknown command name passed in, or an exception from an
         individual test runner.
   """
 
   ProcessCommonOptions(options)
 
   if command == 'gtest':
-    # TODO(gkanwar): See the emulator TODO above -- this call should either go
-    # away or become generalized.
-    ProcessEmulatorOptions(options)
-    results, exit_code = gtest_dispatch.Dispatch(options)
+    results, exit_code = gtest_dispatch.RunGTests(options)
   elif command == 'content_browsertests':
-    results, exit_code = browsertests_dispatch.Dispatch(options)
+    results, exit_code = browsertests_dispatch.RunContentBrowserTests(options)
   elif command == 'instrumentation':
     ProcessInstrumentationOptions(options, option_parser.error)
     results = base_test_result.TestRunResults()
     exit_code = 0
     if options.run_java_tests:
-      test_results, exit_code = instrumentation_dispatch.Dispatch(options)
+      test_results, exit_code = (instrumentation_dispatch.
+                                 RunInstrumentationTests(options))
       results.AddTestRunResults(test_results)
     if options.run_python_tests:
-      test_results, test_exit_code = (python_dispatch.
-                                      DispatchPythonTests(options))
+      test_results, test_exit_code = (host_driven_dispatch.
+                                      RunHostDrivenTests(options))
       results.AddTestRunResults(test_results)
       # Only allow exit code escalation
       if test_exit_code and exit_code != constants.ERROR_EXIT_CODE:
         exit_code = test_exit_code
     report_results.LogFull(
         results=results,
         test_type='Instrumentation',
         test_package=os.path.basename(options.test_apk),
         annotation=options.annotations,
         build_type=options.build_type,
         flakiness_server=options.flakiness_dashboard_server)
   elif command == 'uiautomator':
     ProcessUIAutomatorOptions(options, option_parser.error)
     results = base_test_result.TestRunResults()
     exit_code = 0
     if options.run_java_tests:
-      test_results, exit_code = uiautomator_dispatch.Dispatch(options)
+      test_results, exit_code = (uiautomator_dispatch.
+                                 RunUIAutomatorTests(options))
       results.AddTestRunResults(test_results)
     if options.run_python_tests:
-      test_results, test_exit_code = (python_dispatch.
-                                      DispatchPythonTests(options))
+      test_results, test_exit_code = (host_driven_dispatch.
+                                      RunHostDrivenTests(options))
       results.AddTestRunResults(test_results)
       # Only allow exit code escalation
       if test_exit_code and exit_code != constants.ERROR_EXIT_CODE:
         exit_code = test_exit_code
     report_results.LogFull(
         results=results,
         test_type='UIAutomator',
         test_package=os.path.basename(options.test_jar),
         annotation=options.annotations,
         build_type=options.build_type,
@@ skipping 95 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))