Created separate shards for suspicious testcases.

build/android/pylib/local/device/local_device_gtest_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 collections
 import itertools
 import os
 import posixpath
 
 from devil.android import device_errors
 from devil.android import device_temp_file
 from devil.android import ports
 from devil.utils import reraiser_thread
 from pylib import constants
+from pylib.base import base_test_result
 from pylib.gtest import gtest_test_instance
 from pylib.local import local_test_server_spawner
 from pylib.local.device import local_device_environment
 from pylib.local.device import local_device_test_run
 
 _COMMAND_LINE_FLAGS_SUPPORTED = True
 
 _MAX_INLINE_FLAGS_LENGTH = 50  # Arbitrarily chosen.
 _EXTRA_COMMAND_LINE_FILE = (
     'org.chromium.native_test.NativeTestActivity.CommandLineFile')
@@ skipping 197 matching lines @@
 
   def __init__(self, env, test_instance):
     assert isinstance(env, local_device_environment.LocalDeviceEnvironment)
     assert isinstance(test_instance, gtest_test_instance.GtestTestInstance)
     super(LocalDeviceGtestRun, self).__init__(env, test_instance)
 
     if self._test_instance.apk:
       self._delegate = _ApkDelegate(self._test_instance)
     elif self._test_instance.exe:
       self._delegate = _ExeDelegate(self, self._test_instance.exe)
-
+    self._crashes = set()
     self._servers = collections.defaultdict(list)
 
   #override
   def TestPackage(self):
     return self._test_instance.suite
 
   #override
   def SetUp(self):
     @local_device_test_run.handle_shard_failures_with(
         on_failure=self._env.BlacklistDevice)
@@ skipping 33 matching lines @@
           step()
 
     self._env.parallel_devices.pMap(individual_device_set_up)
 
   #override
   def _ShouldShard(self):
     return True
 
   #override
   def _CreateShards(self, tests):
+    # _crashes are tests that might crash and make the tests in the same shard
+    # following the crashed testcase not run.
+    # Thus we need to create separate shards for each crashed testcase,
+    # so that other tests can be run.
     device_count = len(self._env.devices)
     shards = []
+
+    # Add shards with only one suspect testcase.
+    shards += [[crash] for crash in self._crashes if crash in tests]
+
+    # Delete suspect testcase from tests.
+    tests = [test for test in tests if not test in self._crashes]
+
     for i in xrange(0, device_count):
       unbounded_shard = tests[i::device_count]
       shards += [unbounded_shard[j:j+_MAX_SHARD_SIZE]
                  for j in xrange(0, len(unbounded_shard), _MAX_SHARD_SIZE)]
     return shards
 
   #override
   def _GetTests(self):
     if self._test_instance.extract_test_list_from_filter:
       # When the exact list of tests to run is given via command-line (e.g. when
@@ skipping 33 matching lines @@
       s.Reset()
     if self._test_instance.app_files:
       self._delegate.PullAppFiles(device, self._test_instance.app_files,
                                   self._test_instance.app_file_dir)
     if not self._test_instance.skip_clear_data:
       self._delegate.Clear(device)
 
     # Parse the output.
     # TODO(jbudorick): Transition test scripts away from parsing stdout.
     results = self._test_instance.ParseGTestOutput(output)
+
+    # Check whether there are any crashed testcases.
+    self._crashes.update(r.GetName() for r in results
+                         if r.GetType() == base_test_result.ResultType.CRASH)
     return results
 
   #override
   def TearDown(self):
     @local_device_test_run.handle_shard_failures
     def individual_device_tear_down(dev):
       for s in self._servers.get(str(dev), []):
         s.TearDown()
 
       tool = self.GetTool(dev)
       tool.CleanUpEnvironment()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)