[Android] JUnit test runner changes.

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
@@ skipping 10 matching lines @@
 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.linker import setup as linker_setup
 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.junit import setup as junit_setup
+from pylib.junit import test_dispatcher as junit_dispatcher
 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 apk_helper
 from pylib.utils import command_option_parser
 from pylib.utils import report_results
@@ skipping 331 matching lines @@
       options.exclude_annotations,
       options.test_filter,
       options.test_data,
       options.save_perf_json,
       options.screenshot_failures,
       options.uiautomator_jar,
       options.uiautomator_info_jar,
       options.package)
 
 
+def AddJUnitTestOptions(option_parser):
+  option_parser.usage = '%prog junit -s [test suite name]'
+  option_parser.commands_dict = {}
+
+  option_parser.add_option(
+      '-s', '--test-suite', dest='test_suite',
+      help=('JUnit test suite to run.'))
+  option_parser.add_option(
+      '-f', '--test-filter', dest='test_filter',
+      help='Filters tests googletest-style.')
+  option_parser.add_option(
+      '--package-filter', dest='package_filter',
+      help='Filters tests by package.')
+  option_parser.add_option(
+      '--runner-filter', dest='runner_filter',
+      help='Filters tests by runner class. Must be fully qualified.')
+  option_parser.add_option(
+      '--sdk-version', dest='sdk_version', type="int",
+      help='The Android SDK version.')
+  AddCommonOptions(option_parser)
+
+
+def ProcessJUnitTestOptions(options, error_func):
+  """ Processes all JUnit test options. """
+  if not options.test_suite:
+    error_func('No test suite specified.')
+  return options
+
+
 def AddMonkeyTestOptions(option_parser):
   """Adds monkey test options to |option_parser|."""
 
   option_parser.usage = '%prog monkey [options]'
   option_parser.commands_dict = {}
   option_parser.example = (
       '%prog monkey --package=chrome_shell')
 
   option_parser.add_option(
       '--package',
@@ skipping 236 matching lines @@
   report_results.LogFull(
       results=results,
       test_type='UIAutomator',
       test_package=os.path.basename(options.test_jar),
       annotation=options.annotations,
       flakiness_server=options.flakiness_dashboard_server)
 
   return exit_code
 
 
+def _RunJUnitTests(options, error_func):
+  """Subcommand of RunTestsCommand which runs junit tests."""
+  junit_options = ProcessJUnitTestOptions(options, error_func)
+  runner_factory, tests = junit_setup.Setup(junit_options)
+  _, exit_code = junit_dispatcher.RunTests(tests, runner_factory)
+
+  return exit_code
+
+
 def _RunMonkeyTests(options, error_func, devices):
   """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, devices, shard=False, test_timeout=None,
       num_retries=options.num_retries)
 
@@ skipping 103 matching lines @@
     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)
   else:
     raise Exception('Unknown test type.')
 
 
 def HelpCommand(command, _options, args, option_parser):
   """Display help for a certain command, or overall help.
@@ skipping 40 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),
+    'junit': CommandFunctionTuple(
+        AddJUnitTestOptions, RunTestsCommand),
     'monkey': CommandFunctionTuple(
         AddMonkeyTestOptions, RunTestsCommand),
     'perf': CommandFunctionTuple(
         AddPerfTestOptions, 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())