Remove the inheritance from PageTestResults to unittest.TestResult.

BUG=383100

Review URL: https://codereview.chromium.org/338633002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@278287 0039d316-1c4b-4281-b951-d872f2087c98

tools/telemetry/telemetry/results/gtest_test_results.py

@@ -5,7 +5,6 @@
 import logging
 import sys
 import time
-import unittest
 
 from telemetry.results import page_test_results
 
@@ -22,46 +21,37 @@ class GTestTestResults(page_test_results.PageTestResults):
   def num_errors(self):
     return len(self.errors) + len(self.failures)
 
-  @staticmethod
-  def _formatTestname(test):
-    if isinstance(test, unittest.TestCase):
-      chunks = test.id().split('.')[2:]
-      return '.'.join(chunks)
-    else:
-      return str(test)
-
-  def _emitFailure(self, test, err):
-    print >> self._output_stream, self._exc_info_to_string(err, test)
-    test_name = GTestTestResults._formatTestname(test)
-    print >> self._output_stream, '[  FAILED  ]', test_name, (
+  def _emitFailure(self, page, err):
+    print >> self._output_stream, self._GetStringFromExcInfo(err)
+    print >> self._output_stream, '[  FAILED  ]', page.display_name, (
         '(%0.f ms)' % self._GetMs())
     sys.stdout.flush()
 
-  def addError(self, test, err):
-    super(GTestTestResults, self).addError(test, err)
-    self._emitFailure(test, err)
+  def AddError(self, page, err):
+    super(GTestTestResults, self).AddError(page, err)
+    self._emitFailure(page, err)
 
-  def addFailure(self, test, err):
-    super(GTestTestResults, self).addFailure(test, err)
-    self._emitFailure(test, err)
+  def AddFailure(self, page, err):
+    super(GTestTestResults, self).AddFailure(page, err)
+    self._emitFailure(page, err)
 
-  def startTest(self, test):
-    super(GTestTestResults, self).startTest(test)
+  def StartTest(self, page):
+    super(GTestTestResults, self).StartTest(page)
     print >> self._output_stream, '[ RUN      ]', (
-        GTestTestResults._formatTestname(test))
+        page.display_name)
     sys.stdout.flush()
     self._timestamp = time.time()
 
-  def addSuccess(self, test):
-    super(GTestTestResults, self).addSuccess(test)
-    test_name = GTestTestResults._formatTestname(test)
+  def AddSuccess(self, page):
+    super(GTestTestResults, self).AddSuccess(page)
+    test_name = page.display_name
     print >> self._output_stream, '[       OK ]', test_name, (
         '(%0.f ms)' % self._GetMs())
     sys.stdout.flush()
 
-  def addSkip(self, test, reason):
-    super(GTestTestResults, self).addSkip(test, reason)
-    test_name = GTestTestResults._formatTestname(test)
+  def AddSkip(self, page, reason):
+    super(GTestTestResults, self).AddSkip(page, reason)
+    test_name = page.display_name
     logging.warning('===== SKIPPING TEST %s: %s =====', test_name, reason)
     if self._timestamp == None:
       self._timestamp = time.time()
@@ -79,10 +69,9 @@ class GTestTestResults(page_test_results.PageTestResults):
       unit = 'test' if len(all_errors) == 1 else 'tests'
       print >> self._output_stream, '[  FAILED  ]', (
           '%d %s, listed below:' % (len(all_errors), unit))
-      for test, _ in all_errors:
+      for page, _ in all_errors:
         print >> self._output_stream, '[  FAILED  ] ', (
-            GTestTestResults._formatTestname(test))
-    if not self.wasSuccessful():
+            page.display_name)
       print >> self._output_stream
       count = len(self.errors) + len(self.failures)
       unit = 'TEST' if count == 1 else 'TESTS'

tools/telemetry/telemetry/results/gtest_test_results_unittest.py

@@ -86,6 +86,18 @@ class GTestTestResultsTest(
                 '1 FAILED TEST\n\n' % exception_trace)
     self.assertEquals(expected, ''.join(results.output_data))
 
+  def testSingleSkippedPage(self):
+    test_page_set = _MakePageSet()
+    results = SummaryGtestTestResults()
+    results.StartTest(test_page_set.pages[0])
+    self._mock_timer.SetTime(0.007)
+    results.AddSkip(test_page_set.pages[0], 'Page skipped for testing reason')
+    results.PrintSummary()
+    expected = ('[ RUN      ] http://www.foo.com/\n'
+                '[       OK ] http://www.foo.com/ (7 ms)\n'
+                '[  PASSED  ] 0 tests.\n\n')
+    self.assertEquals(expected, ''.join(results.output_data))
+
   def testPassAndFailedPages(self):
     test_page_set = _MakePageSet()
     results = SummaryGtestTestResults()
@@ -126,5 +138,27 @@ class GTestTestResultsTest(
                 '2 FAILED TESTS\n\n' % (exception_trace, exception_trace))
     self.assertEquals(expected, ''.join(results.output_data))
 
+  def testStreamingResults(self):
+    test_page_set = _MakePageSet()
+    results = SummaryGtestTestResults()
+    exception = self.CreateException()
+
+    results.StartTest(test_page_set.pages[0])
+    self._mock_timer.SetTime(0.007)
+    results.AddSuccess(test_page_set.pages[0])
+    expected = ('[ RUN      ] http://www.foo.com/\n'
+                '[       OK ] http://www.foo.com/ (7 ms)\n')
+    self.assertEquals(expected, ''.join(results.output_data))
+
+    results.StartTest(test_page_set.pages[1])
+    self._mock_timer.SetTime(0.009)
+    exception_trace = ''.join(traceback.format_exception(*exception))
+    results.AddError(test_page_set.pages[1], exception)
+    expected = ('[ RUN      ] http://www.foo.com/\n'
+                '[       OK ] http://www.foo.com/ (7 ms)\n'
+                '[ RUN      ] http://www.bar.com/\n'
+                '%s\n'
+                '[  FAILED  ] http://www.bar.com/ (2 ms)\n' % exception_trace)
+
   def tearDown(self):
     gtest_test_results.time.time = self._real_gtest_time_time

tools/telemetry/telemetry/results/page_test_results.py

@@ -7,15 +7,17 @@ import copy
 import logging
 import sys
 import traceback
-import unittest
 
-class PageTestResults(unittest.TestResult):
+
+class PageTestResults(object):
   def __init__(self, output_stream=None):
     super(PageTestResults, self).__init__()
     self._output_stream = output_stream
     self.pages_that_had_errors = set()
     self.pages_that_had_failures = set()
     self.successes = []
+    self.errors = []
+    self.failures = []
     self.skipped = []
 
   def __copy__(self):
@@ -32,38 +34,28 @@ class PageTestResults(unittest.TestResult):
     return self.pages_that_had_errors.union(
       self.pages_that_had_failures)
 
-  def _exc_info_to_string(self, err, test):
-    if isinstance(test, unittest.TestCase):
-      return super(PageTestResults, self)._exc_info_to_string(err, test)
-    else:
+  def _GetStringFromExcInfo(self, err):
     return ''.join(traceback.format_exception(*err))
 
-  def addSuccess(self, test):
-    self.successes.append(test)
-
-  def addSkip(self, test, reason):  # Python 2.7 has this in unittest.TestResult
-    logging.warning('%s\n%s\nSkipping page.', test, reason)
-    self.skipped.append((test, reason))
-
   def StartTest(self, page):
-    self.startTest(page.display_name)
+    pass
 
   def StopTest(self, page):
-    self.stopTest(page.display_name)
+    pass
 
   def AddError(self, page, err):
     self.pages_that_had_errors.add(page)
-    self.addError(page.display_name, err)
+    self.errors.append((page, self._GetStringFromExcInfo(err)))
 
   def AddFailure(self, page, err):
     self.pages_that_had_failures.add(page)
-    self.addFailure(page.display_name, err)
-
-  def AddSuccess(self, page):
-    self.addSuccess(page.display_name)
+    self.failures.append((page, self._GetStringFromExcInfo(err)))
 
   def AddSkip(self, page, reason):
-    self.addSkip(page.display_name, reason)
+    self.skipped.append((page, reason))
+
+  def AddSuccess(self, page):
+    self.successes.append(page)
 
   def AddFailureMessage(self, page, message):
     try:
@@ -79,10 +71,13 @@ class PageTestResults(unittest.TestResult):
 
   def PrintSummary(self):
     if self.failures:
-      logging.error('Failed pages:\n%s', '\n'.join(zip(*self.failures)[0]))
+      logging.error('Failed pages:\n%s', '\n'.join(
+          p.display_name for p in zip(*self.failures)[0]))
 
     if self.errors:
-      logging.error('Errored pages:\n%s', '\n'.join(zip(*self.errors)[0]))
+      logging.error('Errored pages:\n%s', '\n'.join(
+          p.display_name for p in zip(*self.errors)[0]))
 
     if self.skipped:
-      logging.warning('Skipped pages:\n%s', '\n'.join(zip(*self.skipped)[0]))
+      logging.warning('Skipped pages:\n%s', '\n'.join(
+          p.display_name for p in zip(*self.skipped)[0]))

tools/telemetry/telemetry/results/page_test_results_unittest.py

@@ -32,8 +32,7 @@ class PageTestResultsTest(base_test_results_unittest.BaseTestResultsUnittest):
     results.AddSuccess(self.pages[1])
     self.assertEquals(results.pages_that_had_failures,
                       set([self.pages[0]]))
-    self.assertEquals(results.successes,
-                      [self.pages[1].display_name])
+    self.assertEquals(results.successes, [self.pages[1]])
 
   def test_errors(self):
     results = NonPrintingPageTestResults()
@@ -41,8 +40,7 @@ class PageTestResultsTest(base_test_results_unittest.BaseTestResultsUnittest):
     results.AddSuccess(self.pages[1])
     self.assertEquals(results.pages_that_had_errors,
                       set([self.pages[0]]))
-    self.assertEquals(results.successes,
-                      [self.pages[1].display_name])
+    self.assertEquals(results.successes, [self.pages[1]])
 
   def test_errors_and_failures(self):
     results = NonPrintingPageTestResults()
@@ -51,5 +49,4 @@ class PageTestResultsTest(base_test_results_unittest.BaseTestResultsUnittest):
     results.AddSuccess(self.pages[2])
     self.assertEquals(results.pages_that_had_errors_or_failures,
                       set([self.pages[0], self.pages[1]]))
-    self.assertEquals(results.successes,
-                      [self.pages[2].display_name])
+    self.assertEquals(results.successes, [self.pages[2]])