Update from chromium https://crrev.com/301315

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 collections
 import logging
 import optparse
 import os
 import shutil
 import signal
 import sys
 import threading
+import unittest
 
 from pylib import android_commands
 from pylib import constants
 from pylib import forwarder
 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
@@ skipping 10 matching lines @@
 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 apk_helper
 from pylib.utils import command_option_parser
 from pylib.utils import report_results
 from pylib.utils import reraiser_thread
 from pylib.utils import run_tests_helper
 
 
+HOST_TESTS = ['junit', 'python']
+
+
 def AddCommonOptions(option_parser):
   """Adds all common options to |option_parser|."""
 
   group = optparse.OptionGroup(option_parser, 'Common Options')
   default_build_type = os.environ.get('BUILDTYPE', 'Debug')
   group.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.'))
   group.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.'))
   group.add_option('--build-directory', dest='build_directory',
                    help=('Path to the directory in which build files are'
                          ' located (should not include build type)'))
-  group.add_option('-c', dest='cleanup_test_files',
-                   help='Cleanup test files on the device after run',
-                   action='store_true')
   group.add_option('--num_retries', dest='num_retries', type='int',
                    default=2,
                    help=('Number of retries for a test before '
                          'giving up.'))
   group.add_option('-v',
                    '--verbose',
                    dest='verbose_count',
                    default=0,
                    action='count',
                    help='Verbose level (multiple times for more)')
-  group.add_option('--tool',
-                   dest='tool',
-                   help=('Run the test under a tool '
-                         '(use --tool help to list them)'))
   group.add_option('--flakiness-dashboard-server',
                    dest='flakiness_dashboard_server',
                    help=('Address of the server that is hosting the '
                          'Chrome for Android flakiness dashboard.'))
-  group.add_option('--skip-deps-push', dest='push_deps',
-                   action='store_false', default=True,
-                   help=('Do not push dependencies to the device. '
-                         'Use this at own risk for speeding up test '
-                         'execution on local machine.'))
-  group.add_option('-d', '--device', dest='test_device',
-                   help=('Target device for the test suite '
-                         'to run on.'))
   option_parser.add_option_group(group)
 
 
 def ProcessCommonOptions(options):
   """Processes and handles all common options."""
   run_tests_helper.SetLogLevel(options.verbose_count)
   constants.SetBuildType(options.build_type)
   if options.build_directory:
     constants.SetBuildDirectory(options.build_directory)
 
 
+def AddDeviceOptions(option_parser):
+  group = optparse.OptionGroup(option_parser, 'Device Options')
+  group.add_option('-c', dest='cleanup_test_files',
+                   help='Cleanup test files on the device after run',
+                   action='store_true')
+  group.add_option('--tool',
+                   dest='tool',
+                   help=('Run the test under a tool '
+                         '(use --tool help to list them)'))
+  group.add_option('--skip-deps-push', dest='push_deps',
+                   action='store_false', default=True,
+                   help=('Do not push dependencies to the device. '
+                         'Use this at own risk for speeding up test '
+                         'execution on local machine.'))
+  group.add_option('-d', '--device', dest='test_device',
+                   help=('Target device for the test suite '
+                         'to run on.'))
+  option_parser.add_option_group(group)
+
+
 def AddGTestOptions(option_parser):
   """Adds gtest options to |option_parser|."""
 
   option_parser.usage = '%prog gtest [options]'
   option_parser.commands_dict = {}
   option_parser.example = '%prog gtest -s base_unittests'
 
   # TODO(gkanwar): Make this option required
   option_parser.add_option('-s', '--suite', dest='suite_name',
                            help=('Executable name of the test suite to run '
@@ skipping 13 matching lines @@
                            type='int',
                            default=60)
   option_parser.add_option('--isolate_file_path',
                            '--isolate-file-path',
                            dest='isolate_file_path',
                            help='.isolate file path to override the default '
                                 'path')
   # TODO(gkanwar): Move these to Common Options once we have the plumbing
   # in our other test types to handle these commands
   AddCommonOptions(option_parser)
+  AddDeviceOptions(option_parser)
 
 
 def AddLinkerTestOptions(option_parser):
   option_parser.usage = '%prog linker'
   option_parser.commands_dict = {}
   option_parser.example = '%prog linker'
 
   option_parser.add_option('-f', '--gtest-filter', dest='test_filter',
                            help='googletest-style filter string.')
   AddCommonOptions(option_parser)
+  AddDeviceOptions(option_parser)
 
 
 def ProcessGTestOptions(options):
   """Intercept test suite help to list test suites.
 
   Args:
     options: Command line options.
   """
   if options.suite_name == 'help':
     print 'Available test suites are:'
@@ skipping 63 matching lines @@
 def AddInstrumentationTestOptions(option_parser):
   """Adds Instrumentation test options to |option_parser|."""
 
   option_parser.usage = '%prog instrumentation [options]'
   option_parser.commands_dict = {}
   option_parser.example = ('%prog instrumentation '
                            '--test-apk=ChromeShellTest')
 
   AddJavaTestOptions(option_parser)
   AddCommonOptions(option_parser)
+  AddDeviceOptions(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('--host-driven-root',
                            help='Root of the host-driven tests.')
   option_parser.add_option('-w', '--wait_debugger', dest='wait_for_debugger',
                            action='store_true',
@@ skipping 88 matching lines @@
       help=('Package under test. Possible values: %s' %
             constants.PACKAGE_INFO.keys()))
   option_parser.add_option(
       '--test-jar', dest='test_jar',
       help=('The name of the dexed jar containing the tests (without the '
             '.dex.jar extension). Alternatively, this can be a full path '
             'to the jar.'))
 
   AddJavaTestOptions(option_parser)
   AddCommonOptions(option_parser)
+  AddDeviceOptions(option_parser)
 
 
 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:
@@ skipping 93 matching lines @@
   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)
+  AddDeviceOptions(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:
@@ skipping 53 matching lines @@
       help=('Do not impose a timeout. Each perf step is responsible for '
             'implementing the timeout logic.'))
   option_parser.add_option(
       '-f', '--test-filter',
       help=('Test filter (will match against the names listed in --steps).'))
   option_parser.add_option(
       '--dry-run',
       action='store_true',
       help='Just print the steps without executing.')
   AddCommonOptions(option_parser)
+  AddDeviceOptions(option_parser)
 
 
 def ProcessPerfTestOptions(options, args, 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.
   """
   # Only one of steps, print_step or single_step must be provided.
   count = len(filter(None,
                      [options.steps, options.print_step, options.single_step]))
   if count != 1:
     error_func('Please specify one of: --steps, --print-step, --single-step.')
   single_step = None
   if options.single_step:
     single_step = ' '.join(args[2:])
   return perf_test_options.PerfOptions(
       options.steps, options.flaky_steps, options.output_json_list,
       options.print_step, options.no_timeout, options.test_filter,
       options.dry_run, single_step)
 
 
+def AddPythonTestOptions(option_parser):
+  option_parser.add_option('-s', '--suite', dest='suite_name',
+                           help=('Name of the test suite to run'
+                                 '(use -s help to list them).'))
+  AddCommonOptions(option_parser)
+
+
+def ProcessPythonTestOptions(options, error_func):
+  if options.suite_name not in constants.PYTHON_UNIT_TEST_SUITES:
+    available = ('Available test suites: [%s]' %
+                 ', '.join(constants.PYTHON_UNIT_TEST_SUITES.iterkeys()))
+    if options.suite_name == 'help':
+      print available
+    else:
+      error_func('"%s" is not a valid suite. %s' %
+                 (options.suite_name, available))
+
+
 def _RunGTests(options, devices):
   """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.tool,
@@ skipping 170 matching lines @@
   if perf_options.single_step:
     return perf_test_runner.PrintTestOutput('single_step')
 
   perf_test_runner.PrintSummary(tests)
 
   # Always return 0 on the sharding stage. Individual tests exit_code
   # will be returned on the print_step stage.
   return 0
 
 
+def _RunPythonTests(options, error_func):
+  """Subcommand of RunTestsCommand which runs python unit tests."""
+  ProcessPythonTestOptions(options, error_func)
+
+  suite_vars = constants.PYTHON_UNIT_TEST_SUITES[options.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)
+                   for m in suite_test_modules)
+    runner = unittest.TextTestRunner(verbosity=1+options.verbose_count)
+    return 0 if runner.run(suite).wasSuccessful() else 1
+  finally:
+    sys.path = sys.path[1:]
+
+
 def _GetAttachedDevices(test_device=None):
   """Get all attached devices.
 
   Args:
     test_device: Name of a specific device to use.
 
   Returns:
     A list of attached devices.
   """
   attached_devices = []
@@ skipping 33 matching lines @@
     option_parser.error('Unrecognized arguments: %s' % (' '.join(args[2:])))
     return constants.ERROR_EXIT_CODE
   if command == 'perf':
     if ((options.single_step and len(args) <= 2) or
         (not options.single_step and len(args) > 2)):
       option_parser.error('Unrecognized arguments: %s' % (' '.join(args)))
       return constants.ERROR_EXIT_CODE
 
   ProcessCommonOptions(options)
 
-  devices = _GetAttachedDevices(options.test_device)
+  if command in HOST_TESTS:
+    devices = []
+  else:
+    devices = _GetAttachedDevices(options.test_device)
 
   forwarder.Forwarder.RemoveHostLog()
   if not ports.ResetTestServerPortAllocation():
     raise Exception('Failed to reset test server port.')
 
   if command == 'gtest':
     return _RunGTests(options, devices)
   elif command == 'linker':
     return _RunLinkerTests(options, devices)
   elif command == 'instrumentation':
     return _RunInstrumentationTests(options, option_parser.error, devices)
   elif command == 'uiautomator':
     return _RunUIAutomatorTests(options, option_parser.error, devices)
   elif command == 'junit':
     return _RunJUnitTests(options, option_parser.error)
   elif command == 'monkey':
     return _RunMonkeyTests(options, option_parser.error, devices)
   elif command == 'perf':
     return _RunPerfTests(options, args, option_parser.error)
+  elif command == 'python':
+    return _RunPythonTests(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 42 matching lines @@
     'instrumentation': CommandFunctionTuple(
         AddInstrumentationTestOptions, RunTestsCommand),
     'uiautomator': CommandFunctionTuple(
         AddUIAutomatorTestOptions, RunTestsCommand),
     'junit': CommandFunctionTuple(
         AddJUnitTestOptions, RunTestsCommand),
     'monkey': CommandFunctionTuple(
         AddMonkeyTestOptions, RunTestsCommand),
     'perf': CommandFunctionTuple(
         AddPerfTestOptions, RunTestsCommand),
+    'python': CommandFunctionTuple(
+        AddPythonTestOptions, RunTestsCommand),
     'linker': CommandFunctionTuple(
         AddLinkerTestOptions, RunTestsCommand),
     'help': CommandFunctionTuple(lambda option_parser: None, HelpCommand)
     }
 
 
 def DumpThreadStacks(_signal, _frame):
   for thread in threading.enumerate():
     reraiser_thread.LogThreadStack(thread)
 
 
 def main():
   signal.signal(signal.SIGUSR1, DumpThreadStacks)
   option_parser = command_option_parser.CommandOptionParser(
       commands_dict=VALID_COMMANDS)
   return command_option_parser.ParseAndExecute(option_parser)
 
 
 if __name__ == '__main__':
   sys.exit(main())