[Android] Add support for external sharding to the test runner.

build/android/pylib/local/device/local_device_test_run.py

 # Copyright 2014 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.
 
 import fnmatch
 import imp
 import logging
 import posixpath
 import signal
 import thread
@@ skipping 36 matching lines @@
 
 def SubstituteDeviceRoot(device_path, device_root):
   if not device_path:
     return device_root
   elif isinstance(device_path, list):
     return posixpath.join(*(p if p else device_root for p in device_path))
   else:
     return device_path
 
 
+class TestsTerminated(Exception):
+  pass
+
+
+class InvalidShardingSettings(Exception):
+  def __init__(self, shard_index, total_shards):
+    super(InvalidShardingSettings, self).__init__(
+        'Invalid sharding settings. shard_index: %d total_shards: %d'
+            % (shard_index, total_shards))
+
+
 class LocalDeviceTestRun(test_run.TestRun):
 
   def __init__(self, env, test_instance):
     super(LocalDeviceTestRun, self).__init__(env, test_instance)
     self._tools = {}
 
   #override
   def RunTests(self):
     tests = self._GetTests()
 
@@ skipping 21 matching lines @@
             rerun = test
           raise
         finally:
           if isinstance(tests, test_collection.TestCollection):
             if rerun:
               tests.add(rerun)
             tests.test_completed()
 
       logging.info('Finished running tests on this device.')
 
-    class TestsTerminated(Exception):
-      pass
-
     def stop_tests(_signum, _frame):
       logging.critical('Received SIGTERM. Stopping test execution.')
       exit_now.set()
       raise TestsTerminated()
 
     try:
       with signal_handler.SignalHandler(signal.SIGTERM, stop_tests):
         tries = 0
         results = []
         while tries < self._env.max_tries and tests:
@@ skipping 59 matching lines @@
       # See local_device_gtest_run._ExtractTestsFromFilter()
       if name.endswith('*'):
         return any(fnmatch.fnmatch(n, name) and is_failure_result(t)
                    for n, t in all_test_results.iteritems())
       return is_failure_result(all_test_results.get(name))
 
     failed_tests = (t for t in tests if test_failed(self._GetUniqueTestName(t)))
 
     return [t for t in failed_tests if self._ShouldRetry(t)]
 
+  def _ApplyExternalSharding(self, tests, shard_index, total_shards):
+    logging.info('Using external sharding settings. This is shard %d/%d',
+                 shard_index, total_shards)
+
+    if total_shards < 0 or shard_index < 0 or total_shards <= shard_index:
+      raise InvalidShardingSettings(shard_index, total_shards)
+
+    return [
+        t for t in tests
+        if hash(self._GetUniqueTestName(t)) % total_shards == shard_index]
+
   def GetTool(self, device):
     if not str(device) in self._tools:
       self._tools[str(device)] = valgrind_tools.CreateTool(
           self._env.tool, device)
     return self._tools[str(device)]
 
   def _CreateShards(self, tests):
     raise NotImplementedError
 
   def _GetUniqueTestName(self, test):
     # pylint: disable=no-self-use
     return test
 
   def _ShouldRetry(self, test):
     # pylint: disable=no-self-use,unused-argument
     return True
 
   def _GetTests(self):
     raise NotImplementedError
-
   def _RunTest(self, device, test):
     raise NotImplementedError
 
   def _ShouldShard(self):
     raise NotImplementedError
 
 
 class NoTestsError(Exception):
   """Error for when no tests are found."""