All tests based on cros_ui_test.UITest now get crash checking for free.

client/cros/cros_ui_test.py

 # Copyright (c) 2010 The Chromium OS 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 dbus, logging, os, re, shutil, socket, sys, time
 import common
 import auth_server, constants as chromeos_constants, cryptohome, dns_server
 import cros_logging, cros_ui, login
 from autotest_lib.client.bin import test, utils
 from autotest_lib.client.common_lib import error
@@ skipping 14 matching lines @@
     variable 'auto_login' to False.
 
     Subclasses can log in with arbitrary credentials by passing
     the 'creds' parameter in their control file.  See the documentation of
     UITest.initialize for more details.
 
     If your subclass overrides the initialize() or cleanup() methods, it
     should make sure to invoke this class' version of those methods as well.
     The standard super(...) function cannot be used for this, since the base
     test class is not a 'new style' Python class.
+
+    Any crashes detected during the test run will automatically generate a test
+    failure exception, to disable this behavior set ignore_crashes = True.
     """
     version = 1
 
     auto_login = True
     username = None
     password = None
 
-    """Processes that we know crash and are willing to ignore."""
-    crash_blacklist = ['powerm']
+    ignore_crashes = False
 
     def __init__(self, job, bindir, outputdir):
         self._dns = {}  # for saving/restoring dns entries
         test.test.__init__(self, job, bindir, outputdir)
 
     def xsystem(self, cmd, timeout=None, ignore_status=False):
         """Convenience wrapper around cros_ui.xsystem, to save you an import.
         """
         return cros_ui.xsystem(cmd, timeout, ignore_status)
 
@@ skipping 227 matching lines @@
         """Tears down fake dns and fake Google Accounts server.  If your
         subclass does not create these objects, you will want to override this
         method as well.
         """
         if hasattr(self, '_authServer'):
             self.revert_dns()
             self._authServer.stop()
             self._dnsServer.stop()
 
 
-    def __log_crashed_processes(self, processes):
-        """Runs through the log watched by |watcher| to see if a crash was
-        reported for any process names listed in |processes|.
+    def __check_for_crashes(self):
+        """Runs through logs collected since initialization to see if any crash
+        was reported. Crashes are recorded as INFO messages plus raised as a
+        error.TestFail exception.
         """
-        regex = re.compile(r'Received crash notification for (\w+).+ (sig \d+)',
-                           re.MULTILINE)
+        crashes = []
+        regex = re.compile('Received crash notification for (.+)', re.MULTILINE)
         for match in regex.finditer(self._log_reader.get_logs()):
-            if match.group(1) in processes:
-                self.job.record('INFO', self.tagged_testname,
-                                "%s crash" % m.group(1), m.group(2))
+            self.job.record('INFO', self.tagged_testname,
+                            'Crash detected: %s' % match.group(1))
+            crashes.append(match.group(1))
+
+        if crashes:
+            raise error.TestFail('Crash(es) detected: %s' % ', '.join(crashes))
 
 
     def cleanup(self):
         """Overridden from test.cleanup() to log out when the test is complete.
         """
         logpath = chromeos_constants.CHROME_LOG_DIR
 
         try:
             for file in os.listdir(logpath):
                 fullpath = os.path.join(logpath, file)
@@ skipping 15 matching lines @@
 
         if os.path.isfile(chromeos_constants.CRYPTOHOMED_LOG):
             try:
                 base = os.path.basename(chromeos_constants.CRYPTOHOMED_LOG)
                 shutil.copy(chromeos_constants.CRYPTOHOMED_LOG,
                             os.path.join(self.resultsdir, base))
             except (IOError, OSError) as error:
                 logging.error(error)
 
         self.stop_authserver()
-        self.__log_crashed_processes(self.crash_blacklist)
+        # Make sure this is the last line as it will throw exceptions preventing
+        # subsequent cleanup code from running.
+        if not self.ignore_crashes:
+            self.__check_for_crashes()
 
 
     def get_auth_endpoint_misses(self):
         if hasattr(self, '_authServer'):
             return self._authServer.get_endpoint_misses()
         else:
             return {}