Deprecated libcrash.a so stop testing it

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 34 matching lines @@
         if output != 'core':
             raise error.TestFail('core pattern should have been core, not %s' %
                                  output)
 
 
     def _prepare_crasher(self):
         """Extract the crasher and set its permissions.
 
         crasher is only gzipped to subvert Portage stripping.
         """
-        self._crasher_path = {
-            True: os.path.join(self.srcdir, 'crasher_breakpad'),
-            False: os.path.join(self.srcdir, 'crasher_nobreakpad')
-            }
+        self._crasher_path = os.path.join(self.srcdir, 'crasher_nobreakpad')
         utils.system('cd %s; tar xzf crasher.tgz' %
                      self.srcdir)
 
 
     def _populate_symbols(self):
         """Set up Breakpad's symbol structure.
 
         Breakpad's minidump processor expects symbols to be in a directory
         hierarchy:
           <symbol-root>/<module_name>/<file_id>/<module_name>.sym
         """
         # Dump the symbols from the crasher
         self._symbol_dir = os.path.join(self.srcdir, 'symbols')
         utils.system('rm -rf %s' % self._symbol_dir)
         os.mkdir(self._symbol_dir)
 
-        for with_breakpad in [True, False]:
-            basename = os.path.basename(self._crasher_path[with_breakpad])
-            utils.system('/usr/bin/dump_syms %s > %s.sym' %
-                         (self._crasher_path[with_breakpad],
-                          basename))
-            sym_name = '%s.sym' % basename
-            symbols = utils.read_file(sym_name)
-            # First line should be like:
-            # MODULE Linux x86 7BC3323FBDBA2002601FA5BA3186D6540 crasher_XXX
-            #  or
-            # MODULE Linux arm C2FE4895B203D87DD4D9227D5209F7890 crasher_XXX
-            first_line = symbols.split('\n')[0]
-            tokens = first_line.split()
-            if tokens[0] != 'MODULE' or tokens[1] != 'Linux':
-                raise error.TestError('Unexpected symbols format: %s',
-                                      first_line)
-            file_id = tokens[3]
-            target_dir = os.path.join(self._symbol_dir, basename, file_id)
-            os.makedirs(target_dir)
-            os.rename(sym_name, os.path.join(target_dir, sym_name))
+        basename = os.path.basename(self._crasher_path)
+        utils.system('/usr/bin/dump_syms %s > %s.sym' %
+                     (self._crasher_path,
+                      basename))
+        sym_name = '%s.sym' % basename
+        symbols = utils.read_file(sym_name)
+        # First line should be like:
+        # MODULE Linux x86 7BC3323FBDBA2002601FA5BA3186D6540 crasher_XXX
+        #  or
+        # MODULE Linux arm C2FE4895B203D87DD4D9227D5209F7890 crasher_XXX
+        first_line = symbols.split('\n')[0]
+        tokens = first_line.split()
+        if tokens[0] != 'MODULE' or tokens[1] != 'Linux':
+          raise error.TestError('Unexpected symbols format: %s',
+                                first_line)
+        file_id = tokens[3]
+        target_dir = os.path.join(self._symbol_dir, basename, file_id)
+        os.makedirs(target_dir)
+        os.rename(sym_name, os.path.join(target_dir, sym_name))
 
 
     def _verify_stack(self, stack, basename, from_crash_reporter):
         logging.debug('Crash stackwalk was: %s' % stack)
 
         # Should identify cause as SIGSEGV at address 0x16
         match = re.search(r'Crash reason:\s+(.*)', stack)
         expected_address = '0x16'
         if from_crash_reporter:
             # We cannot yet determine the crash address when coming
@@ skipping 13 matching lines @@
         # Should identify recursion line which is on the stack
         # for 15 levels
         if not ('15  %s!recbomb(int) [bomb.cc : 12 ' % basename) in stack:
             raise error.TestFail('Did not show recursion line on stack')
 
         # Should identify main line
         if not ('16  %s!main [crasher.cc : 21 ' % basename) in stack:
             raise error.TestFail('Did not show main on stack')
 
 
-    def _run_crasher_process(self, username, with_breakpad, cause_crash=True):
+    def _run_crasher_process(self, username, cause_crash=True):
         """Runs the crasher process.
 
         Args:
           username: runs as given user
-          with_breakpad: run crasher that has breakpad (-lcrash) linked in
           extra_args: additional parameters to pass to crasher process
 
         Returns:
           A dictionary with keys:
             returncode: return code of the crasher
             crashed: did the crasher return segv error code
             crash_reporter_caught: did crash_reporter catch a segv
             output: stderr/stdout output of the crasher process
         """
         self._prepare_crasher()
         self._populate_symbols()
 
         if username != 'root':
             crasher_command = ['su', username, '-c']
             expected_result = 128 + SIGSEGV
         else:
             crasher_command = []
             expected_result = -SIGSEGV
 
-        crasher_command.append(self._crasher_path[with_breakpad])
-        basename = os.path.basename(self._crasher_path[with_breakpad])
+        crasher_command.append(self._crasher_path)
+        basename = os.path.basename(self._crasher_path)
         if not cause_crash:
             crasher_command.append('--nocrash')
         crasher = subprocess.Popen(crasher_command,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)
         output = crasher.communicate()[1]
         logging.debug('Output from %s: %s' %
-                      (self._crasher_path[with_breakpad], output))
+                      (self._crasher_path, output))
 
         # Grab the pid from the process output.  We can't just use
         # crasher.pid unfortunately because that may be the PID of su.
         match = re.search(r'pid=(\d+)', output)
         if not match:
             raise error.TestFail('Could not find pid output from crasher: %s' %
                                  output)
         pid = int(match.group(1))
 
         expected_message = ('Received crash notification for '
@@ skipping 65 matching lines @@
             raise error.TestFail('Minidump not sent properly')
         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):
+    def _check_crashing_process(self, username):
         self._log_reader.set_start_by_current()
 
-        result = self._run_crasher_process(username, with_breakpad)
+        result = self._run_crasher_process(username)
 
         if not result['crashed']:
             raise error.TestFail('crasher did not do its job of crashing: %d' %
                                  result['returncode'])
 
         if not result['crash_reporter_caught']:
             logging.debug('Messages that should have included segv: %s' %
                           self._log_reader.get_logs())
             raise error.TestFail('Did not find segv message')
 
         crash_dir = self._get_crash_dir(username)
         crash_contents = os.listdir(crash_dir)
-        basename = os.path.basename(self._crasher_path[with_breakpad])
+        basename = os.path.basename(self._crasher_path)
 
         breakpad_minidump = None
         crash_reporter_minidump = None
 
         self._check_crash_directory_permissions(crash_dir)
 
         logging.debug('Contents in %s: %s' % (crash_dir, crash_contents))
 
         for filename in crash_contents:
             if filename.endswith('.core'):
                 # Ignore core files.  We'll test them later.
                 pass
             elif filename.startswith(basename):
                 # This appears to be a minidump created by the crash reporter.
                 if not crash_reporter_minidump is None:
                     raise error.TestFail('Crash reporter wrote multiple '
                                          'minidumps')
                 crash_reporter_minidump = os.path.join(crash_dir, filename)
             else:
                 # This appears to be a breakpad created minidump.
                 if not breakpad_minidump is None:
                     raise error.TestFail('Breakpad wrote multimpe minidumps')
                 breakpad_minidump = os.path.join(crash_dir, filename)
 
-        if with_breakpad and not breakpad_minidump:
-            raise error.TestFail('%s did not generate breakpad minidump' %
-                                 basename)
-
-        if not with_breakpad and breakpad_minidump:
+        if breakpad_minidump:
             raise error.TestFail('%s did generate breakpad minidump' % basename)
 
         if not crash_reporter_minidump:
             raise error.TestFail('crash reporter did not generate minidump')
 
         if not self._log_reader.can_find('Stored minidump to ' +
                                          crash_reporter_minidump):
             raise error.TestFail('crash reporter did not announce minidump')
 
         # By default test sending the crash_reporter minidump unless there
@@ skipping 22 matching lines @@
 
         self._check_generated_minidump_sending(send_minidump,
                                                username,
                                                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):
             raise error.TestFail('Normal exit of program with dumper failed')
 
 
-    def _test_chronos_breakpad_crasher(self):
-        """Test a user space crash when running as chronos is handled."""
-        self._check_crashing_process('chronos', True)
-
-
     def _test_chronos_nobreakpad_crasher(self):
         """Test a user space crash when running as chronos is handled."""
-        self._check_crashing_process('chronos', False)
-
-
-    def _test_root_breakpad_crasher(self):
-        """Test a user space crash when running as root is handled."""
-        self._check_crashing_process('root', True)
+        self._check_crashing_process('chronos')
 
 
     def _test_root_nobreakpad_crasher(self):
         """Test a user space crash when running as root is handled."""
-        self._check_crashing_process('root', False)
+        self._check_crashing_process('root')
 
 
     def _test_max_enqueued_crashes(self):
         """Test that _MAX_CRASH_DIRECTORY_SIZE is enforced."""
         self._log_reader.set_start_by_current()
         username = 'root'
 
         crash_dir = self._get_crash_dir(username)
         full_message = ('Crash directory %s already full with %d pending '
                         'reports' % (crash_dir, _MAX_CRASH_DIRECTORY_SIZE))
 
         # Fill up the queue.
         for i in range(0, _MAX_CRASH_DIRECTORY_SIZE):
-          result = self._run_crasher_process(username, with_breakpad=False)
+          result = self._run_crasher_process(username)
           if not result['crashed']:
             raise error.TestFail('failure while setting up queue: %d' %
                                  result['returncode'])
           if self._log_reader.can_find(full_message):
             raise error.TestFail('unexpected full message: ' + full_message)
 
         crash_dir_size = len(os.listdir(crash_dir))
         # For debugging
         utils.system('ls -l %s' % crash_dir)
         logging.info('Crash directory had %d entries' % crash_dir_size)
 
         # Crash a bunch more times, but make sure no new reports
         # are enqueued.
         for i in range(0, 10):
           self._log_reader.set_start_by_current()
-          result = self._run_crasher_process(username, with_breakpad=False)
+          result = self._run_crasher_process(username)
           logging.info('New log messages: %s' % self._log_reader.get_logs())
           if not result['crashed']:
             raise error.TestFail('failure after setting up queue: %d' %
                                  result['returncode'])
           if not self._log_reader.can_find(full_message):
             raise error.TestFail('expected full message: ' + full_message)
 
           if crash_dir_size != len(os.listdir(crash_dir)):
             utils.system('ls -l %s' % crash_dir)
             raise error.TestFail('expected no new files (now %d were %d)',
                                  len(os.listdir(crash_dir)),
                                  crash_dir_size)
 
 
     def _check_core_file_persisting(self, expect_persist):
         self._log_reader.set_start_by_current()
 
-        result = self._run_crasher_process('root', with_breakpad=False)
+        result = self._run_crasher_process('root')
 
         if not result['crashed']:
             raise error.TestFail('crasher did not crash')
 
         crash_contents = os.listdir(self._get_crash_dir('root'))
 
         logging.debug('Contents of crash directory: %s', crash_contents)
         logging.debug('Log messages: %s' % self._log_reader.get_logs())
 
         if expect_persist:
@@ skipping 43 matching lines @@
             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',
                               'max_enqueued_crashes',
                               'core_file_persists_in_debug',
                               'core_file_removed_in_production'],
                               initialize_crash_reporter = True)