Added full E2E kcrash testing

client/site_tests/logging_UserCrash/logging_UserCrash.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 grp, logging, os, pwd, re, stat, subprocess
 from signal import SIGSEGV
 from autotest_lib.client.bin import site_crash_test, site_utils, test
 from autotest_lib.client.common_lib import error, utils
 
 _CORE_PATTERN = '/proc/sys/kernel/core_pattern'
@@ skipping 13 matching lines @@
         """Test that the core_pattern is set up by crash reporter."""
         output = utils.read_file(_CORE_PATTERN).rstrip()
         expected_core_pattern = ('|%s --signal=%%s --pid=%%p' %
                                  self._CRASH_REPORTER_PATH)
         if output != expected_core_pattern:
             raise error.TestFail('core pattern should have been %s, not %s' %
                                  (expected_core_pattern, output))
 
         self._log_reader.set_start_by_reboot(-1)
 
-        if not self._log_reader.can_find('Enabling crash handling'):
+        if not self._log_reader.can_find('Enabling user crash handling'):
             raise error.TestFail(
                 'user space crash handling was not started during last boot')
 
 
     def _test_reporter_shutdown(self):
         """Test the crash_reporter shutdown code works."""
         self._log_reader.set_start_by_current()
         utils.system('%s --clean_shutdown' % self._CRASH_REPORTER_PATH)
         output = utils.read_file(_CORE_PATTERN).rstrip()
         if output != 'core':
@@ skipping 172 matching lines @@
 
     def _check_minidump_stackwalk(self, minidump_path, basename,
                                   from_crash_reporter):
         # Now stackwalk the minidump
         stack = utils.system_output('/usr/bin/minidump_stackwalk %s %s' %
                                     (minidump_path, self._symbol_dir))
         self._verify_stack(stack, basename, from_crash_reporter)
 
 
     def _check_generated_minidump_sending(self, minidump_path,
-                                          username, crasher_basename):
+                                          username, crasher_basename,
+                                          will_syslog_give_name):
         # Now check that the sending works
         self._set_sending(True)
         result = self._call_sender_one_crash(
             username=username,
-            minidump=os.path.basename(minidump_path))
+            report=os.path.basename(minidump_path))
         if (not result['send_attempt'] or not result['send_success'] or
-            result['minidump_exists']):
+            result['report_exists']):
             raise error.TestFail('Minidump not sent properly')
-        if not crasher_basename in result['output']:
-            raise error.TestFail('Log did not contain crashing executable name')
+        if will_syslog_give_name:
+            if result['exec_name'] != crasher_basename:
+                raise error.TestFail('Executable name incorrect')
+        if result['report_kind'] != 'minidump':
+            raise error.TestFail('Expected a minidump report')
+        if result['report_name'] != minidump_path:
+            raise error.TestFail('Sent the wrong minidump report')
 
 
     def _check_crashing_process(self, username, with_breakpad):
         self._log_reader.set_start_by_current()
 
         result = self._run_crasher_process(username, with_breakpad)
 
         if not result['crashed']:
             raise error.TestFail('crasher did not do its job of crashing: %d' %
                                  result['returncode'])
@@ skipping 45 matching lines @@
             raise error.TestFail('crash reporter did not announce minidump')
 
         # By default test sending the crash_reporter minidump unless there
         # is a breakpad minidump, and then we test sending it instead.
         send_minidump = crash_reporter_minidump
 
         if crash_reporter_minidump:
             self._check_minidump_stackwalk(crash_reporter_minidump,
                                            basename,
                                            from_crash_reporter=True)
+            will_syslog_give_name = True
 
         if breakpad_minidump:
             self._check_minidump_stackwalk(breakpad_minidump,
                                            basename,
                                            from_crash_reporter=False)
             send_minidump = breakpad_minidump
             os.unlink(crash_reporter_minidump)
+            # If you link against -lcrash, upon sending the syslog will
+            # just say exec_name: <very-long-guid>, where that GUID is the
+            # GUID generated during breakpad.  Since -lcrash is going away,
+            # it seems ok to have the syslog be a little more opaque for
+            # these crashes.  They'll be next to sends for the real crash
+            # anyway.
+            will_syslog_give_name = False
 
         self._check_generated_minidump_sending(send_minidump,
                                                username,
-                                               basename)
+                                               basename,
+                                               will_syslog_give_name)
 
     def _test_no_crash(self):
         """Test a program linked against libcrash_dumper can exit normally."""
         self._log_reader.set_start_by_current()
         result = self._run_crasher_process(username='root',
                                            with_breakpad=True,
                                            cause_crash=False)
         if (result['crashed'] or
             result['crash_reporter_caught'] or
             result['returncode'] != 0):
@@ skipping 77 matching lines @@
                 raise error.TestFail('.leave_core file did not disappear')
             self._check_core_file_persisting(False)
         finally:
             os.system('umount /root')
 
 
     # TODO(kmixter): Test crashing a process as ntp or some other
     # non-root, non-chronos user.
 
     def run_once(self):
-        self.run_crash_tests([
-            'reporter_startup',
-            'reporter_shutdown',
-            'no_crash',
-            'chronos_breakpad_crasher',
-            'chronos_nobreakpad_crasher',
-            'root_breakpad_crasher',
-            'root_nobreakpad_crasher',
-            'core_file_persists_in_debug',
-            'core_file_removed_in_production',
-            ])
+        self.run_crash_tests(['reporter_startup',
+                              'reporter_shutdown',
+                              'no_crash',
+                              'chronos_breakpad_crasher',
+                              'chronos_nobreakpad_crasher',
+                              'root_breakpad_crasher',
+                              'root_nobreakpad_crasher',
+                              'core_file_persists_in_debug',
+                              'core_file_removed_in_production'],
+                              initialize_crash_reporter = True)