[Android] Implement generic JSON results that match base/test/launcher.

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 21 matching lines @@
 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.results import json_results
+from pylib.results import report_results
 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
 
 
 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',
@@ skipping 30 matching lines @@
                    help=('Run the test scripts in platform mode, which '
                          'conceptually separates the test runner from the '
                          '"device" (local or remote, real or emulated) on '
                          'which the tests are running. [experimental]'))
   group.add_option('-e', '--environment', default='local',
                    help=('Test environment to run in. Must be one of: %s' %
                          ', '.join(constants.VALID_ENVIRONMENTS)))
   group.add_option('--adb-path',
                    help=('Specify the absolute path of the adb binary that '
                          'should be used.'))
+  group.add_option('--json-results-file', dest='json_results_file',
+                   help='If set, will dump results in JSON format '
+                        'to specified file.')
   option_parser.add_option_group(group)
 
 
 def ProcessCommonOptions(options, error_func):
   """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)
   if options.output_directory:
@@ skipping 47 matching lines @@
                            help='Additional arguments to pass to the test.')
   option_parser.add_option('-t', dest='timeout',
                            help='Timeout to wait for each test',
                            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',
@@ skipping 455 matching lines @@
 
     if test_exit_code and exit_code != constants.ERROR_EXIT_CODE:
       exit_code = test_exit_code
 
     report_results.LogFull(
         results=results,
         test_type='Unit test',
         test_package=suite_name,
         flakiness_server=options.flakiness_dashboard_server)
 
+    if options.json_results_file:
+      json_results.GenerateJsonResultsFile(results, options.json_results_file)
+
   if os.path.isdir(constants.ISOLATE_DEPS_DIR):
     shutil.rmtree(constants.ISOLATE_DEPS_DIR)
 
   return exit_code
 
 
 def _RunLinkerTests(options, devices):
   """Subcommand of RunTestsCommands which runs linker tests."""
   runner_factory, tests = linker_setup.Setup(options, devices)
 
   results, exit_code = test_dispatcher.RunTests(
       tests, runner_factory, devices, shard=True, test_timeout=60,
       num_retries=options.num_retries)
 
   report_results.LogFull(
       results=results,
       test_type='Linker test',
       test_package='ChromiumLinkerTest')
 
+  if options.json_results_file:
+    json_results.GenerateJsonResultsFile(results, options.json_results_file)
+
   return exit_code
 
 
 def _RunInstrumentationTests(options, error_func, devices):
   """Subcommand of RunTestsCommands which runs instrumentation tests."""
   instrumentation_options = ProcessInstrumentationOptions(options, error_func)
 
   if len(devices) > 1 and options.wait_for_debugger:
     logging.warning('Debugger can not be sharded, using first available device')
     devices = devices[:1]
@@ skipping 31 matching lines @@
     options.device_flags = os.path.join(constants.DIR_SOURCE_ROOT,
                                         options.device_flags)
 
   report_results.LogFull(
       results=results,
       test_type='Instrumentation',
       test_package=os.path.basename(options.test_apk),
       annotation=options.annotations,
       flakiness_server=options.flakiness_dashboard_server)
 
+  if options.json_results_file:
+    json_results.GenerateJsonResultsFile(results, options.json_results_file)
+
   return exit_code
 
 
 def _RunUIAutomatorTests(options, error_func, devices):
   """Subcommand of RunTestsCommands which runs uiautomator tests."""
   uiautomator_options = ProcessUIAutomatorOptions(options, error_func)
 
   runner_factory, tests = uiautomator_setup.Setup(uiautomator_options)
 
   results, exit_code = test_dispatcher.RunTests(
       tests, runner_factory, devices, shard=True, 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,
       flakiness_server=options.flakiness_dashboard_server)
 
+  if options.json_results_file:
+    json_results.GenerateJsonResultsFile(results, options.json_results_file)
+
   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)
 
   report_results.LogFull(
       results=results,
       test_type='Monkey',
       test_package='Monkey')
 
+  if options.json_results_file:
+    json_results.GenerateJsonResultsFile(results, options.json_results_file)
+
   return exit_code
 
 
 def _RunPerfTests(options, args, error_func):
   """Subcommand of RunTestsCommands which runs perf tests."""
   perf_options = ProcessPerfTestOptions(options, args, error_func)
 
   # Just save a simple json with a list of test names.
   if perf_options.output_json_list:
     return perf_test_runner.OutputJsonList(
@@ skipping 11 matching lines @@
   # which increases throughput but have no affinity.
   results, _ = test_dispatcher.RunTests(
       tests, runner_factory, devices, shard=False, test_timeout=None,
       num_retries=options.num_retries)
 
   report_results.LogFull(
       results=results,
       test_type='Perf',
       test_package='Perf')
 
+  if options.json_results_file:
+    json_results.GenerateJsonResultsFile(results, options.json_results_file)
+
   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
 
 
@@ skipping 120 matching lines @@
           options, env, test, option_parser.error) as test_run:
         results = test_run.RunTests()
 
         report_results.LogFull(
             results=results,
             test_type=test.TestType(),
             test_package=test_run.TestPackage(),
             annotation=options.annotations,
             flakiness_server=options.flakiness_dashboard_server)
 
+        if options.json_results_file:
+          json_results.GenerateJsonResultsFile(
+              results, options.json_results_file)
+
   return results
 
 
 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. unused.
@@ skipping 63 matching lines @@
 
 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())