Changes argument passing to use options objects

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 cmd_helper
 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 gtest_config
+from pylib.gtest import test_options as gtest_test_options
 from pylib.host_driven import run_python_tests as python_dispatch
 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')
 
 
 def AddBuildTypeOption(option_parser):
   """Adds the build type option to |option_parser|."""
   default_build_type = 'Debug'
@@ skipping 79 matching lines @@
   # TODO(gkanwar): Move these to Common Options once we have the plumbing
   # in our other test types to handle these commands
   AddCommonOptions(option_parser)
 
 
 def ProcessGTestOptions(options):
   """Intercept test suite help to list test suites.
 
   Args:
     options: Command line options.
-
-  Returns:
-    True if the command should continue.
   """
   if options.suite_name == 'help':
     print 'Available test suites are:'
     for test_suite in (gtest_config.STABLE_TEST_SUITES +
                        gtest_config.EXPERIMENTAL_TEST_SUITES):
       print test_suite
-    return False
+    sys.exit(0)
 
   # Convert to a list, assuming all test suites if nothing was specified.
   # TODO(gkanwar): Require having a test suite
   if options.suite_name:
     options.suite_name = [options.suite_name]
   else:
     options.suite_name = [s for s in gtest_config.STABLE_TEST_SUITES]
-  return True
 
 
 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(
       '-A', '--annotation', dest='annotation_str',
@@ skipping 90 matching lines @@
   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."""
+  """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 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,
                                          options.build_type,
                                          constants.SDK_BUILD_APKS_DIR,
                                          '%s.apk' % options.test_apk)
     options.test_apk_jar_path = os.path.join(
         _SDK_OUT_DIR, options.build_type, constants.SDK_BUILD_TEST_JAVALIB_DIR,
         '%s.jar' %  options.test_apk)
 
+  return instrumentation_test_options.InstrumentationOptions(
+      options.build_type,
+      options.tool,
+      options.cleanup_test_files,
+      options.push_deps,
+      options.annotations,
+      options.exclude_annotations,
+      options.test_filter,
+      options.test_data,
+      options.save_perf_json,
+      options.screenshot_failures,
+      options.disable_assertions,
+      options.wait_for_debugger,
+      options.test_apk,
+      options.test_apk_path,
+      options.test_apk_jar_path)
+
 
 def AddUIAutomatorTestOptions(option_parser):
   """Adds UI Automator test options to |option_parser|."""
 
   option_parser.usage = '%prog uiautomator [options]'
   option_parser.command_list = []
   option_parser.example = (
       '%prog uiautomator --test-jar=chromium_testshell_uiautomator_tests'
       ' --package-name=org.chromium.chrome.testshell')
   option_parser.add_option(
       '--package-name',
       help='The package name used by the apk containing the application.')
   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)
 
 
 def ProcessUIAutomatorOptions(options, error_func):
-  """Processes UIAutomator options/arguments."""
+  """Processes UIAutomator options/arguments.
+
+  Args:
+    options: optparse.Options object.
+    error_func: Function to call with the error message in case of an error.
+
+  Returns:
+    A UIAutomatorOptions named tuple which contains all options relevant to
+    instrumentation tests.
+  """
 
   ProcessJavaTestOptions(options, error_func)
 
   if not options.package_name:
     error_func('--package-name must be specified.')
 
   if not options.test_jar:
     error_func('--test-jar must be specified.')
 
   if os.path.exists(options.test_jar):
     # The dexed JAR is fully qualified, assume the info JAR lives along side.
     options.uiautomator_jar = options.test_jar
   else:
     options.uiautomator_jar = os.path.join(
         _SDK_OUT_DIR, options.build_type, constants.SDK_BUILD_JAVALIB_DIR,
         '%s.dex.jar' % options.test_jar)
   options.uiautomator_info_jar = (
       options.uiautomator_jar[:options.uiautomator_jar.find('.dex.jar')] +
       '_java.jar')
 
+  return uiautomator_test_options.UIAutomatorOptions(
+      options.build_type,
+      options.tool,
+      options.cleanup_test_files,
+      options.push_deps,
+      options.annotations,
+      options.exclude_annotations,
+      options.test_filter,
+      options.test_data,
+      options.save_perf_json,
+      options.screenshot_failures,
+      options.disable_assertions,
+      options.uiautomator_jar,
+      options.uiautomator_info_jar,
+      options.package_name)
+
 
 def _RunGTests(options, error_func):
   """Subcommand of RunTestsCommands which runs gtests."""
-  if not ProcessGTestOptions(options):
-    return 0
+  ProcessGTestOptions(options)
 
   exit_code = 0
   for suite_name in options.suite_name:
-    runner_factory, tests = gtest_setup.Setup(
-        suite_name, options.test_arguments,
-        options.timeout, options.cleanup_test_files, options.tool,
-        options.build_type, options.push_deps, options.test_filter)
+    # TODO(gkanwar): Move this into ProcessGTestOptions once we require -s for
+    # the gtest command.
+    gtest_options = gtest_test_options.GTestOptions(
+        options.build_type,
+        options.tool,
+        options.cleanup_test_files,
+        options.push_deps,
+        options.test_filter,
+        options.test_arguments,
+        options.timeout,
+        suite_name)
+    runner_factory, tests = gtest_setup.Setup(gtest_options)
 
     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)
 
     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,
         build_type=options.build_type,
         flakiness_server=options.flakiness_dashboard_server)
 
   if os.path.isdir(constants.ISOLATE_DEPS_DIR):
     shutil.rmtree(constants.ISOLATE_DEPS_DIR)
 
   return exit_code
 
 
 def _RunInstrumentationTests(options, error_func):
   """Subcommand of RunTestsCommands which runs instrumentation tests."""
-  ProcessInstrumentationOptions(options, error_func)
+  instrumentation_options = ProcessInstrumentationOptions(options, error_func)
 
   results = base_test_result.TestRunResults()
   exit_code = 0
 
   if options.run_java_tests:
-    runner_factory, tests = instrumentation_setup.Setup(
-        options.test_apk_path, options.test_apk_jar_path, options.annotations,
-        options.exclude_annotations, options.test_filter, options.build_type,
-        options.test_data, options.save_perf_json, options.screenshot_failures,
-        options.tool, options.wait_for_debugger, options.disable_assertions,
-        options.push_deps, options.cleanup_test_files)
+    runner_factory, tests = instrumentation_setup.Setup(instrumentation_options)
 
     test_results, exit_code = test_dispatcher.RunTests(
         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)
@@ skipping 14 matching lines @@
       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."""
-  ProcessUIAutomatorOptions(options, error_func)
+  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(
-        options.uiautomator_jar, options.uiautomator_info_jar,
-        options.annotations, options.exclude_annotations, options.test_filter,
-        options.package_name, options.build_type, options.test_data,
-        options.save_perf_json, options.screenshot_failures, options.tool,
-        options.disable_assertions, options.push_deps,
-        options.cleanup_test_files)
+    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)
 
@@ skipping 148 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))