[android] Upstream / sync most of build/android and build/android/pylib.

build/android/pylib/test_result.py

 # Copyright (c) 2012 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 json
 import logging
+import os
+import time
+import traceback
+
+import constants
 
 
 # Language values match constants in Sponge protocol buffer (sponge.proto).
 JAVA = 5
 PYTHON = 7
 
 
 class BaseTestResult(object):
   """A single result from a unit test."""
 
@@ skipping 11 matching lines @@
     dur: Duration of the test run in milliseconds.
     lang: Language of the test (JAVA or PYTHON).
     log: An optional string listing any errors.
     error: A tuple of a short error message and a longer version used by Sponge
     if test resulted in a fail or error.  An empty tuple implies a pass.
   """
 
   def __init__(self, full_name, start_date, dur, lang, log='', error=()):
     BaseTestResult.__init__(self, full_name, log)
     name_pieces = full_name.rsplit('#')
-    if len(name_pieces) > 0:
+    if len(name_pieces) > 1:
       self.test_name = name_pieces[1]
       self.class_name = name_pieces[0]
     else:
       self.class_name = full_name
       self.test_name = full_name
     self.start_date = start_date
     self.dur = dur
     self.error = error
     self.lang = lang
 
 
 class TestResults(object):
   """Results of a test run."""
 
   def __init__(self):
     self.ok = []
     self.failed = []
     self.crashed = []
     self.unknown = []
-    self.disabled = []
-    self.unexpected_pass = []
     self.timed_out = False
     self.overall_fail = False
 
   @staticmethod
   def FromRun(ok=None, failed=None, crashed=None, timed_out=False,
               overall_fail=False):
     ret = TestResults()
     ret.ok = ok or []
     ret.failed = failed or []
     ret.crashed = crashed or []
     ret.timed_out = timed_out
     ret.overall_fail = overall_fail
     return ret
 
   @staticmethod
   def FromTestResults(results):
     """Combines a list of results in a single TestResults object."""
     ret = TestResults()
     for t in results:
       ret.ok += t.ok
       ret.failed += t.failed
       ret.crashed += t.crashed
       ret.unknown += t.unknown
-      ret.disabled += t.disabled
-      ret.unexpected_pass += t.unexpected_pass
       if t.timed_out:
         ret.timed_out = True
       if t.overall_fail:
         ret.overall_fail = True
     return ret
 
+  @staticmethod
+  def FromPythonException(test_name, start_date_ms, exc_info):
+    """Constructs a TestResults with exception information for the given test.
+
+    Args:
+      test_name: name of the test which raised an exception.
+      start_date_ms: the starting time for the test.
+      exc_info: exception info, ostensibly from sys.exc_info().
+
+    Returns:
+      A TestResults object with a SingleTestResult in the failed list.
+    """
+    exc_type, exc_value, exc_traceback = exc_info
+    trace_info = ''.join(traceback.format_exception(exc_type, exc_value,
+                                                    exc_traceback))
+    log_msg = 'Exception:\n' + trace_info
+    duration_ms = (int(time.time()) * 1000) - start_date_ms
+
+    exc_result = SingleTestResult(
+                     full_name='PythonWrapper#' + test_name,
+                     start_date=start_date_ms,
+                     dur=duration_ms,
+                     lang=PYTHON,
+                     log=log_msg,
+                     error=(str(exc_type), log_msg))
+
+    results = TestResults()
+    results.failed.append(exc_result)
+    return results
+
   def _Log(self, sorted_list):
     for t in sorted_list:
       logging.critical(t.name)
       if t.log:
         logging.critical(t.log)
 
   def GetAllBroken(self):
     """Returns the all broken tests including failed, crashed, unknown."""
     return self.failed + self.crashed + self.unknown
 
-  def LogFull(self):
-    """Output all broken tests or 'passed' if none broken"""
+  def LogFull(self, test_group, test_suite):
+    """Output broken test logs, summarize in a log file and the test output."""
+    # Output all broken tests or 'passed' if none broken.
     logging.critical('*' * 80)
     logging.critical('Final result')
     if self.failed:
       logging.critical('Failed:')
       self._Log(sorted(self.failed))
     if self.crashed:
       logging.critical('Crashed:')
       self._Log(sorted(self.crashed))
     if self.unknown:
       logging.critical('Unknown:')
       self._Log(sorted(self.unknown))
     if not self.GetAllBroken():
       logging.critical('Passed')
     logging.critical('*' * 80)
 
+    # Summarize in a log file, if tests are running on bots.
+    if test_group and test_suite and os.environ.get('BUILDBOT_BUILDERNAME'):
+      log_file_path = os.path.join(constants.CHROME_DIR, 'out',
+                                   'Release', 'test_logs')
+      if not os.path.exists(log_file_path):
+        os.mkdir(log_file_path)
+      full_file_name = os.path.join(log_file_path, test_group)
+      if not os.path.exists(full_file_name):
+        with open(full_file_name, 'w') as log_file:
+          print >> log_file, '\n%s results for %s build %s:' % (
+              test_group, os.environ.get('BUILDBOT_BUILDERNAME'),
+              os.environ.get('BUILDBOT_BUILDNUMBER'))
+      log_contents = ['  %s result : %d tests ran' % (test_suite,
+                                                      len(self.ok) +
+                                                      len(self.failed) +
+                                                      len(self.crashed) +
+                                                      len(self.unknown))]
+      content_pairs = [('passed', len(self.ok)), ('failed', len(self.failed)),
+                       ('crashed', len(self.crashed))]
+      for (result, count) in content_pairs:
+        if count:
+          log_contents.append(', %d tests %s' % (count, result))
+      with open(full_file_name, 'a') as log_file:
+        print >> log_file, ''.join(log_contents)
+      content = {'test_group': test_group,
+                 'ok': [t.name for t in self.ok],
+                 'failed': [t.name for t in self.failed],
+                 'crashed': [t.name for t in self.failed],
+                 'unknown': [t.name for t in self.unknown],}
+      with open(os.path.join(log_file_path, 'results.json'), 'a') as json_file:
+        print >> json_file, json.dumps(content)
+
     # Summarize in the test output.
     summary_string = 'Summary:\n'
     summary_string += 'RAN=%d\n' % (len(self.ok) + len(self.failed) +
                                     len(self.crashed) + len(self.unknown))
     summary_string += 'PASSED=%d\n' % (len(self.ok))
     summary_string += 'FAILED=%d %s\n' % (len(self.failed),
                                           [t.name for t in self.failed])
     summary_string += 'CRASHED=%d %s\n' % (len(self.crashed),
                                            [t.name for t in self.crashed])
     summary_string += 'UNKNOWN=%d %s\n' % (len(self.unknown),
                                            [t.name for t in self.unknown])
     logging.critical(summary_string)
     return summary_string