diff options
Diffstat (limited to 'Lib/test/test_gdb.py')
| -rw-r--r-- | Lib/test/test_gdb.py | 305 |
1 files changed, 146 insertions, 159 deletions
diff --git a/Lib/test/test_gdb.py b/Lib/test/test_gdb.py index 9d8ff8ed8a1..6d96550a9bc 100644 --- a/Lib/test/test_gdb.py +++ b/Lib/test/test_gdb.py @@ -8,9 +8,9 @@ import re import subprocess import sys import unittest -import sysconfig +import locale -from test.test_support import run_unittest, findfile +from test.support import run_unittest, findfile, python_is_optimized try: gdb_version, _ = subprocess.Popen(["gdb", "--version"], @@ -19,12 +19,12 @@ except OSError: # This is what "no gdb" looks like. There may, however, be other # errors that manifest this way too. raise unittest.SkipTest("Couldn't find gdb on the path") -gdb_version_number = re.search("^GNU gdb [^\d]*(\d+)\.(\d)", gdb_version) +gdb_version_number = re.search(b"^GNU gdb [^\d]*(\d+)\.(\d)", gdb_version) gdb_major_version = int(gdb_version_number.group(1)) gdb_minor_version = int(gdb_version_number.group(2)) if gdb_major_version < 7: raise unittest.SkipTest("gdb versions before 7.0 didn't support python embedding" - " Saw:\n" + gdb_version) + " Saw:\n" + gdb_version.decode('ascii', 'replace')) # Location of custom hooks file in a repository checkout. checkout_hook_path = os.path.join(os.path.dirname(sys.executable), @@ -33,7 +33,7 @@ checkout_hook_path = os.path.join(os.path.dirname(sys.executable), def run_gdb(*args, **env_vars): """Runs gdb in --batch mode with the additional arguments given by *args. - Returns its (stdout, stderr) + Returns its (stdout, stderr) decoded from utf-8 using the replace handler. """ if env_vars: env = os.environ.copy() @@ -46,7 +46,7 @@ def run_gdb(*args, **env_vars): out, err = subprocess.Popen(base_cmd + args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, ).communicate() - return out, err + return out.decode('utf-8', 'replace'), err.decode('utf-8', 'replace') # Verify that "gdb" was built with the embedded python support enabled: gdbpy_version, _ = run_gdb("--eval-command=python import sys; print sys.version_info") @@ -60,14 +60,7 @@ cmd = ['--args', sys.executable] _, gdbpy_errors = run_gdb('--args', sys.executable) if "auto-loading has been declined" in gdbpy_errors: msg = "gdb security settings prevent use of custom hooks: " - -def python_is_optimized(): - cflags = sysconfig.get_config_vars()['PY_CFLAGS'] - final_opt = "" - for opt in cflags.split(): - if opt.startswith('-O'): - final_opt = opt - return (final_opt and final_opt != '-O0') + raise unittest.SkipTest(msg + gdbpy_errors.rstrip()) def gdb_has_frame_select(): # Does this build of gdb have gdb.Frame.select ? @@ -80,12 +73,14 @@ def gdb_has_frame_select(): HAS_PYUP_PYDOWN = gdb_has_frame_select() +BREAKPOINT_FN='builtin_id' + class DebuggerTests(unittest.TestCase): """Test that the debugger can debug Python.""" def get_stack_trace(self, source=None, script=None, - breakpoint='PyObject_Print', + breakpoint=BREAKPOINT_FN, cmds_after_breakpoint=None, import_site=False): ''' @@ -103,7 +98,7 @@ class DebuggerTests(unittest.TestCase): # error, which typically happens python is dynamically linked (the # breakpoints of interest are to be found in the shared library) # When this happens, we still get: - # Function "PyObject_Print" not defined. + # Function "textiowrapper_write" not defined. # emitted to stderr each time, alas. # Initially I had "--eval-command=continue" here, but removed it to @@ -172,19 +167,21 @@ class DebuggerTests(unittest.TestCase): cmds_after_breakpoint=None, import_site=False): # Given an input python source representation of data, - # run "python -c'print DATA'" under gdb with a breakpoint on - # PyObject_Print and scrape out gdb's representation of the "op" + # run "python -c'id(DATA)'" under gdb with a breakpoint on + # builtin_id and scrape out gdb's representation of the "op" # parameter, and verify that the gdb displays the same string # + # Verify that the gdb displays the expected string + # # For a nested structure, the first time we hit the breakpoint will # give us the top-level structure - gdb_output = self.get_stack_trace(source, breakpoint='PyObject_Print', + gdb_output = self.get_stack_trace(source, breakpoint=BREAKPOINT_FN, cmds_after_breakpoint=cmds_after_breakpoint, import_site=import_site) # gdb can insert additional '\n' and space characters in various places # in its output, depending on the width of the terminal it's connected # to (using its "wrap_here" function) - m = re.match('.*#0\s+PyObject_Print\s+\(\s*op\=\s*(.*?),\s+fp=.*\).*', + m = re.match('.*#0\s+builtin_id\s+\(self\=.*,\s+v=\s*(.*?)\)\s+at\s+Python/bltinmodule.c.*', gdb_output, re.DOTALL) if not m: self.fail('Unexpected gdb output: %r\n%s' % (gdb_output, gdb_output)) @@ -197,37 +194,35 @@ class DebuggerTests(unittest.TestCase): def assertMultilineMatches(self, actual, pattern): m = re.match(pattern, actual, re.DOTALL) - self.assertTrue(m, msg='%r did not match %r' % (actual, pattern)) + if not m: + self.fail(msg='%r did not match %r' % (actual, pattern)) def get_sample_script(self): return findfile('gdb_sample.py') class PrettyPrintTests(DebuggerTests): def test_getting_backtrace(self): - gdb_output = self.get_stack_trace('print 42') - self.assertTrue('PyObject_Print' in gdb_output) + gdb_output = self.get_stack_trace('id(42)') + self.assertTrue(BREAKPOINT_FN in gdb_output) - def assertGdbRepr(self, val, cmds_after_breakpoint=None): + def assertGdbRepr(self, val, exp_repr=None, cmds_after_breakpoint=None): # Ensure that gdb's rendering of the value in a debugged process # matches repr(value) in this process: - gdb_repr, gdb_output = self.get_gdb_repr('print ' + repr(val), + gdb_repr, gdb_output = self.get_gdb_repr('id(' + ascii(val) + ')', cmds_after_breakpoint) - self.assertEqual(gdb_repr, repr(val), gdb_output) + if not exp_repr: + exp_repr = repr(val) + self.assertEqual(gdb_repr, exp_repr, + ('%r did not equal expected %r; full output was:\n%s' + % (gdb_repr, exp_repr, gdb_output))) def test_int(self): - 'Verify the pretty-printing of various "int" values' + 'Verify the pretty-printing of various "int"/long values' self.assertGdbRepr(42) self.assertGdbRepr(0) self.assertGdbRepr(-7) - self.assertGdbRepr(sys.maxint) - self.assertGdbRepr(-sys.maxint) - - def test_long(self): - 'Verify the pretty-printing of various "long" values' - self.assertGdbRepr(0L) - self.assertGdbRepr(1000000000000L) - self.assertGdbRepr(-1L) - self.assertGdbRepr(-1000000000000000L) + self.assertGdbRepr(1000000000000) + self.assertGdbRepr(-1000000000000000) def test_singletons(self): 'Verify the pretty-printing of True, False and None' @@ -239,123 +234,115 @@ class PrettyPrintTests(DebuggerTests): 'Verify the pretty-printing of dictionaries' self.assertGdbRepr({}) self.assertGdbRepr({'foo': 'bar'}) - self.assertGdbRepr("{'foo': 'bar', 'douglas':42}") + self.assertGdbRepr({'foo': 'bar', 'douglas': 42}, + "{'foo': 'bar', 'douglas': 42}") def test_lists(self): 'Verify the pretty-printing of lists' self.assertGdbRepr([]) - self.assertGdbRepr(range(5)) + self.assertGdbRepr(list(range(5))) + + def test_bytes(self): + 'Verify the pretty-printing of bytes' + self.assertGdbRepr(b'') + self.assertGdbRepr(b'And now for something hopefully the same') + self.assertGdbRepr(b'string with embedded NUL here \0 and then some more text') + self.assertGdbRepr(b'this is a tab:\t' + b' this is a slash-N:\n' + b' this is a slash-R:\r' + ) + + self.assertGdbRepr(b'this is byte 255:\xff and byte 128:\x80') + + self.assertGdbRepr(bytes([b for b in range(255)])) def test_strings(self): - 'Verify the pretty-printing of strings' + 'Verify the pretty-printing of unicode strings' + encoding = locale.getpreferredencoding() + def check_repr(text): + try: + text.encode(encoding) + printable = True + except UnicodeEncodeError: + self.assertGdbRepr(text, ascii(text)) + else: + self.assertGdbRepr(text) + self.assertGdbRepr('') self.assertGdbRepr('And now for something hopefully the same') self.assertGdbRepr('string with embedded NUL here \0 and then some more text') - self.assertGdbRepr('this is byte 255:\xff and byte 128:\x80') - - def test_tuples(self): - 'Verify the pretty-printing of tuples' - self.assertGdbRepr(tuple()) - self.assertGdbRepr((1,)) - self.assertGdbRepr(('foo', 'bar', 'baz')) - - def test_unicode(self): - 'Verify the pretty-printing of unicode values' - # Test the empty unicode string: - self.assertGdbRepr(u'') - - self.assertGdbRepr(u'hello world') # Test printing a single character: # U+2620 SKULL AND CROSSBONES - self.assertGdbRepr(u'\u2620') + check_repr('\u2620') # Test printing a Japanese unicode string # (I believe this reads "mojibake", using 3 characters from the CJK # Unified Ideographs area, followed by U+3051 HIRAGANA LETTER KE) - self.assertGdbRepr(u'\u6587\u5b57\u5316\u3051') + check_repr('\u6587\u5b57\u5316\u3051') # Test a character outside the BMP: # U+1D121 MUSICAL SYMBOL C CLEF # This is: # UTF-8: 0xF0 0x9D 0x84 0xA1 # UTF-16: 0xD834 0xDD21 - # This will only work on wide-unicode builds: - self.assertGdbRepr(u"\U0001D121") + check_repr(chr(0x1D121)) + + def test_tuples(self): + 'Verify the pretty-printing of tuples' + self.assertGdbRepr(tuple()) + self.assertGdbRepr((1,), '(1,)') + self.assertGdbRepr(('foo', 'bar', 'baz')) def test_sets(self): 'Verify the pretty-printing of sets' self.assertGdbRepr(set()) - rep = self.get_gdb_repr("print set(['a', 'b'])")[0] - self.assertTrue(rep.startswith("set([")) - self.assertTrue(rep.endswith("])")) - self.assertEqual(eval(rep), {'a', 'b'}) - rep = self.get_gdb_repr("print set([4, 5])")[0] - self.assertTrue(rep.startswith("set([")) - self.assertTrue(rep.endswith("])")) - self.assertEqual(eval(rep), {4, 5}) - - # Ensure that we handled sets containing the "dummy" key value, + self.assertGdbRepr(set(['a', 'b']), "{'a', 'b'}") + self.assertGdbRepr(set([4, 5, 6]), "{4, 5, 6}") + + # Ensure that we handle sets containing the "dummy" key value, # which happens on deletion: gdb_repr, gdb_output = self.get_gdb_repr('''s = set(['a','b']) s.pop() -print s''') - self.assertEqual(gdb_repr, "set(['b'])") +id(s)''') + self.assertEqual(gdb_repr, "{'b'}") def test_frozensets(self): 'Verify the pretty-printing of frozensets' self.assertGdbRepr(frozenset()) - rep = self.get_gdb_repr("print frozenset(['a', 'b'])")[0] - self.assertTrue(rep.startswith("frozenset([")) - self.assertTrue(rep.endswith("])")) - self.assertEqual(eval(rep), {'a', 'b'}) - rep = self.get_gdb_repr("print frozenset([4, 5])")[0] - self.assertTrue(rep.startswith("frozenset([")) - self.assertTrue(rep.endswith("])")) - self.assertEqual(eval(rep), {4, 5}) + self.assertGdbRepr(frozenset(['a', 'b']), "frozenset({'a', 'b'})") + self.assertGdbRepr(frozenset([4, 5, 6]), "frozenset({4, 5, 6})") def test_exceptions(self): # Test a RuntimeError gdb_repr, gdb_output = self.get_gdb_repr(''' try: raise RuntimeError("I am an error") -except RuntimeError, e: - print e +except RuntimeError as e: + id(e) ''') self.assertEqual(gdb_repr, - "exceptions.RuntimeError('I am an error',)") + "RuntimeError('I am an error',)") # Test division by zero: gdb_repr, gdb_output = self.get_gdb_repr(''' try: a = 1 / 0 -except ZeroDivisionError, e: - print e +except ZeroDivisionError as e: + id(e) ''') self.assertEqual(gdb_repr, - "exceptions.ZeroDivisionError('integer division or modulo by zero',)") - - def test_classic_class(self): - 'Verify the pretty-printing of classic class instances' - gdb_repr, gdb_output = self.get_gdb_repr(''' -class Foo: - pass -foo = Foo() -foo.an_int = 42 -print foo''') - m = re.match(r'<Foo\(an_int=42\) at remote 0x[0-9a-f]+>', gdb_repr) - self.assertTrue(m, - msg='Unexpected classic-class rendering %r' % gdb_repr) + "ZeroDivisionError('division by zero',)") def test_modern_class(self): 'Verify the pretty-printing of new-style class instances' gdb_repr, gdb_output = self.get_gdb_repr(''' -class Foo(object): +class Foo: pass foo = Foo() foo.an_int = 42 -print foo''') +id(foo)''') m = re.match(r'<Foo\(an_int=42\) at remote 0x[0-9a-f]+>', gdb_repr) self.assertTrue(m, msg='Unexpected new-style class rendering %r' % gdb_repr) @@ -368,8 +355,9 @@ class Foo(list): foo = Foo() foo += [1, 2, 3] foo.an_int = 42 -print foo''') +id(foo)''') m = re.match(r'<Foo\(an_int=42\) at remote 0x[0-9a-f]+>', gdb_repr) + self.assertTrue(m, msg='Unexpected new-style class rendering %r' % gdb_repr) @@ -382,12 +370,13 @@ class Foo(tuple): pass foo = Foo((1, 2, 3)) foo.an_int = 42 -print foo''') +id(foo)''') m = re.match(r'<Foo\(an_int=42\) at remote 0x[0-9a-f]+>', gdb_repr) + self.assertTrue(m, msg='Unexpected new-style class rendering %r' % gdb_repr) - def assertSane(self, source, corruption, expvalue=None, exptype=None): + def assertSane(self, source, corruption, exprepr=None): '''Run Python under gdb, corrupting variables in the inferior process immediately before taking a backtrace. @@ -401,19 +390,15 @@ print foo''') gdb_repr, gdb_output = \ self.get_gdb_repr(source, cmds_after_breakpoint=cmds_after_breakpoint) - - if expvalue: - if gdb_repr == repr(expvalue): + if exprepr: + if gdb_repr == exprepr: # gdb managed to print the value in spite of the corruption; # this is good (see http://bugs.python.org/issue8330) return - if exptype: - pattern = '<' + exptype + ' at remote 0x[0-9a-f]+>' - else: - # Match anything for the type name; 0xDEADBEEF could point to - # something arbitrary (see http://bugs.python.org/issue8330) - pattern = '<.* at remote 0x[0-9a-f]+>' + # Match anything for the type name; 0xDEADBEEF could point to + # something arbitrary (see http://bugs.python.org/issue8330) + pattern = '<.* at remote 0x[0-9a-f]+>' m = re.match(pattern, gdb_repr) if not m: @@ -423,8 +408,8 @@ print foo''') def test_NULL_ptr(self): 'Ensure that a NULL PyObject* is handled gracefully' gdb_repr, gdb_output = ( - self.get_gdb_repr('print 42', - cmds_after_breakpoint=['set variable op=0', + self.get_gdb_repr('id(42)', + cmds_after_breakpoint=['set variable v=0', 'backtrace']) ) @@ -432,44 +417,33 @@ print foo''') def test_NULL_ob_type(self): 'Ensure that a PyObject* with NULL ob_type is handled gracefully' - self.assertSane('print 42', - 'set op->ob_type=0') + self.assertSane('id(42)', + 'set v->ob_type=0') def test_corrupt_ob_type(self): 'Ensure that a PyObject* with a corrupt ob_type is handled gracefully' - self.assertSane('print 42', - 'set op->ob_type=0xDEADBEEF', - expvalue=42) + self.assertSane('id(42)', + 'set v->ob_type=0xDEADBEEF', + exprepr='42') def test_corrupt_tp_flags(self): 'Ensure that a PyObject* with a type with corrupt tp_flags is handled' - self.assertSane('print 42', - 'set op->ob_type->tp_flags=0x0', - expvalue=42) + self.assertSane('id(42)', + 'set v->ob_type->tp_flags=0x0', + exprepr='42') def test_corrupt_tp_name(self): 'Ensure that a PyObject* with a type with corrupt tp_name is handled' - self.assertSane('print 42', - 'set op->ob_type->tp_name=0xDEADBEEF', - expvalue=42) - - def test_NULL_instance_dict(self): - 'Ensure that a PyInstanceObject with with a NULL in_dict is handled' - self.assertSane(''' -class Foo: - pass -foo = Foo() -foo.an_int = 42 -print foo''', - 'set ((PyInstanceObject*)op)->in_dict = 0', - exptype='Foo') + self.assertSane('id(42)', + 'set v->ob_type->tp_name=0xDEADBEEF', + exprepr='42') def test_builtins_help(self): 'Ensure that the new-style class _Helper in site.py can be handled' # (this was the issue causing tracebacks in # http://bugs.python.org/issue8032#msg100537 ) + gdb_repr, gdb_output = self.get_gdb_repr('id(__builtins__.help)', import_site=True) - gdb_repr, gdb_output = self.get_gdb_repr('print __builtins__.help', import_site=True) m = re.match(r'<_Helper at remote 0x[0-9a-f]+>', gdb_repr) self.assertTrue(m, msg='Unexpected rendering %r' % gdb_repr) @@ -478,20 +452,18 @@ print foo''', '''Ensure that a reference loop involving a list doesn't lead proxyval into an infinite loop:''' gdb_repr, gdb_output = \ - self.get_gdb_repr("a = [3, 4, 5] ; a.append(a) ; print a") - + self.get_gdb_repr("a = [3, 4, 5] ; a.append(a) ; id(a)") self.assertEqual(gdb_repr, '[3, 4, 5, [...]]') gdb_repr, gdb_output = \ - self.get_gdb_repr("a = [3, 4, 5] ; b = [a] ; a.append(b) ; print a") - + self.get_gdb_repr("a = [3, 4, 5] ; b = [a] ; a.append(b) ; id(a)") self.assertEqual(gdb_repr, '[3, 4, 5, [[...]]]') def test_selfreferential_dict(self): '''Ensure that a reference loop involving a dict doesn't lead proxyval into an infinite loop:''' gdb_repr, gdb_output = \ - self.get_gdb_repr("a = {} ; b = {'bar':a} ; a['foo'] = b ; print a") + self.get_gdb_repr("a = {} ; b = {'bar':a} ; a['foo'] = b ; id(a)") self.assertEqual(gdb_repr, "{'foo': {'bar': {...}}}") @@ -502,7 +474,7 @@ class Foo: pass foo = Foo() foo.an_attr = foo -print foo''') +id(foo)''') self.assertTrue(re.match('<Foo\(an_attr=<\.\.\.>\) at remote 0x[0-9a-f]+>', gdb_repr), 'Unexpected gdb representation: %r\n%s' % \ @@ -515,7 +487,7 @@ class Foo(object): pass foo = Foo() foo.an_attr = foo -print foo''') +id(foo)''') self.assertTrue(re.match('<Foo\(an_attr=<\.\.\.>\) at remote 0x[0-9a-f]+>', gdb_repr), 'Unexpected gdb representation: %r\n%s' % \ @@ -529,7 +501,7 @@ a = Foo() b = Foo() a.an_attr = b b.an_attr = a -print a''') +id(a)''') self.assertTrue(re.match('<Foo\(an_attr=<Foo\(an_attr=<\.\.\.>\) at remote 0x[0-9a-f]+>\) at remote 0x[0-9a-f]+>', gdb_repr), 'Unexpected gdb representation: %r\n%s' % \ @@ -537,7 +509,7 @@ print a''') def test_truncation(self): 'Verify that very long output is truncated' - gdb_repr, gdb_output = self.get_gdb_repr('print range(1000)') + gdb_repr, gdb_output = self.get_gdb_repr('id(list(range(1000)))') self.assertEqual(gdb_repr, "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, " "14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, " @@ -563,13 +535,9 @@ print a''') self.assertEqual(len(gdb_repr), 1024 + len('...(truncated)')) - def test_builtin_function(self): - gdb_repr, gdb_output = self.get_gdb_repr('print len') - self.assertEqual(gdb_repr, '<built-in function len>') - def test_builtin_method(self): - gdb_repr, gdb_output = self.get_gdb_repr('import sys; print sys.stdout.readlines') - self.assertTrue(re.match('<built-in method readlines of file object at remote 0x[0-9a-f]+>', + gdb_repr, gdb_output = self.get_gdb_repr('import sys; id(sys.stdout.readlines)') + self.assertTrue(re.match('<built-in method readlines of _io.TextIOWrapper object at remote 0x[0-9a-f]+>', gdb_repr), 'Unexpected gdb representation: %r\n%s' % \ (gdb_repr, gdb_output)) @@ -580,11 +548,11 @@ def foo(a, b, c): pass foo(3, 4, 5) -print foo.__code__''', - breakpoint='PyObject_Print', - cmds_after_breakpoint=['print (PyFrameObject*)(((PyCodeObject*)op)->co_zombieframe)'] +id(foo.__code__)''', + breakpoint='builtin_id', + cmds_after_breakpoint=['print (PyFrameObject*)(((PyCodeObject*)v)->co_zombieframe)'] ) - self.assertTrue(re.match(r'.*\s+\$1 =\s+Frame 0x[0-9a-f]+, for file <string>, line 3, in foo \(\)\s+.*', + self.assertTrue(re.match('.*\s+\$1 =\s+Frame 0x[0-9a-f]+, for file <string>, line 3, in foo \(\)\s+.*', gdb_output, re.DOTALL), 'Unexpected gdb representation: %r\n%s' % (gdb_output, gdb_output)) @@ -605,7 +573,7 @@ class PyListTests(DebuggerTests): ' 7 baz(a, b, c)\n' ' 8 \n' ' 9 def baz(*args):\n' - ' >10 print(42)\n' + ' >10 id(42)\n' ' 11 \n' ' 12 foo(1, 2, 3)\n', bt) @@ -616,7 +584,7 @@ class PyListTests(DebuggerTests): cmds_after_breakpoint=['py-list 9']) self.assertListing(' 9 def baz(*args):\n' - ' >10 print(42)\n' + ' >10 id(42)\n' ' 11 \n' ' 12 foo(1, 2, 3)\n', bt) @@ -673,18 +641,37 @@ $''') #[0-9]+ Frame 0x[0-9a-f]+, for file .*gdb_sample.py, line 7, in bar \(a=1, b=2, c=3\) baz\(a, b, c\) #[0-9]+ Frame 0x[0-9a-f]+, for file .*gdb_sample.py, line 10, in baz \(args=\(1, 2, 3\)\) - print\(42\) + id\(42\) $''') class PyBtTests(DebuggerTests): @unittest.skipIf(python_is_optimized(), "Python was compiled with optimizations") - def test_basic_command(self): + def test_bt(self): 'Verify that the "py-bt" command works' bt = self.get_stack_trace(script=self.get_sample_script(), cmds_after_breakpoint=['py-bt']) self.assertMultilineMatches(bt, r'''^.* +Traceback \(most recent call first\): + File ".*gdb_sample.py", line 10, in baz + id\(42\) + File ".*gdb_sample.py", line 7, in bar + baz\(a, b, c\) + File ".*gdb_sample.py", line 4, in foo + bar\(a, b, c\) + File ".*gdb_sample.py", line 12, in <module> + foo\(1, 2, 3\) +''') + + @unittest.skipIf(python_is_optimized(), + "Python was compiled with optimizations") + def test_bt_full(self): + 'Verify that the "py-bt-full" command works' + bt = self.get_stack_trace(script=self.get_sample_script(), + cmds_after_breakpoint=['py-bt-full']) + self.assertMultilineMatches(bt, + r'''^.* #[0-9]+ Frame 0x[0-9a-f]+, for file .*gdb_sample.py, line 7, in bar \(a=1, b=2, c=3\) baz\(a, b, c\) #[0-9]+ Frame 0x[0-9a-f]+, for file .*gdb_sample.py, line 4, in foo \(a=1, b=2, c=3\) @@ -703,9 +690,9 @@ class PyPrintTests(DebuggerTests): self.assertMultilineMatches(bt, r".*\nlocal 'args' = \(1, 2, 3\)\n.*") - @unittest.skipUnless(HAS_PYUP_PYDOWN, "test requires py-up/py-down commands") @unittest.skipIf(python_is_optimized(), "Python was compiled with optimizations") + @unittest.skipUnless(HAS_PYUP_PYDOWN, "test requires py-up/py-down commands") def test_print_after_up(self): bt = self.get_stack_trace(script=self.get_sample_script(), cmds_after_breakpoint=['py-up', 'py-print c', 'py-print b', 'py-print a']) @@ -726,7 +713,7 @@ class PyPrintTests(DebuggerTests): bt = self.get_stack_trace(script=self.get_sample_script(), cmds_after_breakpoint=['py-print len']) self.assertMultilineMatches(bt, - r".*\nbuiltin 'len' = <built-in function len>\n.*") + r".*\nbuiltin 'len' = <built-in method len of module object at remote 0x[0-9a-f]+>\n.*") class PyLocalsTests(DebuggerTests): @unittest.skipIf(python_is_optimized(), |