Add ThreadPool.abort() to stop processing early.

googletest/run_test_cases.py

 #!/usr/bin/env python
 # Copyright 2013 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 each test cases as a single shard, single process execution.
 
 Similar to sharding_supervisor.py but finer grained. It runs each test case
 individually instead of running per shard. Runs multiple instances in parallel.
 """
@@ skipping 846 matching lines @@
       else:
         line = '%s %s' % (i['test_case'], duration)
       if self.verbose or not test_case_has_passed or try_count > 0:
         # Print output in one of three cases:
         # - --verbose was specified.
         # - The test failed.
         # - The wasn't the first attempt (this is needed so the test parser can
         #   detect that a test has been successfully retried).
         if i['output']:
           line += '\n' + i['output']
-      self.progress.update_item(line, index=True, size=need_to_retry)
+      self.progress.update_item(line, index=1, size=need_to_retry)

[Vadim Sh., 2013/10/02 18:19:48]

int(need_to_retry)?

[Marc-Antoine Ruel (Google), 2013/10/02 19:41:26]

Done.

 
       if need_to_retry:
         priority = self._retry(priority, i['test_case'], try_count)
 
       # Delay yielding when only one test case is running, in case of a
       # crash-after-succeed.
       if len(test_cases) > 1:
         yield i
 
     if proc.returncode and not got_failure_at_least_once:
       if results and len(test_cases) == 1:
         # Crash after pass.
         results[-1]['returncode'] = proc.returncode
 
       if try_count < self.retries:
         # This is tricky, one of the test case failed but each did print that
         # they succeeded! Retry them *all* individually.
         if not self.verbose and not try_count:
           # Print all the output as one shot when not verbose to be sure the
           # potential stack trace is printed.
           output = ''.join(i['output'] for i in results)
           self.progress.update_item(output, raw=True)
         for i in results:
           priority = self._retry(priority, i['test_case'], try_count)
-          self.progress.update_item('', size=True)
+          self.progress.update_item('', size=1)
 
     # Only yield once the process completed when there is only one test case as
     # a safety precaution.
     if results and len(test_cases) == 1:
       yield results[-1]
 
   def _retry(self, priority, test_case, try_count):
     """Adds back the same task again only if relevant.
 
     It may add it either at lower (e.g. higher value) priority or at the end of
@@ skipping 696 matching lines @@
         options.gtest_output,
         result_file,
         options.verbose)
   except Failure as e:
     print >> sys.stderr, e.args[0]
     return 1
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))