Thread Watcher: don't fail when test already failed.

testing_support/tests/thread_watcher_test.py

 # Copyright 2016 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 re
 import sys
 import threading
 import unittest
 
 from testing_support import thread_watcher
@@ skipping 10 matching lines @@
     self._start_event.wait()
 
   def run(self):
     self._start_event.set()
     self._stop_event.wait()
 
   def stop(self):
     self._stop_event.set()
     self.join()
 
+class _ResultFake(object):
+  def __init__(self, value):
+    self.value = value
+
+  def wasSuccessful(self):
+    return self.value
+
 
 class ThreadWatcherTestCase(thread_watcher.TestCase):
   def setUp(self):
     self._fail_called = []
     self.watcher = thread_watcher.ThreadWatcherMixIn()
     self.watcher.fail = lambda x: self._fail_called.append(x)
     self._threads = []
 
   def tearDown(self):
     for t in self._threads:
@@ skipping 23 matching lines @@
         re.compile(
             '^Found 2 running thread\(s\) after the test.\n\n'
             'Thread <_PuppetThread\(foo, started daemon \d+\)> stacktrace:\n'
             '  .*\n\n'
             'Thread <_PuppetThread\(bar, started daemon \d+\)> stacktrace:\n'
             '  .*\n$', re.DOTALL)
     )
     self.assertNotIn('  Thread stopped while acquiring stacktrace.\n',
                      error_message)
 
+  def test_extra_threads_unittest_pass(self):
+    # Test succeeded, so thread_watcher must cause failure.
+    self.watcher._resultForDoCleanups = _ResultFake(True)
+    self.watcher.setUp()
+    self._threads.append(_PuppetThread('foo'))
+    self.watcher.tearDown()
+    self.assertEqual(len(self._fail_called), 1)
+
+  def test_extra_threads_unittest_fail(self):
+    # Test failed already, so thread_watcher must ignore result.
+    self.watcher._resultForDoCleanups = _ResultFake(False)
+    self.watcher.setUp()
+    self._threads.append(_PuppetThread('foo'))
+    self.watcher.tearDown()
+    self.assertEqual(self._fail_called, [])
+
+  def test_extra_threads_expect_tests_pass(self):
+    # Test succeeded, so thread_watcher must cause failure.
+    self.watcher._test_failed_with_exception = False
+    self.watcher.setUp()
+    self._threads.append(_PuppetThread('foo'))
+    self.watcher.tearDown()
+    self.assertEqual(len(self._fail_called), 1)
+
+  def test_extra_threads_expect_tests_fail(self):
+    # Test failed already, so thread_watcher must ignore result.
+    self.watcher._test_failed_with_exception = True
+    self.watcher.setUp()
+    self._threads.append(_PuppetThread('foo'))
+    self.watcher.tearDown()
+    self.assertEqual(self._fail_called, [])
+
   def test_fail_get_stacktrace(self):
     self.watcher.setUp()
     self._threads.append(_PuppetThread('foo'))
     try:
       old = sys._current_frames
       sys._current_frames = lambda: {}
       self.watcher.tearDown()
     finally:
       sys._current_frames = old
 
@@ skipping 17 matching lines @@
     self._threads.append(_PuppetThread(name))
 
   def test_ok(self):
     pass
 
   def test_ok_with_threads(self):
     self._threads.append(_PuppetThread('ok'))
     self._threads[-1].stop()
 
 
-
 if __name__ == '__main__':
   unittest.main()