Add new Android test runner command to handle linker tests.

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 sys
 
 from pylib import android_commands
 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.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.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
@@ skipping 72 matching lines @@
   option_parser.add_option('-a', '--test-arguments', dest='test_arguments',
                            default='',
                            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)
   # TODO(gkanwar): Move these to Common Options once we have the plumbing
   # in our other test types to handle these commands
   AddCommonOptions(option_parser)
 

[bulach, 2013/10/02 11:16:50]

nit: another \n here and after this method

[digit1, 2013/10/02 14:01:52]

Done.

+def AddLinkerTestOptions(option_parser):
+  option_parser.usage = '%prog linker'
+  option_parser.commands_dict = {}
+  option_parser.example = '%prog linker'
+
+  AddCommonOptions(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:'
     for test_suite in (gtest_config.STABLE_TEST_SUITES +
@@ skipping 364 matching lines @@
         results=results,
         test_type='Unit test',
         test_package=suite_name,
         flakiness_server=options.flakiness_dashboard_server)
 
   if os.path.isdir(constants.ISOLATE_DEPS_DIR):
     shutil.rmtree(constants.ISOLATE_DEPS_DIR)
 
   return exit_code
 
+def _RunLinkerTests(options, error_func, 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='ContentLinkerTest')
+
+  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]
 
   results = base_test_result.TestRunResults()
@@ skipping 139 matching lines @@
   if len(args) > 2:
     option_parser.error('Unrecognized arguments: %s' % (' '.join(args[2:])))
     return constants.ERROR_EXIT_CODE
 
   ProcessCommonOptions(options)
 
   devices = _GetAttachedDevices(options.test_device)
 
   if command == 'gtest':
     return _RunGTests(options, option_parser.error, devices)
+  elif command == 'linker':
+    return _RunLinkerTests(options, option_parser.error, devices)
   elif command == 'instrumentation':
     return _RunInstrumentationTests(options, option_parser.error, devices)
   elif command == 'uiautomator':
     return _RunUIAutomatorTests(options, option_parser.error, devices)
   elif command == 'monkey':
     return _RunMonkeyTests(options, option_parser.error, devices)
   elif command == 'perf':
     return _RunPerfTests(options, option_parser.error, devices)
   else:
     raise Exception('Unknown test type.')
@@ skipping 48 matching lines @@
 VALID_COMMANDS = {
     'gtest': CommandFunctionTuple(AddGTestOptions, RunTestsCommand),
     'instrumentation': CommandFunctionTuple(
         AddInstrumentationTestOptions, RunTestsCommand),
     'uiautomator': CommandFunctionTuple(
         AddUIAutomatorTestOptions, RunTestsCommand),
     'monkey': CommandFunctionTuple(
         AddMonkeyTestOptions, RunTestsCommand),
     'perf': CommandFunctionTuple(
         AddPerfTestOptions, RunTestsCommand),
+    'linker': CommandFunctionTuple(
+        AddLinkerTestOptions, RunTestsCommand),
     'help': CommandFunctionTuple(lambda option_parser: None, HelpCommand)
     }
 
 
 def main(argv):
   option_parser = command_option_parser.CommandOptionParser(
       commands_dict=VALID_COMMANDS)
   return command_option_parser.ParseAndExecute(option_parser)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))