| 1 |
import re |
| 2 |
import sys |
| 3 |
from test import support |
| 4 |
|
| 5 |
from .util import ( |
| 6 |
BREAKPOINT_FN, GDB_VERSION, |
| 7 |
run_gdb, setup_module, DebuggerTests) |
| 8 |
|
| 9 |
|
| 10 |
def setUpModule(): |
| 11 |
setup_module() |
| 12 |
|
| 13 |
|
| 14 |
class PrettyPrintTests(DebuggerTests): |
| 15 |
def get_gdb_repr(self, source, |
| 16 |
cmds_after_breakpoint=None, |
| 17 |
import_site=False): |
| 18 |
# Given an input python source representation of data, |
| 19 |
# run "python -c'id(DATA)'" under gdb with a breakpoint on |
| 20 |
# builtin_id and scrape out gdb's representation of the "op" |
| 21 |
# parameter, and verify that the gdb displays the same string |
| 22 |
# |
| 23 |
# Verify that the gdb displays the expected string |
| 24 |
# |
| 25 |
# For a nested structure, the first time we hit the breakpoint will |
| 26 |
# give us the top-level structure |
| 27 |
|
| 28 |
# NOTE: avoid decoding too much of the traceback as some |
| 29 |
# undecodable characters may lurk there in optimized mode |
| 30 |
# (issue #19743). |
| 31 |
cmds_after_breakpoint = cmds_after_breakpoint or ["backtrace 1"] |
| 32 |
gdb_output = self.get_stack_trace(source, breakpoint=BREAKPOINT_FN, |
| 33 |
cmds_after_breakpoint=cmds_after_breakpoint, |
| 34 |
import_site=import_site) |
| 35 |
# gdb can insert additional '\n' and space characters in various places |
| 36 |
# in its output, depending on the width of the terminal it's connected |
| 37 |
# to (using its "wrap_here" function) |
| 38 |
m = re.search( |
| 39 |
# Match '#0 builtin_id(self=..., v=...)' |
| 40 |
r'#0\s+builtin_id\s+\(self\=.*,\s+v=\s*(.*?)?\)' |
| 41 |
# Match ' at Python/bltinmodule.c'. |
| 42 |
# bpo-38239: builtin_id() is defined in Python/bltinmodule.c, |
| 43 |
# but accept any "Directory\file.c" to support Link Time |
| 44 |
# Optimization (LTO). |
| 45 |
r'\s+at\s+\S*[A-Za-z]+/[A-Za-z0-9_-]+\.c', |
| 46 |
gdb_output, re.DOTALL) |
| 47 |
if not m: |
| 48 |
self.fail('Unexpected gdb output: %r\n%s' % (gdb_output, gdb_output)) |
| 49 |
return m.group(1), gdb_output |
| 50 |
|
| 51 |
def test_getting_backtrace(self): |
| 52 |
gdb_output = self.get_stack_trace('id(42)') |
| 53 |
self.assertTrue(BREAKPOINT_FN in gdb_output) |
| 54 |
|
| 55 |
def assertGdbRepr(self, val, exp_repr=None): |
| 56 |
# Ensure that gdb's rendering of the value in a debugged process |
| 57 |
# matches repr(value) in this process: |
| 58 |
gdb_repr, gdb_output = self.get_gdb_repr('id(' + ascii(val) + ')') |
| 59 |
if not exp_repr: |
| 60 |
exp_repr = repr(val) |
| 61 |
self.assertEqual(gdb_repr, exp_repr, |
| 62 |
('%r did not equal expected %r; full output was:\n%s' |
| 63 |
% (gdb_repr, exp_repr, gdb_output))) |
| 64 |
|
| 65 |
@support.requires_resource('cpu') |
| 66 |
def test_int(self): |
| 67 |
'Verify the pretty-printing of various int values' |
| 68 |
self.assertGdbRepr(42) |
| 69 |
self.assertGdbRepr(0) |
| 70 |
self.assertGdbRepr(-7) |
| 71 |
self.assertGdbRepr(1000000000000) |
| 72 |
self.assertGdbRepr(-1000000000000000) |
| 73 |
|
| 74 |
def test_singletons(self): |
| 75 |
'Verify the pretty-printing of True, False and None' |
| 76 |
self.assertGdbRepr(True) |
| 77 |
self.assertGdbRepr(False) |
| 78 |
self.assertGdbRepr(None) |
| 79 |
|
| 80 |
def test_dicts(self): |
| 81 |
'Verify the pretty-printing of dictionaries' |
| 82 |
self.assertGdbRepr({}) |
| 83 |
self.assertGdbRepr({'foo': 'bar'}, "{'foo': 'bar'}") |
| 84 |
# Python preserves insertion order since 3.6 |
| 85 |
self.assertGdbRepr({'foo': 'bar', 'douglas': 42}, "{'foo': 'bar', 'douglas': 42}") |
| 86 |
|
| 87 |
def test_lists(self): |
| 88 |
'Verify the pretty-printing of lists' |
| 89 |
self.assertGdbRepr([]) |
| 90 |
self.assertGdbRepr(list(range(5))) |
| 91 |
|
| 92 |
@support.requires_resource('cpu') |
| 93 |
def test_bytes(self): |
| 94 |
'Verify the pretty-printing of bytes' |
| 95 |
self.assertGdbRepr(b'') |
| 96 |
self.assertGdbRepr(b'And now for something hopefully the same') |
| 97 |
self.assertGdbRepr(b'string with embedded NUL here \0 and then some more text') |
| 98 |
self.assertGdbRepr(b'this is a tab:\t' |
| 99 |
b' this is a slash-N:\n' |
| 100 |
b' this is a slash-R:\r' |
| 101 |
) |
| 102 |
|
| 103 |
self.assertGdbRepr(b'this is byte 255:\xff and byte 128:\x80') |
| 104 |
|
| 105 |
self.assertGdbRepr(bytes([b for b in range(255)])) |
| 106 |
|
| 107 |
@support.requires_resource('cpu') |
| 108 |
def test_strings(self): |
| 109 |
'Verify the pretty-printing of unicode strings' |
| 110 |
# We cannot simply call locale.getpreferredencoding() here, |
| 111 |
# as GDB might have been linked against a different version |
| 112 |
# of Python with a different encoding and coercion policy |
| 113 |
# with respect to PEP 538 and PEP 540. |
| 114 |
stdout, stderr = run_gdb( |
| 115 |
'--eval-command', |
| 116 |
'python import locale; print(locale.getpreferredencoding())') |
| 117 |
|
| 118 |
encoding = stdout |
| 119 |
if stderr or not encoding: |
| 120 |
raise RuntimeError( |
| 121 |
f'unable to determine the Python locale preferred encoding ' |
| 122 |
f'of embedded Python in GDB\n' |
| 123 |
f'stdout={stdout!r}\n' |
| 124 |
f'stderr={stderr!r}') |
| 125 |
|
| 126 |
def check_repr(text): |
| 127 |
try: |
| 128 |
text.encode(encoding) |
| 129 |
except UnicodeEncodeError: |
| 130 |
self.assertGdbRepr(text, ascii(text)) |
| 131 |
else: |
| 132 |
self.assertGdbRepr(text) |
| 133 |
|
| 134 |
self.assertGdbRepr('') |
| 135 |
self.assertGdbRepr('And now for something hopefully the same') |
| 136 |
self.assertGdbRepr('string with embedded NUL here \0 and then some more text') |
| 137 |
|
| 138 |
# Test printing a single character: |
| 139 |
# U+2620 SKULL AND CROSSBONES |
| 140 |
check_repr('\u2620') |
| 141 |
|
| 142 |
# Test printing a Japanese unicode string |
| 143 |
# (I believe this reads "mojibake", using 3 characters from the CJK |
| 144 |
# Unified Ideographs area, followed by U+3051 HIRAGANA LETTER KE) |
| 145 |
check_repr('\u6587\u5b57\u5316\u3051') |
| 146 |
|
| 147 |
# Test a character outside the BMP: |
| 148 |
# U+1D121 MUSICAL SYMBOL C CLEF |
| 149 |
# This is: |
| 150 |
# UTF-8: 0xF0 0x9D 0x84 0xA1 |
| 151 |
# UTF-16: 0xD834 0xDD21 |
| 152 |
check_repr(chr(0x1D121)) |
| 153 |
|
| 154 |
def test_tuples(self): |
| 155 |
'Verify the pretty-printing of tuples' |
| 156 |
self.assertGdbRepr(tuple(), '()') |
| 157 |
self.assertGdbRepr((1,), '(1,)') |
| 158 |
self.assertGdbRepr(('foo', 'bar', 'baz')) |
| 159 |
|
| 160 |
@support.requires_resource('cpu') |
| 161 |
def test_sets(self): |
| 162 |
'Verify the pretty-printing of sets' |
| 163 |
if GDB_VERSION < (7, 3): |
| 164 |
self.skipTest("pretty-printing of sets needs gdb 7.3 or later") |
| 165 |
self.assertGdbRepr(set(), "set()") |
| 166 |
self.assertGdbRepr(set(['a']), "{'a'}") |
| 167 |
# PYTHONHASHSEED is need to get the exact frozenset item order |
| 168 |
if not sys.flags.ignore_environment: |
| 169 |
self.assertGdbRepr(set(['a', 'b']), "{'a', 'b'}") |
| 170 |
self.assertGdbRepr(set([4, 5, 6]), "{4, 5, 6}") |
| 171 |
|
| 172 |
# Ensure that we handle sets containing the "dummy" key value, |
| 173 |
# which happens on deletion: |
| 174 |
gdb_repr, gdb_output = self.get_gdb_repr('''s = set(['a','b']) |
| 175 |
s.remove('a') |
| 176 |
id(s)''') |
| 177 |
self.assertEqual(gdb_repr, "{'b'}") |
| 178 |
|
| 179 |
@support.requires_resource('cpu') |
| 180 |
def test_frozensets(self): |
| 181 |
'Verify the pretty-printing of frozensets' |
| 182 |
if GDB_VERSION < (7, 3): |
| 183 |
self.skipTest("pretty-printing of frozensets needs gdb 7.3 or later") |
| 184 |
self.assertGdbRepr(frozenset(), "frozenset()") |
| 185 |
self.assertGdbRepr(frozenset(['a']), "frozenset({'a'})") |
| 186 |
# PYTHONHASHSEED is need to get the exact frozenset item order |
| 187 |
if not sys.flags.ignore_environment: |
| 188 |
self.assertGdbRepr(frozenset(['a', 'b']), "frozenset({'a', 'b'})") |
| 189 |
self.assertGdbRepr(frozenset([4, 5, 6]), "frozenset({4, 5, 6})") |
| 190 |
|
| 191 |
def test_exceptions(self): |
| 192 |
# Test a RuntimeError |
| 193 |
gdb_repr, gdb_output = self.get_gdb_repr(''' |
| 194 |
try: |
| 195 |
raise RuntimeError("I am an error") |
| 196 |
except RuntimeError as e: |
| 197 |
id(e) |
| 198 |
''') |
| 199 |
self.assertEqual(gdb_repr, |
| 200 |
"RuntimeError('I am an error',)") |
| 201 |
|
| 202 |
|
| 203 |
# Test division by zero: |
| 204 |
gdb_repr, gdb_output = self.get_gdb_repr(''' |
| 205 |
try: |
| 206 |
a = 1 / 0 |
| 207 |
except ZeroDivisionError as e: |
| 208 |
id(e) |
| 209 |
''') |
| 210 |
self.assertEqual(gdb_repr, |
| 211 |
"ZeroDivisionError('division by zero',)") |
| 212 |
|
| 213 |
def test_modern_class(self): |
| 214 |
'Verify the pretty-printing of new-style class instances' |
| 215 |
gdb_repr, gdb_output = self.get_gdb_repr(''' |
| 216 |
class Foo: |
| 217 |
pass |
| 218 |
foo = Foo() |
| 219 |
foo.an_int = 42 |
| 220 |
id(foo)''') |
| 221 |
m = re.match(r'<Foo\(an_int=42\) at remote 0x-?[0-9a-f]+>', gdb_repr) |
| 222 |
self.assertTrue(m, |
| 223 |
msg='Unexpected new-style class rendering %r' % gdb_repr) |
| 224 |
|
| 225 |
def test_subclassing_list(self): |
| 226 |
'Verify the pretty-printing of an instance of a list subclass' |
| 227 |
gdb_repr, gdb_output = self.get_gdb_repr(''' |
| 228 |
class Foo(list): |
| 229 |
pass |
| 230 |
foo = Foo() |
| 231 |
foo += [1, 2, 3] |
| 232 |
foo.an_int = 42 |
| 233 |
id(foo)''') |
| 234 |
m = re.match(r'<Foo\(an_int=42\) at remote 0x-?[0-9a-f]+>', gdb_repr) |
| 235 |
|
| 236 |
self.assertTrue(m, |
| 237 |
msg='Unexpected new-style class rendering %r' % gdb_repr) |
| 238 |
|
| 239 |
def test_subclassing_tuple(self): |
| 240 |
'Verify the pretty-printing of an instance of a tuple subclass' |
| 241 |
# This should exercise the negative tp_dictoffset code in the |
| 242 |
# new-style class support |
| 243 |
gdb_repr, gdb_output = self.get_gdb_repr(''' |
| 244 |
class Foo(tuple): |
| 245 |
pass |
| 246 |
foo = Foo((1, 2, 3)) |
| 247 |
foo.an_int = 42 |
| 248 |
id(foo)''') |
| 249 |
m = re.match(r'<Foo\(an_int=42\) at remote 0x-?[0-9a-f]+>', gdb_repr) |
| 250 |
|
| 251 |
self.assertTrue(m, |
| 252 |
msg='Unexpected new-style class rendering %r' % gdb_repr) |
| 253 |
|
| 254 |
def assertSane(self, source, corruption, exprepr=None): |
| 255 |
'''Run Python under gdb, corrupting variables in the inferior process |
| 256 |
immediately before taking a backtrace. |
| 257 |
|
| 258 |
Verify that the variable's representation is the expected failsafe |
| 259 |
representation''' |
| 260 |
if corruption: |
| 261 |
cmds_after_breakpoint=[corruption, 'backtrace'] |
| 262 |
else: |
| 263 |
cmds_after_breakpoint=['backtrace'] |
| 264 |
|
| 265 |
gdb_repr, gdb_output = \ |
| 266 |
self.get_gdb_repr(source, |
| 267 |
cmds_after_breakpoint=cmds_after_breakpoint) |
| 268 |
if exprepr: |
| 269 |
if gdb_repr == exprepr: |
| 270 |
# gdb managed to print the value in spite of the corruption; |
| 271 |
# this is good (see http://bugs.python.org/issue8330) |
| 272 |
return |
| 273 |
|
| 274 |
# Match anything for the type name; 0xDEADBEEF could point to |
| 275 |
# something arbitrary (see http://bugs.python.org/issue8330) |
| 276 |
pattern = '<.* at remote 0x-?[0-9a-f]+>' |
| 277 |
|
| 278 |
m = re.match(pattern, gdb_repr) |
| 279 |
if not m: |
| 280 |
self.fail('Unexpected gdb representation: %r\n%s' % \ |
| 281 |
(gdb_repr, gdb_output)) |
| 282 |
|
| 283 |
def test_NULL_ptr(self): |
| 284 |
'Ensure that a NULL PyObject* is handled gracefully' |
| 285 |
gdb_repr, gdb_output = ( |
| 286 |
self.get_gdb_repr('id(42)', |
| 287 |
cmds_after_breakpoint=['set variable v=0', |
| 288 |
'backtrace']) |
| 289 |
) |
| 290 |
|
| 291 |
self.assertEqual(gdb_repr, '0x0') |
| 292 |
|
| 293 |
def test_NULL_ob_type(self): |
| 294 |
'Ensure that a PyObject* with NULL ob_type is handled gracefully' |
| 295 |
self.assertSane('id(42)', |
| 296 |
'set v->ob_type=0') |
| 297 |
|
| 298 |
def test_corrupt_ob_type(self): |
| 299 |
'Ensure that a PyObject* with a corrupt ob_type is handled gracefully' |
| 300 |
self.assertSane('id(42)', |
| 301 |
'set v->ob_type=0xDEADBEEF', |
| 302 |
exprepr='42') |
| 303 |
|
| 304 |
def test_corrupt_tp_flags(self): |
| 305 |
'Ensure that a PyObject* with a type with corrupt tp_flags is handled' |
| 306 |
self.assertSane('id(42)', |
| 307 |
'set v->ob_type->tp_flags=0x0', |
| 308 |
exprepr='42') |
| 309 |
|
| 310 |
def test_corrupt_tp_name(self): |
| 311 |
'Ensure that a PyObject* with a type with corrupt tp_name is handled' |
| 312 |
self.assertSane('id(42)', |
| 313 |
'set v->ob_type->tp_name=0xDEADBEEF', |
| 314 |
exprepr='42') |
| 315 |
|
| 316 |
def test_builtins_help(self): |
| 317 |
'Ensure that the new-style class _Helper in site.py can be handled' |
| 318 |
|
| 319 |
if sys.flags.no_site: |
| 320 |
self.skipTest("need site module, but -S option was used") |
| 321 |
|
| 322 |
# (this was the issue causing tracebacks in |
| 323 |
# http://bugs.python.org/issue8032#msg100537 ) |
| 324 |
gdb_repr, gdb_output = self.get_gdb_repr('id(__builtins__.help)', import_site=True) |
| 325 |
|
| 326 |
m = re.match(r'<_Helper\(\) at remote 0x-?[0-9a-f]+>', gdb_repr) |
| 327 |
self.assertTrue(m, |
| 328 |
msg='Unexpected rendering %r' % gdb_repr) |
| 329 |
|
| 330 |
def test_selfreferential_list(self): |
| 331 |
'''Ensure that a reference loop involving a list doesn't lead proxyval |
| 332 |
into an infinite loop:''' |
| 333 |
gdb_repr, gdb_output = \ |
| 334 |
self.get_gdb_repr("a = [3, 4, 5] ; a.append(a) ; id(a)") |
| 335 |
self.assertEqual(gdb_repr, '[3, 4, 5, [...]]') |
| 336 |
|
| 337 |
gdb_repr, gdb_output = \ |
| 338 |
self.get_gdb_repr("a = [3, 4, 5] ; b = [a] ; a.append(b) ; id(a)") |
| 339 |
self.assertEqual(gdb_repr, '[3, 4, 5, [[...]]]') |
| 340 |
|
| 341 |
def test_selfreferential_dict(self): |
| 342 |
'''Ensure that a reference loop involving a dict doesn't lead proxyval |
| 343 |
into an infinite loop:''' |
| 344 |
gdb_repr, gdb_output = \ |
| 345 |
self.get_gdb_repr("a = {} ; b = {'bar':a} ; a['foo'] = b ; id(a)") |
| 346 |
|
| 347 |
self.assertEqual(gdb_repr, "{'foo': {'bar': {...}}}") |
| 348 |
|
| 349 |
def test_selfreferential_old_style_instance(self): |
| 350 |
gdb_repr, gdb_output = \ |
| 351 |
self.get_gdb_repr(''' |
| 352 |
class Foo: |
| 353 |
pass |
| 354 |
foo = Foo() |
| 355 |
foo.an_attr = foo |
| 356 |
id(foo)''') |
| 357 |
self.assertTrue(re.match(r'<Foo\(an_attr=<\.\.\.>\) at remote 0x-?[0-9a-f]+>', |
| 358 |
gdb_repr), |
| 359 |
'Unexpected gdb representation: %r\n%s' % \ |
| 360 |
(gdb_repr, gdb_output)) |
| 361 |
|
| 362 |
def test_selfreferential_new_style_instance(self): |
| 363 |
gdb_repr, gdb_output = \ |
| 364 |
self.get_gdb_repr(''' |
| 365 |
class Foo(object): |
| 366 |
pass |
| 367 |
foo = Foo() |
| 368 |
foo.an_attr = foo |
| 369 |
id(foo)''') |
| 370 |
self.assertTrue(re.match(r'<Foo\(an_attr=<\.\.\.>\) at remote 0x-?[0-9a-f]+>', |
| 371 |
gdb_repr), |
| 372 |
'Unexpected gdb representation: %r\n%s' % \ |
| 373 |
(gdb_repr, gdb_output)) |
| 374 |
|
| 375 |
gdb_repr, gdb_output = \ |
| 376 |
self.get_gdb_repr(''' |
| 377 |
class Foo(object): |
| 378 |
pass |
| 379 |
a = Foo() |
| 380 |
b = Foo() |
| 381 |
a.an_attr = b |
| 382 |
b.an_attr = a |
| 383 |
id(a)''') |
| 384 |
self.assertTrue(re.match(r'<Foo\(an_attr=<Foo\(an_attr=<\.\.\.>\) at remote 0x-?[0-9a-f]+>\) at remote 0x-?[0-9a-f]+>', |
| 385 |
gdb_repr), |
| 386 |
'Unexpected gdb representation: %r\n%s' % \ |
| 387 |
(gdb_repr, gdb_output)) |
| 388 |
|
| 389 |
def test_truncation(self): |
| 390 |
'Verify that very long output is truncated' |
| 391 |
gdb_repr, gdb_output = self.get_gdb_repr('id(list(range(1000)))') |
| 392 |
self.assertEqual(gdb_repr, |
| 393 |
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, " |
| 394 |
"14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, " |
| 395 |
"27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, " |
| 396 |
"40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, " |
| 397 |
"53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, " |
| 398 |
"66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, " |
| 399 |
"79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, " |
| 400 |
"92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, " |
| 401 |
"104, 105, 106, 107, 108, 109, 110, 111, 112, 113, " |
| 402 |
"114, 115, 116, 117, 118, 119, 120, 121, 122, 123, " |
| 403 |
"124, 125, 126, 127, 128, 129, 130, 131, 132, 133, " |
| 404 |
"134, 135, 136, 137, 138, 139, 140, 141, 142, 143, " |
| 405 |
"144, 145, 146, 147, 148, 149, 150, 151, 152, 153, " |
| 406 |
"154, 155, 156, 157, 158, 159, 160, 161, 162, 163, " |
| 407 |
"164, 165, 166, 167, 168, 169, 170, 171, 172, 173, " |
| 408 |
"174, 175, 176, 177, 178, 179, 180, 181, 182, 183, " |
| 409 |
"184, 185, 186, 187, 188, 189, 190, 191, 192, 193, " |
| 410 |
"194, 195, 196, 197, 198, 199, 200, 201, 202, 203, " |
| 411 |
"204, 205, 206, 207, 208, 209, 210, 211, 212, 213, " |
| 412 |
"214, 215, 216, 217, 218, 219, 220, 221, 222, 223, " |
| 413 |
"224, 225, 226...(truncated)") |
| 414 |
self.assertEqual(len(gdb_repr), |
| 415 |
1024 + len('...(truncated)')) |
| 416 |
|
| 417 |
def test_builtin_method(self): |
| 418 |
gdb_repr, gdb_output = self.get_gdb_repr('import sys; id(sys.stdout.readlines)') |
| 419 |
self.assertTrue(re.match(r'<built-in method readlines of _io.TextIOWrapper object at remote 0x-?[0-9a-f]+>', |
| 420 |
gdb_repr), |
| 421 |
'Unexpected gdb representation: %r\n%s' % \ |
| 422 |
(gdb_repr, gdb_output)) |
| 423 |
|
| 424 |
def test_frames(self): |
| 425 |
gdb_output = self.get_stack_trace(''' |
| 426 |
import sys |
| 427 |
def foo(a, b, c): |
| 428 |
return sys._getframe(0) |
| 429 |
|
| 430 |
f = foo(3, 4, 5) |
| 431 |
id(f)''', |
| 432 |
breakpoint='builtin_id', |
| 433 |
cmds_after_breakpoint=['print (PyFrameObject*)v'] |
| 434 |
) |
| 435 |
self.assertTrue(re.match(r'.*\s+\$1 =\s+Frame 0x-?[0-9a-f]+, for file <string>, line 4, in foo \(a=3.*', |
| 436 |
gdb_output, |
| 437 |
re.DOTALL), |
| 438 |
'Unexpected gdb representation: %r\n%s' % (gdb_output, gdb_output)) |