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
@@ skipping 211 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.suspects = set()

[jbudorick, 2016/02/27 00:31:38]

suspects here should probably be _suspects

[BigBossZhiling, 2016/02/29 22:19:28]

Done.

     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):
+    # Suspects are tests that might crash and make the tests in the same shard
+    # following the supect not run. Thus we need to create separate shards for
+    # each suspects, so that other tests can be run.

[jbudorick, 2016/02/27 00:31:38]

nit: suspect

[BigBossZhiling, 2016/02/29 22:19:28]

Done.

     device_count = len(self._env.devices)
     shards = []
+
+    # Add shards with only one suspect testcase.
+    shards += [[suspect] for suspect in self.suspects if suspect in tests]

[jbudorick, 2016/02/27 00:31:38]

will suspect ever not be in tests...?

[BigBossZhiling, 2016/02/29 22:19:27]

I am not sure. Is there a case where multiple test suites will be run? Suspects
of one test suite should not appear in the test run of another test suite
though.

+
+    # Delete suspect testcase from tests.
+    tests = [test for test in tests if not test in self.suspects]
+
     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 32 matching lines @@
     for s in self._servers[str(device)]:
       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.
+    crashed_test_case = self._test_instance.GetCrashedTestCase(output)
+    if crashed_test_case:
+      self.suspects.add(crashed_test_case)
     results = self._test_instance.ParseGTestOutput(output)

[jbudorick, 2016/02/27 00:31:38]

What if we did crash parsing in ParseGTestOutput and extracted suspects from
results as any test case with result type 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)