Remove a bunch of redundant code from parallel_testsuite.py

All this infrastructure with the BufferedTestBase was added to work
around that fact that we were previously using using a fake TestResult
class so that is could be serialized.

However in #25737 I converted to using TestResult as the superclass of
BufferedParallelTestResult.  There were only two members that needed to
me removed to make it work.

With that change landed we can now remove a log of the other code here.

Author: sbc100

test/parallel_testsuite.py

@@ -77,7 +77,8 @@ def printResult(res):
       msg = f'{res.test} ... FAIL'
       errlog(f'{progress}{with_color(RED, msg)}')
     elif res.test_result == 'skipped':
-      msg = f"skipped '{res.buffered_result.reason}'"
+      reason = res.skipped[0][1]
+      msg = f"skipped '{reason}'"
       errlog(f"{progress}{res.test} ... {with_color(CYAN, msg)}")
     elif res.test_result == 'unexpected success':
       msg = f'unexpected success ({elapsed:.2f}s)'
@@ -276,14 +277,10 @@ class BufferedParallelTestResult(unittest.TestResult):
   """
   def __init__(self):
     super().__init__()
-    self.buffered_result = None
     self.test_duration = 0
     self.test_result = 'errored'
     self.test_name = ''
-
-  @property
-  def test(self):
-    return self.buffered_result.test
+    self.test = None
 
   def test_short_name(self):
     # Given a test name e.g. "test_atomic_cxx (test_core.core0.test_atomic_cxx)"
@@ -294,8 +291,28 @@ def addDuration(self, test, elapsed):
     self.test_duration = elapsed
 
   def updateResult(self, result):
+    # The exception info object that we are adding here have already
+    # been turned into strings so make _exc_info_to_string into a no-op.
+    result._exc_info_to_string = lambda x, _y: x
+    # No need to worry about stdou/stderr buffering since are a not
+    # actually runnin the test here, only setting the results.
+    result.buffer = False
     result.startTest(self.test)
-    self.buffered_result.updateResult(result)
+    if self.test_result == 'success':
+      result.addSuccess(self.test)
+    elif self.test_result == 'failed':
+      result.addFailure(*self.failures[0])
+    elif self.test_result == 'errored':
+      result.addError(*self.errors[0])
+    elif self.test_result == 'skipped':
+      result.addSkip(*self.skipped[0])
+    elif self.test_result == 'unexpected success':
+      result.addUnexpectedSuccess(*self.unexpectedSuccessesed[0])
+    elif self.test_result == 'expected failed':
+      result.addExpectedFailure(*self.expectedFailures[0])
+    else:
+      assert False
+    result.addDuration(self.test, self.test_duration)
     result.stopTest(self.test)
     result.core_time += self.test_duration
     self.log_test_run_for_visualization()
@@ -325,13 +342,11 @@ def log_test_run_for_visualization(self):
 
   def startTest(self, test):
     super().startTest(test)
+    self.test = test
     self.test_name = str(test)
 
   def stopTest(self, test):
     super().stopTest(test)
-    # TODO(sbc): figure out a way to display this duration information again when
-    # these results get passed back to the TextTestRunner/TextTestResult.
-    self.buffered_result.duration = self.test_duration
     # Once we are done running the test and any stdout/stderr buffering has
     # being taking care or, we delete these fields which the parent class uses.
     # This is because they are not picklable (serializable).
@@ -340,137 +355,29 @@ def stopTest(self, test):
 
   def addSuccess(self, test):
     super().addSuccess(test)
-    self.buffered_result = BufferedTestSuccess(test)
     self.test_result = 'success'
 
   def addExpectedFailure(self, test, err):
     super().addExpectedFailure(test, err)
-    self.buffered_result = BufferedTestExpectedFailure(test, err)
     self.test_result = 'expected failure'
 
   def addUnexpectedSuccess(self, test):
     super().addUnexpectedSuccess(test)
-    self.buffered_result = BufferedTestUnexpectedSuccess(test)
     self.test_result = 'unexpected success'
 
   def addSkip(self, test, reason):
     super().addSkip(test, reason)
-    self.buffered_result = BufferedTestSkip(test, reason)
     self.test_result = 'skipped'
 
   def addFailure(self, test, err):
     super().addFailure(test, err)
-    self.buffered_result = BufferedTestFailure(test, err)
     self.test_result = 'failed'
 
   def addError(self, test, err):
     super().addError(test, err)
-    self.buffered_result = BufferedTestError(test, err)
     self.test_result = 'errored'
 
 
-class BufferedTestBase:
-  """Abstract class that holds test result data, split by type of result."""
-  def __init__(self, test, err=None):
-    self.test = test
-    if err:
-      exctype, value, tb = err
-      self.error = exctype, value, FakeTraceback(tb)
-
-  def updateResult(self, result):
-    assert False, 'Base class should not be used directly'
-
-
-class BufferedTestSuccess(BufferedTestBase):
-  def updateResult(self, result):
-    result.addSuccess(self.test)
-
-
-class BufferedTestSkip(BufferedTestBase):
-  def __init__(self, test, reason):
-    self.test = test
-    self.reason = reason
-
-  def updateResult(self, result):
-    result.addSkip(self.test, self.reason)
-
-
-def fixup_fake_exception(fake_exc):
-  ex = fake_exc[2]
-  if ex.tb_frame.f_code.positions is None:
-    return
-  while ex is not None:
-    # .co_positions is supposed to be a function that returns an enumerable
-    # to the list of code positions. Create a function object wrapper around
-    # the data
-    def make_wrapper(rtn):
-      return lambda: rtn
-    ex.tb_frame.f_code.co_positions = make_wrapper(ex.tb_frame.f_code.positions)
-    ex = ex.tb_next
-
-
-class BufferedTestFailure(BufferedTestBase):
-  def updateResult(self, result):
-    fixup_fake_exception(self.error)
-    result.addFailure(self.test, self.error)
-
-
-class BufferedTestExpectedFailure(BufferedTestBase):
-  def updateResult(self, result):
-    fixup_fake_exception(self.error)
-    result.addExpectedFailure(self.test, self.error)
-
-
-class BufferedTestError(BufferedTestBase):
-  def updateResult(self, result):
-    fixup_fake_exception(self.error)
-    result.addError(self.test, self.error)
-
-
-class BufferedTestUnexpectedSuccess(BufferedTestBase):
-  def updateResult(self, result):
-    fixup_fake_exception(self.error)
-    result.addUnexpectedSuccess(self.test)
-
-
-class FakeTraceback:
-  """A fake version of a traceback object that is picklable across processes.
-
-  Python's traceback objects contain hidden stack information that isn't able
-  to be pickled. Further, traceback objects aren't constructable from Python,
-  so we need a dummy object that fulfills its interface.
-
-  The fields we expose are exactly those which are used by
-  unittest.TextTestResult to show a text representation of a traceback. Any
-  other use is not intended.
-  """
-
-  def __init__(self, tb):
-    self.tb_frame = FakeFrame(tb.tb_frame)
-    self.tb_lineno = tb.tb_lineno
-    self.tb_next = FakeTraceback(tb.tb_next) if tb.tb_next is not None else None
-    self.tb_lasti = tb.tb_lasti
-
-
-class FakeFrame:
-  def __init__(self, f):
-    self.f_code = FakeCode(f.f_code)
-    # f.f_globals is not picklable, not used in stack traces, and needs to be iterable
-    self.f_globals = []
-
-
-class FakeCode:
-  def __init__(self, co):
-    self.co_filename = co.co_filename
-    self.co_name = co.co_name
-    # co.co_positions() returns an iterator. Flatten it to a list so that it can
-    # be pickled to the parent process
-    if hasattr(co, 'co_positions'):
-      self.positions = list(co.co_positions())
-    else:
-      self.positions = None
-
-
 def num_cores():
   if NUM_CORES:
     return int(NUM_CORES)