[android] Upstream / sync most of build/android and build/android/pylib.

build/android/run_tests.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2012 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 the native unit tests.
 
 1. Copy over test binary to /data/local on device.
 2. Resources: chrome/unit_tests requires resources (chrome.pak and en-US.pak)
@@ skipping 32 matching lines @@
   ReadOnlyFileUtilTest.ContentsEqual
 
 This file is generated by the tests running on devices. If running on emulator,
 additonal filter file which lists the tests only failed in emulator will be
 loaded. We don't care about the rare testcases which succeeded on emuatlor, but
 failed on device.
 """
 
 import fnmatch
 import logging
-import multiprocessing
 import os
-import re
 import subprocess
 import sys
 import time
 
 from pylib import android_commands
 from pylib.base_test_sharder import BaseTestSharder
-from pylib import cmd_helper
+from pylib import constants
 from pylib import debug_info
 import emulator
+from pylib import ports
 from pylib import run_tests_helper
+from pylib import test_options_parser
 from pylib.single_test_runner import SingleTestRunner
-from pylib.test_package_executable import TestPackageExecutable
 from pylib.test_result import BaseTestResult, TestResults
 
 _TEST_SUITES = ['base_unittests',
                 'content_unittests',
                 'gpu_unittests',
                 'ipc_tests',
                 'net_unittests',
                 'sql_unittests',
                 'sync_unit_tests',
                 'ui_unittests',
                ]
 
 def FullyQualifiedTestSuites(apk):
   """Return a fully qualified list that represents all known suites.
 
   Args:
     apk: if True, use the apk-based test runner"""
   # If not specified, assume the test suites are in out/Release
-  test_suite_dir = os.path.abspath(os.path.join(run_tests_helper.CHROME_DIR,
+  test_suite_dir = os.path.abspath(os.path.join(constants.CHROME_DIR,
                                                 'out', 'Release'))
   if apk:
     # out/Release/$SUITE_apk/$SUITE-debug.apk
     suites = [os.path.join(test_suite_dir,
                            t + '_apk',
                            t + '-debug.apk')
               for t in _TEST_SUITES]
   else:
     suites = [os.path.join(test_suite_dir, t) for t in _TEST_SUITES]
   return suites
@@ skipping 90 matching lines @@
     cleanup_test_files: Whether or not to cleanup test files on device.
     tool: Name of the Valgrind tool.
     log_dump_name: Name of log dump file.
     apk: boolean to state if we are using the apk based test runner
     annotate: should we print buildbot-style annotations?
 
   Returns:
     A TestResults object.
   """
   results = []
+  global _TEST_SUITES
 
   if test_suite:
     global _TEST_SUITES
-    if (not os.path.exists(test_suite) and
-        not os.path.splitext(test_suite)[1] == '.apk'):
+    if (not os.path.exists(test_suite)):
       logging.critical('Unrecognized test suite %s, supported: %s' %
                        (test_suite, _TEST_SUITES))
       if test_suite in _TEST_SUITES:
         logging.critical('(Remember to include the path: out/Release/%s)',
                          test_suite)
-      return TestResults.FromRun(failed=[BaseTestResult(test_suite, '')])
+      test_suite_basename = os.path.basename(test_suite)
+      if test_suite_basename in _TEST_SUITES:
+        logging.critical('Try "make -j15 %s"' % test_suite_basename)
+      else:
+        logging.critical('Unrecognized test suite, supported: %s' %
+                         _TEST_SUITES)
+      return TestResults.FromOkAndFailed([], [BaseTestResult(test_suite, '')],
+                                         False, False)
     fully_qualified_test_suites = [test_suite]
   else:
     fully_qualified_test_suites = FullyQualifiedTestSuites(apk)
   debug_info_list = []
   print 'Known suites: ' + str(_TEST_SUITES)
   print 'Running these: ' + str(fully_qualified_test_suites)
   for t in fully_qualified_test_suites:
     if annotate:
       print '@@@BUILD_STEP Test suite %s@@@' % os.path.basename(t)
     test = SingleTestRunner(device, t, gtest_filter, test_arguments,
                             timeout, rebaseline, performance_test,
                             cleanup_test_files, tool, 0, not not log_dump_name)
     test.Run()
 
     results += [test.test_results]
     # Collect debug info.
     debug_info_list += [test.dump_debug_info]
     if rebaseline:
       test.UpdateFilter(test.test_results.failed)
-    test.test_results.LogFull()
+    test.test_results.LogFull('Unit test', os.path.basename(t))
   # Zip all debug info outputs into a file named by log_dump_name.
   debug_info.GTestDebugInfo.ZipAndCleanResults(
-      os.path.join(run_tests_helper.CHROME_DIR, 'out', 'Release',
+      os.path.join(constants.CHROME_DIR, 'out', 'Release',
           'debug_info_dumps'),
       log_dump_name, [d for d in debug_info_list if d])
 
   if annotate:
     PrintAnnotationForTestResults(test.test_results)
 
   return TestResults.FromTestResults(results)
 
 
 class TestSharder(BaseTestSharder):
   """Responsible for sharding the tests on the connected devices."""
 
   def __init__(self, attached_devices, test_suite, gtest_filter,
                test_arguments, timeout, rebaseline, performance_test,
                cleanup_test_files, tool, annotate):
     BaseTestSharder.__init__(self, attached_devices)
     self.test_suite = test_suite
     self.test_suite_basename = os.path.basename(test_suite)
     self.gtest_filter = gtest_filter
     self.test_arguments = test_arguments
     self.timeout = timeout
     self.rebaseline = rebaseline
     self.performance_test = performance_test
     self.cleanup_test_files = cleanup_test_files
     self.tool = tool
     self.annotate = annotate
     test = SingleTestRunner(self.attached_devices[0], test_suite, gtest_filter,
                             test_arguments, timeout, rebaseline,
                             performance_test, cleanup_test_files, tool, 0)
+    # The executable/apk needs to be copied before we can call GetAllTests.
+    test.test_package.StripAndCopyExecutable()
     all_tests = test.test_package.GetAllTests()
     if not rebaseline:
       disabled_list = test.GetDisabledTests()
       # Only includes tests that do not have any match in the disabled list.
       all_tests = filter(lambda t:
                          not any([fnmatch.fnmatch(t, disabled_pattern)
                                   for disabled_pattern in disabled_list]),
                          all_tests)
     self.tests = all_tests
 
   def CreateShardedTestRunner(self, device, index):
     """Creates a suite-specific test runner.
 
     Args:
       device: Device serial where this shard will run.
       index: Index of this device in the pool.
 
     Returns:
       A SingleTestRunner object.
     """
-    shard_size = len(self.tests) / len(self.attached_devices)
+    device_num = len(self.attached_devices)
+    shard_size = (len(self.tests) + device_num - 1) / device_num
     shard_test_list = self.tests[index * shard_size : (index + 1) * shard_size]
     test_filter = ':'.join(shard_test_list)
     return SingleTestRunner(device, self.test_suite,
                             test_filter, self.test_arguments, self.timeout,
                             self.rebaseline, self.performance_test,
                             self.cleanup_test_files, self.tool, index)
 
   def OnTestsCompleted(self, test_runners, test_results):
     """Notifies that we completed the tests."""
-    test_results.LogFull()
+    test_results.LogFull('Unit test', os.path.basename(self.test_suite))
     if self.annotate:
       PrintAnnotationForTestResults(test_results)
     if test_results.failed and self.rebaseline:
       test_runners[0].UpdateFilter(test_results.failed)
 
 
 
 def _RunATestSuite(options):
   """Run a single test suite.
 
@@ skipping 25 matching lines @@
     attached_devices = [options.test_device]
   else:
     attached_devices = android_commands.GetAttachedDevices()
 
   if not attached_devices:
     logging.critical('A device must be attached and online.')
     if options.annotate:
       print '@@@STEP_FAILURE@@@'
     return 1
 
+  # Reset the test port allocation. It's important to do it before starting
+  # to dispatch any tests.
+  if not ports.ResetTestServerPortAllocation():
+    raise Exception('Failed to reset test server port.')
+
   if (len(attached_devices) > 1 and options.test_suite and
       not options.gtest_filter and not options.performance_test):
     sharder = TestSharder(attached_devices, options.test_suite,
                           options.gtest_filter, options.test_arguments,
                           options.timeout, options.rebaseline,
                           options.performance_test,
                           options.cleanup_test_files, options.tool,
                           options.annotate)
     test_results = sharder.RunShardedTests()
   else:
@@ skipping 57 matching lines @@
 
 def ListTestSuites():
   """Display a list of available test suites
   """
   print 'Available test suites are:'
   for test_suite in _TEST_SUITES:
     print test_suite
 
 
 def main(argv):
-  option_parser = run_tests_helper.CreateTestRunnerOptionParser(None,
+  option_parser = test_options_parser.CreateTestRunnerOptionParser(None,
       default_timeout=0)
   option_parser.add_option('-s', '--suite', dest='test_suite',
                            help='Executable name of the test suite to run '
                            '(use -s help to list them)')
   option_parser.add_option('-d', '--device', dest='test_device',
                            help='Target device the test suite to run ')
   option_parser.add_option('-r', dest='rebaseline',
                            help='Rebaseline and update *testsuite_disabled',
                            action='store_true',
                            default=False)
@@ skipping 48 matching lines @@
   # from all suites, but the buildbot associates the exit status only with the
   # most recent step).
   if options.annotate:
     return 0
   else:
     return failed_tests_count
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))