[Android] Switch instrumentation tests to the new shard/runner paradigm.

build/android/pylib/instrumentation/test_runner.py

 # 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 the Java tests. See more information on run_instrumentation_tests.py."""
 
 import logging
 import os
 import re
 import shutil
 import sys
 import time
 
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib import forwarder
 from pylib import json_perf_parser
 from pylib import perf_tests_helper
 from pylib import valgrind_tools
 from pylib.base import base_test_runner
-from pylib.base import base_test_sharder
 from pylib.base import test_result
 
 import apk_info
 
 
 _PERF_TEST_ANNOTATION = 'PerfTest'
 
 
 class TestRunner(base_test_runner.BaseTestRunner):
   """Responsible for running a series of tests connected to a single device."""
 
   _DEVICE_DATA_DIR = 'chrome/test/data'
   _EMMA_JAR = os.path.join(os.environ.get('ANDROID_BUILD_TOP', ''),
                            'external/emma/lib/emma.jar')
   _COVERAGE_MERGED_FILENAME = 'unittest_coverage.es'
   _COVERAGE_WEB_ROOT_DIR = os.environ.get('EMMA_WEB_ROOTDIR')
   _COVERAGE_FILENAME = 'coverage.ec'
   _COVERAGE_RESULT_PATH = ('/data/data/com.google.android.apps.chrome/files/' +
                            _COVERAGE_FILENAME)
   _COVERAGE_META_INFO_PATH = os.path.join(os.environ.get('ANDROID_BUILD_TOP',
                                                          ''),
                                           'out/target/common/obj/APPS',
                                           'Chrome_intermediates/coverage.em')
   _HOSTMACHINE_PERF_OUTPUT_FILE = '/tmp/chrome-profile'
   _DEVICE_PERF_OUTPUT_SEARCH_PREFIX = (constants.DEVICE_PERF_OUTPUT_DIR +
                                        '/chrome-profile*')
   _DEVICE_HAS_TEST_FILES = {}
 
-  def __init__(self, options, device, tests_iter, coverage, shard_index, apks,
+  def __init__(self, options, device, shard_index, coverage, apks,
                ports_to_forward):
     """Create a new TestRunner.
 
     Args:
       options: An options object with the following required attributes:
       -  build_type: 'Release' or 'Debug'.
       -  install_apk: Re-installs the apk if opted.
       -  save_perf_json: Whether or not to save the JSON file from UI perf
             tests.
       -  screenshot_failures: Take a screenshot for a test failure
       -  tool: Name of the Valgrind tool.
       -  wait_for_debugger: blocks until the debugger is connected.
       -  disable_assertions: Whether to disable java assertions on the device.
       device: Attached android device.
-      tests_iter: A list of tests to be run.
+      shard_index: Shard index.
       coverage: Collects coverage information if opted.
-      shard_index: shard # for this TestRunner, used to create unique port
-          numbers.
       apks: A list of ApkInfo objects need to be installed. The first element
             should be the tests apk, the rests could be the apks used in test.
             The default is ChromeTest.apk.
       ports_to_forward: A list of port numbers for which to set up forwarders.
                         Can be optionally requested by a test case.
     Raises:
       Exception: if coverage metadata is not available.
     """
-    super(TestRunner, self).__init__(
-        device, options.tool, shard_index, options.build_type)
+    super(TestRunner, self).__init__(device, options.tool, options.build_type)
+    self._lighttp_port = constants.LIGHTTPD_RANDOM_PORT_FIRST + shard_index
 
     if not apks:
       apks = [apk_info.ApkInfo(options.test_apk_path,
                                options.test_apk_jar_path)]
 
     self.build_type = options.build_type
     self.install_apk = options.install_apk
     self.test_data = options.test_data
     self.save_perf_json = options.save_perf_json
     self.screenshot_failures = options.screenshot_failures
     self.wait_for_debugger = options.wait_for_debugger
     self.disable_assertions = options.disable_assertions
 
-    self.tests_iter = tests_iter
     self.coverage = coverage
     self.apks = apks
     self.test_apk = apks[0]
     self.instrumentation_class_path = self.test_apk.GetPackageName()
     self.ports_to_forward = ports_to_forward
 
-    self.test_results = test_result.TestResults()
     self.forwarder = None
 
     if self.coverage:
       if os.path.exists(TestRunner._COVERAGE_MERGED_FILENAME):
         os.remove(TestRunner._COVERAGE_MERGED_FILENAME)
       if not os.path.exists(TestRunner._COVERAGE_META_INFO_PATH):
         raise Exception('FATAL ERROR in ' + sys.argv[0] +
                         ' : Coverage meta info [' +
                         TestRunner._COVERAGE_META_INFO_PATH +
                         '] does not exist.')
       if (not TestRunner._COVERAGE_WEB_ROOT_DIR or
           not os.path.exists(TestRunner._COVERAGE_WEB_ROOT_DIR)):
         raise Exception('FATAL ERROR in ' + sys.argv[0] +
                         ' : Path specified in $EMMA_WEB_ROOTDIR [' +
                         TestRunner._COVERAGE_WEB_ROOT_DIR +
                         '] does not exist.')
 
-  def _GetTestsIter(self):
-    if not self.tests_iter:
-      # multiprocessing.Queue can't be pickled across processes if we have it as
-      # a member set during constructor.  Grab one here instead.
-      self.tests_iter = (base_test_sharder.BaseTestSharder.tests_container)
-    assert self.tests_iter
-    return self.tests_iter
-
   def CopyTestFilesOnce(self):
     """Pushes the test data files to the device. Installs the apk if opted."""
     if TestRunner._DEVICE_HAS_TEST_FILES.get(self.device, False):
       logging.warning('Already copied test files to device %s, skipping.',
                       self.device)
       return
     for dest_host_pair in self.test_data:
       dst_src = dest_host_pair.split(':',1)
       dst_layer = dst_src[0]
       host_src = dst_src[1]
@@ skipping 83 matching lines @@
       logging.warning('Unable to enable java asserts for %s, non rooted device',
                       self.device)
     else:
       if self.adb.SetJavaAssertsEnabled(enable=not self.disable_assertions):
         self.adb.Reboot(full_reboot=False)
 
     # We give different default value to launch HTTP server based on shard index
     # because it may have race condition when multiple processes are trying to
     # launch lighttpd with same port at same time.
     http_server_ports = self.LaunchTestHttpServer(
-        os.path.join(constants.CHROME_DIR),
-        (constants.LIGHTTPD_RANDOM_PORT_FIRST + self.shard_index))
+        os.path.join(constants.CHROME_DIR), self._lighttp_port)
     if self.ports_to_forward:
       port_pairs = [(port, port) for port in self.ports_to_forward]
       # We need to remember which ports the HTTP server is using, since the
       # forwarder will stomp on them otherwise.
       port_pairs.append(http_server_ports)
       self.forwarder = forwarder.Forwarder(self.adb, self.build_type)
       self.forwarder.Run(port_pairs, self.tool, '127.0.0.1')
     self.CopyTestFilesOnce()
     self.flags.AddFlags(['--enable-test-intents'])
 
@@ skipping 142 matching lines @@
     if 'Manual' in annotations:
       return 600 * 60
     if 'External' in annotations:
       return 10 * 60
     if 'LargeTest' in annotations or _PERF_TEST_ANNOTATION in annotations:
       return 5 * 60
     if 'MediumTest' in annotations:
       return 3 * 60
     return 1 * 60
 
-  def RunTests(self):
-    """Runs the tests, generating the coverage if needed.
+  def RunTest(self, test):
+    """Runs the test, generating the coverage if needed.
 
     Returns:
       A test_result.TestResults object.
     """
     instrumentation_path = (self.instrumentation_class_path +
                             '/android.test.InstrumentationTestRunner')
     instrumentation_args = self._GetInstrumentationArgs()
-    for test in self._GetTestsIter():
+    raw_result = None
+    start_date_ms = None
+    test_results = test_result.TestResults()
+    try:
+      self.TestSetup(test)
+      start_date_ms = int(time.time()) * 1000
+      args_with_filter = dict(instrumentation_args)
+      args_with_filter['class'] = test
+      # |raw_results| is a list that should contain
+      # a single TestResult object.
+      logging.warn(args_with_filter)
+      (raw_results, _) = self.adb.Adb().StartInstrumentation(
+          instrumentation_path=instrumentation_path,
+          instrumentation_args=args_with_filter,
+          timeout_time=(self._GetIndividualTestTimeoutSecs(test) *
+                        self._GetIndividualTestTimeoutScale(test) *
+                        self.tool.GetTimeoutScale()))
+      duration_ms = int(time.time()) * 1000 - start_date_ms
+      assert len(raw_results) == 1
+      raw_result = raw_results[0]
+      status_code = raw_result.GetStatusCode()
+      if status_code:
+        log = raw_result.GetFailureReason()
+        if not log:
+          log = 'No information.'
+        if self.screenshot_failures or log.find('INJECT_EVENTS perm') >= 0:
+          self._TakeScreenshot(test)
+        test_results.failed = [test_result.SingleTestResult(
+            test, start_date_ms, duration_ms, log)]
+      else:
+        test_results.ok = [test_result.SingleTestResult(test, start_date_ms,
+                                                        duration_ms)]
+    # Catch exceptions thrown by StartInstrumentation().
+    # See ../../third_party/android/testrunner/adb_interface.py
+    except (android_commands.errors.WaitForResponseTimedOutError,
+            android_commands.errors.DeviceUnresponsiveError,
+            android_commands.errors.InstrumentationError), e:
+      if start_date_ms:
+        duration_ms = int(time.time()) * 1000 - start_date_ms
+      else:
+        start_date_ms = int(time.time()) * 1000
+        duration_ms = 0
+      message = str(e)
+      if not message:
+        message = 'No information.'
+      test_results.crashed = [test_result.SingleTestResult(
+          test, start_date_ms, duration_ms, message)]
       raw_result = None
-      start_date_ms = None
-      try:
-        self.TestSetup(test)
-        start_date_ms = int(time.time()) * 1000
-        args_with_filter = dict(instrumentation_args)
-        args_with_filter['class'] = test
-        # |raw_results| is a list that should contain
-        # a single TestResult object.
-        logging.warn(args_with_filter)
-        (raw_results, _) = self.adb.Adb().StartInstrumentation(
-            instrumentation_path=instrumentation_path,
-            instrumentation_args=args_with_filter,
-            timeout_time=(self._GetIndividualTestTimeoutSecs(test) *
-                          self._GetIndividualTestTimeoutScale(test) *
-                          self.tool.GetTimeoutScale()))
-        duration_ms = int(time.time()) * 1000 - start_date_ms
-        assert len(raw_results) == 1
-        raw_result = raw_results[0]
-        status_code = raw_result.GetStatusCode()
-        if status_code:
-          log = raw_result.GetFailureReason()
-          if not log:
-            log = 'No information.'
-          if self.screenshot_failures or log.find('INJECT_EVENTS perm') >= 0:
-            self._TakeScreenshot(test)
-          self.test_results.failed += [test_result.SingleTestResult(
-              test, start_date_ms, duration_ms, log)]
-        else:
-          result = [test_result.SingleTestResult(test, start_date_ms,
-                                                 duration_ms)]
-          self.test_results.ok += result
-      # Catch exceptions thrown by StartInstrumentation().
-      # See ../../third_party/android/testrunner/adb_interface.py
-      except (android_commands.errors.WaitForResponseTimedOutError,
-              android_commands.errors.DeviceUnresponsiveError,
-              android_commands.errors.InstrumentationError), e:
-        if start_date_ms:
-          duration_ms = int(time.time()) * 1000 - start_date_ms
-        else:
-          start_date_ms = int(time.time()) * 1000
-          duration_ms = 0
-        message = str(e)
-        if not message:
-          message = 'No information.'
-        self.test_results.crashed += [test_result.SingleTestResult(
-            test, start_date_ms, duration_ms, message)]
-        raw_result = None
-      self.TestTeardown(test, raw_result)
-    return self.test_results
+    self.TestTeardown(test, raw_result)
+    return (test_results, None if test_results.ok else test)