[Android] Converts host driven tests to common test_dispatcher

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 run_python_tests as python_dispatch
+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.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')
 
@@ skipping 115 matching lines @@
   option_parser.add_option(
       '-A', '--annotation', dest='annotation_str',
       help=('Comma-separated list of annotations. Run only tests with any of '
             'the given annotations. An annotation can be either a key or a '
             'key-values pair. A test that has no annotation is considered '
             '"SmallTest".'))
   option_parser.add_option(
       '-E', '--exclude-annotation', dest='exclude_annotation_str',
       help=('Comma-separated list of annotations. Exclude tests with these '
             'annotations.'))
-  option_parser.add_option('-j', '--java_only', action='store_true',
-                           default=False, help='Run only the Java tests.')
-  option_parser.add_option('-p', '--python_only', action='store_true',
-                           default=False,
-                           help='Run only the host-driven tests.')
   option_parser.add_option('--screenshot', dest='screenshot_failures',
                            action='store_true',
                            help='Capture screenshots of test failures')
   option_parser.add_option('--save-perf-json', action='store_true',
                            help='Saves the JSON file for each UI Perf test.')
-  option_parser.add_option('--official-build', help='Run official build tests.')
-  option_parser.add_option('--python_test_root',
-                           help='Root of the host-driven tests.')
+  option_parser.add_option('--official-build', action='store_true',
+                           help='Run official build tests.')
   option_parser.add_option('--keep_test_server_ports',
                            action='store_true',
                            help=('Indicates the test server ports must be '
                                  'kept. When this is run via a sharder '
                                  'the test server ports should be kept and '
                                  'should not be reset.'))
   # TODO(gkanwar): This option is deprecated. Remove it in the future.
   option_parser.add_option('--disable_assertions', action='store_true',
                            help=('(DEPRECATED) Run with java assertions '
                                  'disabled.'))
   option_parser.add_option('--test_data', action='append', default=[],
                            help=('Each instance defines a directory of test '
                                  'data that should be copied to the target(s) '
                                  'before running the tests. The argument '
                                  'should be of the form <target>:<source>, '
                                  '<target> is relative to the device data'
                                  'directory, and <source> is relative to the '
                                  'chromium build directory.'))
 
 
 def ProcessJavaTestOptions(options, error_func):
   """Processes options/arguments and populates |options| with defaults."""
 
-  if options.java_only and options.python_only:
-    error_func('Options java_only (-j) and python_only (-p) '
-               'are mutually exclusive.')
-  options.run_java_tests = True
-  options.run_python_tests = True
-  if options.java_only:
-    options.run_python_tests = False
-  elif options.python_only:
-    options.run_java_tests = False
-
-  if not options.python_test_root:
-    options.run_python_tests = False
-
   if options.annotation_str:
     options.annotations = options.annotation_str.split(',')
   elif options.test_filter:
     options.annotations = []
   else:
     options.annotations = ['Smoke', 'SmallTest', 'MediumTest', 'LargeTest',
                            'EnormousTest']
 
   if options.exclude_annotation_str:
     options.exclude_annotations = options.exclude_annotation_str.split(',')
   else:
     options.exclude_annotations = []
 
   if not options.keep_test_server_ports:
     if not ports.ResetTestServerPortAllocation():
       raise Exception('Failed to reset test server port.')
 
 
 def AddInstrumentationTestOptions(option_parser):
   """Adds Instrumentation test options to |option_parser|."""
 
   option_parser.usage = '%prog instrumentation [options]'
   option_parser.command_list = []
   option_parser.example = ('%prog instrumentation '
                            '--test-apk=ChromiumTestShellTest')
 
   AddJavaTestOptions(option_parser)
   AddCommonOptions(option_parser)
 
+  option_parser.add_option('-j', '--java_only', action='store_true',
+                           default=False, help='Run only the Java tests.')
+  option_parser.add_option('-p', '--python_only', action='store_true',
+                           default=False,
+                           help='Run only the host-driven tests.')
+  option_parser.add_option('--python_test_root',
+                           help='Root of the host-driven tests.')
   option_parser.add_option('-w', '--wait_debugger', dest='wait_for_debugger',
                            action='store_true',
                            help='Wait for debugger.')
   #TODO(craigdh): Remove option once -I is no longer passed downstream.
   option_parser.add_option('-I', dest='install_apk', action='store_true',
                            help='(DEPRECATED) Install the test apk.')
   option_parser.add_option(
       '--test-apk', dest='test_apk',
       help=('The name of the apk containing the tests '
             '(without the .apk extension; e.g. "ContentShellTest"). '
             'Alternatively, this can be a full path to the apk.'))
 
 
 def ProcessInstrumentationOptions(options, error_func):
   """Processes options/arguments and populate |options| with defaults.
 
   Args:
     options: optparse.Options object.
     error_func: Function to call with the error message in case of an error.
 
   Returns:
     An InstrumentationOptions named tuple which contains all options relevant to
     instrumentation tests.
   """
 
   ProcessJavaTestOptions(options, error_func)
 
+  if options.java_only and options.python_only:
+    error_func('Options java_only (-j) and python_only (-p) '
+               'are mutually exclusive.')
+  options.run_java_tests = True
+  options.run_python_tests = True
+  if options.java_only:
+    options.run_python_tests = False
+  elif options.python_only:
+    options.run_java_tests = False
+
+  if not options.python_test_root:
+    options.run_python_tests = False
+
   if not options.test_apk:
     error_func('--test-apk must be specified.')
 
   if os.path.exists(options.test_apk):
     # The APK is fully qualified, assume the JAR lives along side.
     options.test_apk_path = options.test_apk
     options.test_apk_jar_path = (os.path.splitext(options.test_apk_path)[0] +
                                  '.jar')
   else:
     options.test_apk_path = os.path.join(_SDK_OUT_DIR,
@@ skipping 147 matching lines @@
         tests, runner_factory, options.wait_for_debugger,
         options.test_device,
         shard=True,
         build_type=options.build_type,
         test_timeout=None,
         num_retries=options.num_retries)
 
     results.AddTestRunResults(test_results)
 
   if options.run_python_tests:
-    test_results, test_exit_code = (
-        python_dispatch.DispatchPythonTests(options))
+    runner_factory, tests = host_driven_setup.InstrumentationSetup(
+        options.python_test_root, options.official_build,
+        instrumentation_options)
+
+    test_results, test_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)
 
     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)
 
   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
 
-  if options.run_java_tests:
-    runner_factory, tests = uiautomator_setup.Setup(uiautomator_options)
+  runner_factory, tests = uiautomator_setup.Setup(uiautomator_options)
 
-    test_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)
-
-    results.AddTestRunResults(test_results)
-
-  if options.run_python_tests:
-    test_results, test_exit_code = (
-        python_dispatch.DispatchPythonTests(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
+  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
@@ skipping 26 matching lines @@
 
   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)
   else:
     raise Exception('Unknown test type.')
 
-  return exit_code
-
 
 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.
     options: optparse options dictionary.
     args: List of extra args from optparse.
     option_parser: optparse.OptionParser object.
@@ skipping 81 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))