Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame^] | 1 | #!/usr/bin/env python |
| 2 | # Copyright 2014 The Chromium Authors. All rights reserved. |
| 3 | # Use of this source code is governed by a BSD-style license that can be |
| 4 | # found in the LICENSE file. |
| 5 | |
| 6 | import functools |
| 7 | import logging |
| 8 | import os |
| 9 | import unittest |
| 10 | |
| 11 | from pylib.symbols import elf_symbolizer |
| 12 | from pylib.symbols import mock_addr2line |
| 13 | |
| 14 | |
| 15 | _MOCK_A2L_PATH = os.path.join(os.path.dirname(mock_addr2line.__file__), |
| 16 | 'mock_addr2line') |
| 17 | _INCOMPLETE_MOCK_ADDR = 1024 * 1024 |
| 18 | _UNKNOWN_MOCK_ADDR = 2 * 1024 * 1024 |
| 19 | _INLINE_MOCK_ADDR = 3 * 1024 * 1024 |
| 20 | |
| 21 | |
| 22 | class ELFSymbolizerTest(unittest.TestCase): |
| 23 | def setUp(self): |
| 24 | self._callback = functools.partial( |
| 25 | ELFSymbolizerTest._SymbolizeCallback, self) |
| 26 | self._resolved_addresses = set() |
| 27 | # Mute warnings, we expect them due to the crash/hang tests. |
| 28 | logging.getLogger().setLevel(logging.ERROR) |
| 29 | |
| 30 | def testParallelism1(self): |
| 31 | self._RunTest(max_concurrent_jobs=1, num_symbols=100) |
| 32 | |
| 33 | def testParallelism4(self): |
| 34 | self._RunTest(max_concurrent_jobs=4, num_symbols=100) |
| 35 | |
| 36 | def testParallelism8(self): |
| 37 | self._RunTest(max_concurrent_jobs=8, num_symbols=100) |
| 38 | |
| 39 | def testCrash(self): |
| 40 | os.environ['MOCK_A2L_CRASH_EVERY'] = '99' |
| 41 | self._RunTest(max_concurrent_jobs=1, num_symbols=100) |
| 42 | os.environ['MOCK_A2L_CRASH_EVERY'] = '0' |
| 43 | |
| 44 | def testHang(self): |
| 45 | os.environ['MOCK_A2L_HANG_EVERY'] = '99' |
| 46 | self._RunTest(max_concurrent_jobs=1, num_symbols=100) |
| 47 | os.environ['MOCK_A2L_HANG_EVERY'] = '0' |
| 48 | |
| 49 | def testInlines(self): |
| 50 | """Stimulate the inline processing logic.""" |
| 51 | symbolizer = elf_symbolizer.ELFSymbolizer( |
| 52 | elf_file_path='/path/doesnt/matter/mock_lib1.so', |
| 53 | addr2line_path=_MOCK_A2L_PATH, |
| 54 | callback=self._callback, |
| 55 | inlines=True, |
| 56 | max_concurrent_jobs=4) |
| 57 | |
| 58 | for addr in xrange(1000): |
| 59 | exp_inline = False |
| 60 | exp_unknown = False |
| 61 | |
| 62 | # First 100 addresses with inlines. |
| 63 | if addr < 100: |
| 64 | addr += _INLINE_MOCK_ADDR |
| 65 | exp_inline = True |
| 66 | |
| 67 | # Followed by 100 without inlines. |
| 68 | elif addr < 200: |
| 69 | pass |
| 70 | |
| 71 | # Followed by 100 interleaved inlines and not inlines. |
| 72 | elif addr < 300: |
| 73 | if addr & 1: |
| 74 | addr += _INLINE_MOCK_ADDR |
| 75 | exp_inline = True |
| 76 | |
| 77 | # Followed by 100 interleaved inlines and unknonwn. |
| 78 | elif addr < 400: |
| 79 | if addr & 1: |
| 80 | addr += _INLINE_MOCK_ADDR |
| 81 | exp_inline = True |
| 82 | else: |
| 83 | addr += _UNKNOWN_MOCK_ADDR |
| 84 | exp_unknown = True |
| 85 | |
| 86 | exp_name = 'mock_sym_for_addr_%d' % addr if not exp_unknown else None |
| 87 | exp_source_path = 'mock_src/mock_lib1.so.c' if not exp_unknown else None |
| 88 | exp_source_line = addr if not exp_unknown else None |
| 89 | cb_arg = (addr, exp_name, exp_source_path, exp_source_line, exp_inline) |
| 90 | symbolizer.SymbolizeAsync(addr, cb_arg) |
| 91 | |
| 92 | symbolizer.Join() |
| 93 | |
| 94 | def testIncompleteSyminfo(self): |
| 95 | """Stimulate the symbol-not-resolved logic.""" |
| 96 | symbolizer = elf_symbolizer.ELFSymbolizer( |
| 97 | elf_file_path='/path/doesnt/matter/mock_lib1.so', |
| 98 | addr2line_path=_MOCK_A2L_PATH, |
| 99 | callback=self._callback, |
| 100 | max_concurrent_jobs=1) |
| 101 | |
| 102 | # Test symbols with valid name but incomplete path. |
| 103 | addr = _INCOMPLETE_MOCK_ADDR |
| 104 | exp_name = 'mock_sym_for_addr_%d' % addr |
| 105 | exp_source_path = None |
| 106 | exp_source_line = None |
| 107 | cb_arg = (addr, exp_name, exp_source_path, exp_source_line, False) |
| 108 | symbolizer.SymbolizeAsync(addr, cb_arg) |
| 109 | |
| 110 | # Test symbols with no name or sym info. |
| 111 | addr = _UNKNOWN_MOCK_ADDR |
| 112 | exp_name = None |
| 113 | exp_source_path = None |
| 114 | exp_source_line = None |
| 115 | cb_arg = (addr, exp_name, exp_source_path, exp_source_line, False) |
| 116 | symbolizer.SymbolizeAsync(addr, cb_arg) |
| 117 | |
| 118 | symbolizer.Join() |
| 119 | |
| 120 | def _RunTest(self, max_concurrent_jobs, num_symbols): |
| 121 | symbolizer = elf_symbolizer.ELFSymbolizer( |
| 122 | elf_file_path='/path/doesnt/matter/mock_lib1.so', |
| 123 | addr2line_path=_MOCK_A2L_PATH, |
| 124 | callback=self._callback, |
| 125 | max_concurrent_jobs=max_concurrent_jobs, |
| 126 | addr2line_timeout=0.5) |
| 127 | |
| 128 | for addr in xrange(num_symbols): |
| 129 | exp_name = 'mock_sym_for_addr_%d' % addr |
| 130 | exp_source_path = 'mock_src/mock_lib1.so.c' |
| 131 | exp_source_line = addr |
| 132 | cb_arg = (addr, exp_name, exp_source_path, exp_source_line, False) |
| 133 | symbolizer.SymbolizeAsync(addr, cb_arg) |
| 134 | |
| 135 | symbolizer.Join() |
| 136 | |
| 137 | # Check that all the expected callbacks have been received. |
| 138 | for addr in xrange(num_symbols): |
| 139 | self.assertIn(addr, self._resolved_addresses) |
| 140 | self._resolved_addresses.remove(addr) |
| 141 | |
| 142 | # Check for unexpected callbacks. |
| 143 | self.assertEqual(len(self._resolved_addresses), 0) |
| 144 | |
| 145 | def _SymbolizeCallback(self, sym_info, cb_arg): |
| 146 | self.assertTrue(isinstance(sym_info, elf_symbolizer.ELFSymbolInfo)) |
| 147 | self.assertTrue(isinstance(cb_arg, tuple)) |
| 148 | self.assertEqual(len(cb_arg), 5) |
| 149 | |
| 150 | # Unpack expectations from the callback extra argument. |
| 151 | (addr, exp_name, exp_source_path, exp_source_line, exp_inlines) = cb_arg |
| 152 | if exp_name is None: |
| 153 | self.assertIsNone(sym_info.name) |
| 154 | else: |
| 155 | self.assertTrue(sym_info.name.startswith(exp_name)) |
| 156 | self.assertEqual(sym_info.source_path, exp_source_path) |
| 157 | self.assertEqual(sym_info.source_line, exp_source_line) |
| 158 | |
| 159 | if exp_inlines: |
| 160 | self.assertEqual(sym_info.name, exp_name + '_inner') |
| 161 | self.assertEqual(sym_info.inlined_by.name, exp_name + '_middle') |
| 162 | self.assertEqual(sym_info.inlined_by.inlined_by.name, |
| 163 | exp_name + '_outer') |
| 164 | |
| 165 | # Check against duplicate callbacks. |
| 166 | self.assertNotIn(addr, self._resolved_addresses) |
| 167 | self._resolved_addresses.add(addr) |
| 168 | |
| 169 | |
| 170 | if __name__ == '__main__': |
| 171 | unittest.main() |