0hh*SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK J r J r SSKJr SSKJr SSKJrJr SSKJr SSKJrJr SSKJr \R8(+r"S S \5rS r S r!S r"Sr#Sr$Sr%Sr&Sr'Sr(Sr)Sr*Sr+Sr,Sr-Sr.Sr/\R`Rb(dSr2Sr3Sr4Sr5Sr6S r7S!r8S"r9S#r:S$r;S%r\R~"S(5r@\A"S)\@R5 S*rCS+rDS,rES-rFS.rGS/rHS0rI\(dS1rJS2rKS3rL\(dS4rMS5rN\(dS6rOS7rPS8rQS9rRS:rSS;rTS<rUS=rVS>rWS?rXS@rYSArZSBr[SCr\SDr]SEr^SFr_SGr`SHraSIrbSJrc\R"5"SKSL\R55rf"SMSN\R5rg\R"5"SOSP\R55rhSQri\jSR:Xa\R"5 gg)SN) ExitStackredirect_stdout)StringIO)support)force_not_colorized os_helper) import_module)run_pty FakeInput)patchc*\rSrSrSrSrSrSrSrg) PdbTestInputz:Context manager that makes testing Pdb in doctests easier.cXlgN)input)selfrs 6/opt/python-3.13.8/usr/lib/python3.13/test/test_pdb.py__init__PdbTestInput.__init__s c[RUl[UR5[l[ [S5(a "5UlgSUlg)Ngettrace)sysstdin real_stdinr rhasattrr orig_tracers r __enter__PdbTestInput.__enter__!s<))djj) ,3C,D,D#,,.$rcUR[lUR(a![R"UR5 ggr)rrrrsettrace)rexcs r__exit__PdbTestInput.__exit__&s)OO ?? LL ) r)rrrN) __name__ __module__ __qualname____firstlineno____doc__rr r%__static_attributes__rrrrsDO *rrcg)aThis tests the custom displayhook for pdb. >>> def test_function(foo, bar): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ ... 'foo', ... 'bar', ... 'for i in range(5): print(i)', ... 'continue', ... ]): ... test_function(1, None) > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) foo 1 (Pdb) bar (Pdb) for i in range(5): print(i) 0 1 2 3 4 (Pdb) continue Nr-r-rrtest_pdb_displayhookr/,rcg)aBTest the basic commands of pdb. >>> def test_function_2(foo, bar='default'): ... print(foo) ... for i in range(5): ... print(i) ... print(bar) ... for i in range(10): ... never_executed ... print('after for') ... print('...') ... return foo.upper() >>> def test_function3(arg=None, *, kwonly=None): ... pass >>> def test_function4(a, b, c, /): ... pass >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... ret = test_function_2('baz') ... test_function3(kwonly=True) ... test_function4(1, 2, 3) ... print(ret) >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'step', # go to line ret = test_function_2('baz') ... 'step', # entering the function call ... 'args', # display function args ... 'list', # list function source ... 'bt', # display backtrace ... 'up', # step up to test_function() ... 'down', # step down to test_function_2() again ... 'next', # stepping to print(foo) ... 'next', # stepping to the for loop ... 'step', # stepping into the for loop ... 'until', # continuing until out of the for loop ... 'next', # executing the print(bar) ... 'jump 8', # jump over second for loop ... 'return', # return out of function ... 'retval', # display return value ... 'next', # step to test_function3() ... 'step', # stepping into test_function3() ... 'args', # display function args ... 'return', # return out of function ... 'next', # step to test_function4() ... 'step', # stepping to test_function4() ... 'args', # display function args ... 'continue', ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_function() -> ret = test_function_2('baz') (Pdb) step --Call-- > (1)test_function_2() -> def test_function_2(foo, bar='default'): (Pdb) args foo = 'baz' bar = 'default' (Pdb) list 1 -> def test_function_2(foo, bar='default'): 2 print(foo) 3 for i in range(5): 4 print(i) 5 print(bar) 6 for i in range(10): 7 never_executed 8 print('after for') 9 print('...') 10 return foo.upper() [EOF] (Pdb) bt ... (26)() -> test_function() (3)test_function() -> ret = test_function_2('baz') > (1)test_function_2() -> def test_function_2(foo, bar='default'): (Pdb) up > (3)test_function() -> ret = test_function_2('baz') (Pdb) down > (1)test_function_2() -> def test_function_2(foo, bar='default'): (Pdb) next > (2)test_function_2() -> print(foo) (Pdb) next baz > (3)test_function_2() -> for i in range(5): (Pdb) step > (4)test_function_2() -> print(i) (Pdb) until 0 1 2 3 4 > (5)test_function_2() -> print(bar) (Pdb) next default > (6)test_function_2() -> for i in range(10): (Pdb) jump 8 > (8)test_function_2() -> print('after for') (Pdb) return after for ... --Return-- > (10)test_function_2()->'BAZ' -> return foo.upper() (Pdb) retval 'BAZ' (Pdb) next > (4)test_function() -> test_function3(kwonly=True) (Pdb) step --Call-- > (1)test_function3() -> def test_function3(arg=None, *, kwonly=None): (Pdb) args arg = None kwonly = True (Pdb) return --Return-- > (2)test_function3()->None -> pass (Pdb) next > (5)test_function() -> test_function4(1, 2, 3) (Pdb) step --Call-- > (1)test_function4() -> def test_function4(a, b, c, /): (Pdb) args a = 1 b = 2 c = 3 (Pdb) continue BAZ Nr-r-rrtest_pdb_basic_commandsr2Hr0rc@SSKnURR5 g)Nr)bdb BreakpointclearBreakpoints)r4s rreset_Breakpointr7sNN##%rcg)a]Test basic commands related to breakpoints. >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... print(1) ... print(2) ... print(3) ... print(4) First, need to clear bdb state that might be left over from previous tests. Otherwise, the new breakpoints might get assigned different numbers. >>> reset_Breakpoint() Now test the breakpoint commands. NORMALIZE_WHITESPACE is needed because the breakpoint list outputs a tab for the "stop only" and "ignore next" lines, which we don't want to put in here. >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'break 3', ... 'break 4, +', ... 'disable 1', ... 'ignore 1 10', ... 'condition 1 1 < 2', ... 'condition 1 1 <', ... 'break 4', ... 'break 4', ... 'break', ... 'clear 3', ... 'break', ... 'condition 1', ... 'enable 1', ... 'clear 1', ... 'commands 2', ... 'p "42"', ... 'print("42", 7*6)', # Issue 18764 (not about breakpoints) ... 'end', ... 'continue', # will stop at breakpoint 2 (line 4) ... 'clear', # clear all! ... 'y', ... 'tbreak 5', ... 'continue', # will stop at temporary breakpoint ... 'break', # make sure breakpoint is gone ... 'commands 10', # out of range ... 'commands a', # display help ... 'commands 4', # already deleted ... 'break 6, undefined', # condition causing `NameError` during evaluation ... 'continue', # will stop, ignoring runtime error ... 'continue', ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) break 3 Breakpoint 1 at :3 (Pdb) break 4, + *** Invalid condition +: SyntaxError: invalid syntax (Pdb) disable 1 Disabled breakpoint 1 at :3 (Pdb) ignore 1 10 Will ignore next 10 crossings of breakpoint 1. (Pdb) condition 1 1 < 2 New condition set for breakpoint 1. (Pdb) condition 1 1 < *** Invalid condition 1 <: SyntaxError: invalid syntax (Pdb) break 4 Breakpoint 2 at :4 (Pdb) break 4 Breakpoint 3 at :4 (Pdb) break Num Type Disp Enb Where 1 breakpoint keep no at :3 stop only if 1 < 2 ignore next 10 hits 2 breakpoint keep yes at :4 3 breakpoint keep yes at :4 (Pdb) clear 3 Deleted breakpoint 3 at :4 (Pdb) break Num Type Disp Enb Where 1 breakpoint keep no at :3 stop only if 1 < 2 ignore next 10 hits 2 breakpoint keep yes at :4 (Pdb) condition 1 Breakpoint 1 is now unconditional. (Pdb) enable 1 Enabled breakpoint 1 at :3 (Pdb) clear 1 Deleted breakpoint 1 at :3 (Pdb) commands 2 (com) p "42" (com) print("42", 7*6) (com) end (Pdb) continue 1 '42' 42 42 > (4)test_function() -> print(2) (Pdb) clear Clear all breaks? y Deleted breakpoint 2 at :4 (Pdb) tbreak 5 Breakpoint 4 at :5 (Pdb) continue 2 Deleted breakpoint 4 at :5 > (5)test_function() -> print(3) (Pdb) break (Pdb) commands 10 *** cannot set commands: Breakpoint number 10 out of range (Pdb) commands a *** Invalid argument: a Usage: (Pdb) commands [bpnumber] (com) ... (com) end (Pdb) (Pdb) commands 4 *** cannot set commands: Breakpoint 4 already deleted (Pdb) break 6, undefined Breakpoint 5 at :6 (Pdb) continue 3 > (6)test_function() -> print(4) (Pdb) continue 4 Nr-r-rrtest_pdb_breakpoint_commandsr9r0rcg)aTest breakpoints on function definitions with annotation. >>> def foo[T](): ... return 0 >>> def bar() -> int: ... return 0 >>> def foobar[T]() -> int: ... return 0 >>> reset_Breakpoint() >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... pass >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'break foo', ... 'break bar', ... 'break foobar', ... 'continue', ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) break foo Breakpoint 1 at :2 (Pdb) break bar Breakpoint 2 at :2 (Pdb) break foobar Breakpoint 3 at :2 (Pdb) continue Nr-r-rr-test_pdb_breakpoint_on_annotated_function_defr;ir0rcg)aDBreakpoints with filename:lineno >>> def test_function(): ... # inspect_fodder2 is a great module as the line number is stable ... from test.test_inspect import inspect_fodder2 as mod2 ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... mod2.func88() ... mod2.func114() ... # Be a good citizen and clean up the mess ... reset_Breakpoint() First, need to clear bdb state that might be left over from previous tests. Otherwise, the new breakpoints might get assigned different numbers. >>> reset_Breakpoint() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS ... 'break test.test_inspect.inspect_fodder2:90', ... 'continue', # will stop at func88 ... 'break test/test_inspect/inspect_fodder2.py:115', ... 'continue', # will stop at func114 ... 'continue', ... ]): ... test_function() > (4)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) break test.test_inspect.inspect_fodder2:90 Breakpoint 1 at ...inspect_fodder2.py:90 (Pdb) continue > ...inspect_fodder2.py(90)func88() -> return 90 (Pdb) break test/test_inspect/inspect_fodder2.py:115 Breakpoint 2 at ...inspect_fodder2.py:115 (Pdb) continue > ...inspect_fodder2.py(115)func114() -> return 115 (Pdb) continue Nr-r-rr!test_pdb_breakpoint_with_filenamer=r0rcg)aHBreakpoints are remembered between interactive sessions >>> reset_Breakpoint() >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'import test.test_pdb', ... 'break test.test_pdb.do_something', ... 'break test.test_pdb.do_nothing', ... 'break', ... 'continue', ... ]): ... pdb.run('print()') > (1)()... (Pdb) import test.test_pdb (Pdb) break test.test_pdb.do_something Breakpoint 1 at ...test_pdb.py:... (Pdb) break test.test_pdb.do_nothing Breakpoint 2 at ...test_pdb.py:... (Pdb) break Num Type Disp Enb Where 1 breakpoint keep yes at ...test_pdb.py:... 2 breakpoint keep yes at ...test_pdb.py:... (Pdb) continue >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'break', ... 'break pdb.find_function', ... 'break', ... 'clear 1', ... 'continue', ... ]): ... pdb.run('print()') > (1)()... (Pdb) break Num Type Disp Enb Where 1 breakpoint keep yes at ...test_pdb.py:... 2 breakpoint keep yes at ...test_pdb.py:... (Pdb) break pdb.find_function Breakpoint 3 at ...pdb.py:... (Pdb) break Num Type Disp Enb Where 1 breakpoint keep yes at ...test_pdb.py:... 2 breakpoint keep yes at ...test_pdb.py:... 3 breakpoint keep yes at ...pdb.py:... (Pdb) clear 1 Deleted breakpoint 1 at ...test_pdb.py:... (Pdb) continue >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'break', ... 'clear 2', ... 'clear 3', ... 'continue', ... ]): ... pdb.run('print()') > (1)()... (Pdb) break Num Type Disp Enb Where 2 breakpoint keep yes at ...test_pdb.py:... 3 breakpoint keep yes at ...pdb.py:... (Pdb) clear 2 Deleted breakpoint 2 at ...test_pdb.py:... (Pdb) clear 3 Deleted breakpoint 3 at ...pdb.py:... (Pdb) continue Nr-r-rr:test_pdb_breakpoints_preserved_across_interactive_sessionsr?r0rcg)ahTest that do_p/do_pp do not swallow exceptions. >>> class BadRepr: ... def __repr__(self): ... raise Exception('repr_exc') >>> obj = BadRepr() >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'p obj', ... 'pp obj', ... 'continue', ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) p obj *** Exception: repr_exc (Pdb) pp obj *** Exception: repr_exc (Pdb) continue Nr-r-rrtest_pdb_pp_repr_excrAr0rcg)aTest that empty line repeats the last command. >>> def test_function(): ... x = 1 ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... y = 2 >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'p x', ... '', # Should repeat p x ... 'n ;; p 0 ;; p x', # Fill cmdqueue with multiple commands ... '', # Should still repeat p x ... 'continue', ... ]): ... test_function() > (3)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) p x 1 (Pdb) 1 (Pdb) n ;; p 0 ;; p x 0 1 > (4)test_function() -> y = 2 (Pdb) 1 (Pdb) continue Nr-r-rrtest_pdb_empty_linerCr0rcgrr-r-rr do_nothingrE2src[S5 g)N*)printr-rr do_somethingrI5s  "Ircg)a Test the list and source commands of pdb. >>> def test_function_2(foo): ... import test.test_pdb ... test.test_pdb.do_nothing() ... 'some...' ... 'more...' ... 'code...' ... 'to...' ... 'make...' ... 'a...' ... 'long...' ... 'listing...' ... 'useful...' ... '...' ... '...' ... return foo >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... ret = test_function_2('baz') >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'step', # go to the test function line ... 'list', # list first function ... 'step', # step into second function ... 'list', # list second function ... 'list', # continue listing to EOF ... 'list 1,3', # list specific lines ... 'list x', # invalid argument ... 'next', # step to import ... 'next', # step over import ... 'step', # step into do_nothing ... 'longlist', # list all lines ... 'source do_something', # list all lines of function ... 'source fooxxx', # something that doesn't exit ... 'continue', ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_function() -> ret = test_function_2('baz') (Pdb) list 1 def test_function(): 2 import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() 3 -> ret = test_function_2('baz') [EOF] (Pdb) step --Call-- > (1)test_function_2() -> def test_function_2(foo): (Pdb) list 1 -> def test_function_2(foo): 2 import test.test_pdb 3 test.test_pdb.do_nothing() 4 'some...' 5 'more...' 6 'code...' 7 'to...' 8 'make...' 9 'a...' 10 'long...' 11 'listing...' (Pdb) list 12 'useful...' 13 '...' 14 '...' 15 return foo [EOF] (Pdb) list 1,3 1 -> def test_function_2(foo): 2 import test.test_pdb 3 test.test_pdb.do_nothing() (Pdb) list x *** ... (Pdb) next > (2)test_function_2() -> import test.test_pdb (Pdb) next > (3)test_function_2() -> test.test_pdb.do_nothing() (Pdb) step --Call-- > ...test_pdb.py(...)do_nothing() -> def do_nothing(): (Pdb) longlist ... -> def do_nothing(): ... pass (Pdb) source do_something ... def do_something(): ... print(42) (Pdb) source fooxxx *** ... (Pdb) continue Nr-r-rrtest_list_commandsrK8r0rcg)aTest the whatis command >>> myvar = (1,2) >>> def myfunc(): ... pass >>> class MyClass: ... def mymethod(self): ... pass >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'whatis myvar', ... 'whatis myfunc', ... 'whatis MyClass', ... 'whatis MyClass()', ... 'whatis MyClass.mymethod', ... 'whatis MyClass().mymethod', ... 'continue', ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) whatis myvar (Pdb) whatis myfunc Function myfunc (Pdb) whatis MyClass Class test.test_pdb.MyClass (Pdb) whatis MyClass() (Pdb) whatis MyClass.mymethod Function mymethod (Pdb) whatis MyClass().mymethod Method mymethod (Pdb) continue Nr-r-rrtest_pdb_whatis_commandrMr0rcg)aTest display command >>> def test_function(): ... a = 0 ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... a = 1 ... a = 2 ... a = 3 ... a = 4 >>> with PdbTestInput([ # doctest: +ELLIPSIS ... 's', ... 'display +', ... 'display', ... 'display a', ... 'n', ... 'display', ... 'undisplay a', ... 'n', ... 'display a', ... 'undisplay', ... 'display a < 1', ... 'n', ... 'display undefined', ... 'continue', ... ]): ... test_function() > (3)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) s > (4)test_function() -> a = 1 (Pdb) display + *** Unable to display +: SyntaxError: invalid syntax (Pdb) display No expression is being displayed (Pdb) display a display a: 0 (Pdb) n > (5)test_function() -> a = 2 display a: 1 [old: 0] (Pdb) display Currently displaying: a: 1 (Pdb) undisplay a (Pdb) n > (6)test_function() -> a = 3 (Pdb) display a display a: 2 (Pdb) undisplay (Pdb) display a < 1 display a < 1: False (Pdb) n > (7)test_function() -> a = 4 (Pdb) display undefined display undefined: ** raised NameError: name 'undefined' is not defined ** (Pdb) continue Nr-r-rrtest_pdb_display_commandrOr0rcg)aTest alias command >>> class A: ... def __init__(self): ... self.attr1 = 10 ... self.attr2 = 'str' ... def method(self): ... pass >>> def test_function(): ... o = A() ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... o.method() >>> with PdbTestInput([ # doctest: +ELLIPSIS ... 's', ... 'alias pi', ... 'alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")', ... 'alias ps pi self', ... 'alias ps', ... 'pi o', ... 's', ... 'ps', ... 'alias myp p %2', ... 'alias myp', ... 'alias myp p %1', ... 'myp', ... 'myp 1', ... 'myp 1 2', ... 'alias repeat_second_arg p "%* %2"', ... 'repeat_second_arg 1 2 3', ... 'continue', ... ]): ... test_function() > (3)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) s > (4)test_function() -> o.method() (Pdb) alias pi *** Unknown alias 'pi' (Pdb) alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}") (Pdb) alias ps pi self (Pdb) alias ps ps = pi self (Pdb) pi o o.attr1 = 10 o.attr2 = str (Pdb) s --Call-- > (5)method() -> def method(self): (Pdb) ps self.attr1 = 10 self.attr2 = str (Pdb) alias myp p %2 *** Replaceable parameters must be consecutive (Pdb) alias myp *** Unknown alias 'myp' (Pdb) alias myp p %1 (Pdb) myp *** Not enough arguments for alias 'myp' (Pdb) myp 1 1 (Pdb) myp 1 2 *** Too many arguments for alias 'myp' (Pdb) alias repeat_second_arg p "%* %2" (Pdb) repeat_second_arg 1 2 3 '1 2 3 2' (Pdb) continue Nr-r-rrtest_pdb_alias_commandrQr0rcg)aSTest where command >>> def g(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> def f(): ... g(); >>> def test_function(): ... f() >>> with PdbTestInput([ # doctest: +ELLIPSIS ... 'w', ... 'where', ... 'u', ... 'w', ... 'continue', ... ]): ... test_function() > (2)g() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) w ... (8)() -> test_function() (2)test_function() -> f() (2)f() -> g(); > (2)g() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) where ... (8)() -> test_function() (2)test_function() -> f() (2)f() -> g(); > (2)g() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) u > (2)f() -> g(); (Pdb) w ... (8)() -> test_function() (2)test_function() -> f() > (2)f() -> g(); (2)g() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) continue Nr-r-rrtest_pdb_where_commandrSLr0rcg)aTest interact command >>> g = 0 >>> dict_g = {} >>> def test_function(): ... x = 1 ... lst_local = [] ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'interact', ... 'x', ... 'g', ... 'x = 2', ... 'g = 3', ... 'dict_g["a"] = True', ... 'lst_local.append(x)', ... 'exit()', ... 'p x', ... 'p g', ... 'p dict_g', ... 'p lst_local', ... 'continue', ... ]): ... test_function() > (4)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) interact *pdb interact start* ... x 1 ... g 0 ... x = 2 ... g = 3 ... dict_g["a"] = True ... lst_local.append(x) ... exit() *exit from pdb interact command* (Pdb) p x 1 (Pdb) p g 0 (Pdb) p dict_g {'a': True} (Pdb) p lst_local [2] (Pdb) continue Nr-r-rrtest_pdb_interact_commandrUr0rcg)a' Test convenience variables >>> def util_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... try: ... raise Exception('test') ... except: ... pass ... return 1 >>> def test_function(): ... util_function() >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'step', # Step to try statement ... '$_frame.f_lineno', # Check frame convenience variable ... '$ _frame', # This should be a syntax error ... '$a = 10', # Set a convenience variable ... '$a', # Print its value ... 'p "$a"', # Print the string $a ... 'p $a + 2', # Do some calculation ... 'p f"$a = {$a}"', # Make sure $ in string is not converted and f-string works ... 'u', # Switch frame ... '$_frame.f_lineno', # Make sure the frame changed ... '$a', # Make sure the value persists ... 'd', # Go back to the original frame ... 'next', ... '$a', # The value should be gone ... 'next', ... '$_exception', # Check exception convenience variable ... 'next', ... '$_exception', # Exception should be gone ... 'return', ... '$_retval', # Check return convenience variable ... 'continue', ... ]): ... test_function() > (2)util_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)util_function() -> try: (Pdb) $_frame.f_lineno 3 (Pdb) $ _frame *** SyntaxError: invalid syntax (Pdb) $a = 10 (Pdb) $a 10 (Pdb) p "$a" '$a' (Pdb) p $a + 2 12 (Pdb) p f"$a = {$a}" '$a = 10' (Pdb) u > (2)test_function() -> util_function() (Pdb) $_frame.f_lineno 2 (Pdb) $a 10 (Pdb) d > (3)util_function() -> try: (Pdb) next > (4)util_function() -> raise Exception('test') (Pdb) $a *** KeyError: 'a' (Pdb) next Exception: test > (4)util_function() -> raise Exception('test') (Pdb) $_exception Exception('test') (Pdb) next > (5)util_function() -> except: (Pdb) $_exception *** KeyError: '_exception' (Pdb) return --Return-- > (7)util_function()->1 -> return 1 (Pdb) $_retval 1 (Pdb) continue Nr-r-rrtest_convenience_variablesrWr0rcg)aTest post mortem traceback debugging of chained exception >>> def test_function_2(): ... try: ... 1/0 ... finally: ... print('Exception!') >>> def test_function_reraise(): ... try: ... test_function_2() ... except ZeroDivisionError as e: ... raise ZeroDivisionError('reraised') from e >>> def test_function(): ... import pdb; ... instance = pdb.Pdb(nosigint=True, readrc=False) ... try: ... test_function_reraise() ... except Exception as e: ... pdb._post_mortem(e, instance) >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'exceptions', ... 'exceptions 0', ... '$_exception', ... 'up', ... 'down', ... 'exceptions 1', ... '$_exception', ... 'up', ... 'down', ... 'exceptions -1', ... 'exceptions 3', ... 'up', ... 'exit', ... ]): ... try: ... test_function() ... except ZeroDivisionError: ... print('Correctly reraised.') Exception! > (5)test_function_reraise() -> raise ZeroDivisionError('reraised') from e (Pdb) exceptions 0 ZeroDivisionError('division by zero') > 1 ZeroDivisionError('reraised') (Pdb) exceptions 0 > (3)test_function_2() -> 1/0 (Pdb) $_exception ZeroDivisionError('division by zero') (Pdb) up > (3)test_function_reraise() -> test_function_2() (Pdb) down > (3)test_function_2() -> 1/0 (Pdb) exceptions 1 > (5)test_function_reraise() -> raise ZeroDivisionError('reraised') from e (Pdb) $_exception ZeroDivisionError('reraised') (Pdb) up > (5)test_function() -> test_function_reraise() (Pdb) down > (5)test_function_reraise() -> raise ZeroDivisionError('reraised') from e (Pdb) exceptions -1 *** No exception with that number (Pdb) exceptions 3 *** No exception with that number (Pdb) up > (5)test_function() -> test_function_reraise() (Pdb) exit Nr-r-rrtest_post_mortem_chainedrYr0rcg)aTest post mortem traceback debugging of chained exception >>> def make_exc_with_stack(type_, *content, from_=None): ... try: ... raise type_(*content) from from_ ... except Exception as out: ... return out ... >>> def main(): ... try: ... raise ValueError('Context Not Shown') ... except Exception as e1: ... raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause') >>> def test_function(): ... import pdb; ... instance = pdb.Pdb(nosigint=True, readrc=False) ... try: ... main() ... except Exception as e: ... pdb._post_mortem(e, instance) >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'exceptions', ... 'exceptions 0', ... 'exceptions 1', ... 'up', ... 'down', ... 'exit', ... ]): ... try: ... test_function() ... except ValueError: ... print('Ok.') > (5)main() -> raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause') (Pdb) exceptions 0 TypeError('The Cause') > 1 ValueError('With Cause') (Pdb) exceptions 0 > (3)make_exc_with_stack() -> raise type_(*content) from from_ (Pdb) exceptions 1 > (5)main() -> raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause') (Pdb) up > (5)test_function() -> main() (Pdb) down > (5)main() -> raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause') (Pdb) exitNr-r-rr!test_post_mortem_cause_no_contextr[kr0rcg)aTest post mortem traceback debugging of chained exception >>> def main(): ... try: ... raise TypeError('Context of the cause') ... except Exception as e1: ... try: ... raise ValueError('Root Cause') ... except Exception as e2: ... ex = e2 ... raise ValueError("With Cause, and cause has context") from ex >>> def test_function(): ... import pdb; ... instance = pdb.Pdb(nosigint=True, readrc=False) ... try: ... main() ... except Exception as e: ... pdb._post_mortem(e, instance) >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'exceptions', ... 'exceptions 2', ... 'up', ... 'down', ... 'exceptions 3', ... 'up', ... 'down', ... 'exceptions 4', ... 'up', ... 'down', ... 'exit', ... ]): ... try: ... test_function() ... except ValueError: ... print('Correctly reraised.') > (9)main() -> raise ValueError("With Cause, and cause has context") from ex (Pdb) exceptions 0 TypeError('Context of the cause') 1 ValueError('Root Cause') > 2 ValueError('With Cause, and cause has context') (Pdb) exceptions 2 > (9)main() -> raise ValueError("With Cause, and cause has context") from ex (Pdb) up > (5)test_function() -> main() (Pdb) down > (9)main() -> raise ValueError("With Cause, and cause has context") from ex (Pdb) exceptions 3 *** No exception with that number (Pdb) up > (5)test_function() -> main() (Pdb) down > (9)main() -> raise ValueError("With Cause, and cause has context") from ex (Pdb) exceptions 4 *** No exception with that number (Pdb) up > (5)test_function() -> main() (Pdb) down > (9)main() -> raise ValueError("With Cause, and cause has context") from ex (Pdb) exit Nr-r-rr%test_post_mortem_context_of_the_causer]r0rcg)aTest post mortem traceback debugging of chained exception In particular that cause from None (which sets __supress_context__ to True) does not show context. >>> def main(): ... try: ... raise TypeError('Context of the cause') ... except Exception as e1: ... raise ValueError("With Cause, and cause has context") from None >>> def test_function(): ... import pdb; ... instance = pdb.Pdb(nosigint=True, readrc=False) ... try: ... main() ... except Exception as e: ... pdb._post_mortem(e, instance) >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'exceptions', ... 'exit', ... ]): ... try: ... test_function() ... except ValueError: ... print('Correctly reraised.') > (5)main() -> raise ValueError("With Cause, and cause has context") from None (Pdb) exceptions > 0 ValueError('With Cause, and cause has context') (Pdb) exit Nr-r-rrtest_post_mortem_from_noner_r0rcg)agTest post mortem traceback debugging of chained exception especially when one exception has no stack. >>> def main(): ... raise Exception() from Exception() >>> def test_function(): ... import pdb; ... instance = pdb.Pdb(nosigint=True, readrc=False) ... try: ... main() ... except Exception as e: ... pdb._post_mortem(e, instance) >>> with PdbTestInput( # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... ["exceptions", ... "exceptions 0", ... "exit"], ... ): ... try: ... test_function() ... except ValueError: ... print('Correctly reraised.') > (2)main() -> raise Exception() from Exception() (Pdb) exceptions - Exception() > 1 Exception() (Pdb) exceptions 0 *** This exception does not have a traceback, cannot jump to it (Pdb) exit Nr-r-rrtest_post_mortem_from_no_stackrar0rcg)aTest post mortem called when origin exception has no stack >>> def test_function(): ... import pdb; ... instance = pdb.Pdb(nosigint=True, readrc=False) ... import sys ... sys.last_exc = Exception() ... pdb._post_mortem(sys.last_exc, instance) >>> with PdbTestInput( # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... [] ... ): ... try: ... test_function() ... except ValueError as e: ... print(e) A valid traceback must be passed if no exception is being handled Nr-r-rr test_post_mortem_single_no_stackrc7r0rcg)au Test post mortem traceback debugging of chained exception Test with simple and complex cycles, exception groups,... >>> def make_ex_with_stack(type_, *content, from_=None): ... try: ... raise type_(*content) from from_ ... except Exception as out: ... return out ... >>> def cycle(): ... try: ... raise ValueError("Cycle Leaf") ... except Exception as e: ... raise e from e ... >>> def tri_cycle(): ... a = make_ex_with_stack(ValueError, "Cycle1") ... b = make_ex_with_stack(ValueError, "Cycle2") ... c = make_ex_with_stack(ValueError, "Cycle3") ... ... a.__cause__ = b ... b.__cause__ = c ... ... raise c from a ... >>> def cause(): ... try: ... raise ValueError("Cause Leaf") ... except Exception as e: ... raise e ... >>> def context(n=10): ... try: ... raise ValueError(f"Context Leaf {n}") ... except Exception as e: ... if n == 0: ... raise ValueError(f"With Context {n}") from e ... else: ... context(n - 1) ... >>> def main(): ... try: ... cycle() ... except Exception as e1: ... try: ... tri_cycle() ... except Exception as e2: ... ex = e2 ... raise ValueError("With Context and With Cause") from ex >>> def test_function(): ... import pdb; ... instance = pdb.Pdb(nosigint=True, readrc=False) ... try: ... main() ... except Exception as e: ... pdb._post_mortem(e, instance) >>> with PdbTestInput( # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... ["exceptions", ... "exceptions 0", ... "exceptions 1", ... "exceptions 2", ... "exceptions 3", ... "exit"], ... ): ... try: ... test_function() ... except ValueError: ... print('Correctly reraised.') > (9)main() -> raise ValueError("With Context and With Cause") from ex (Pdb) exceptions 0 ValueError('Cycle2') 1 ValueError('Cycle1') 2 ValueError('Cycle3') > 3 ValueError('With Context and With Cause') (Pdb) exceptions 0 > (3)make_ex_with_stack() -> raise type_(*content) from from_ (Pdb) exceptions 1 > (3)make_ex_with_stack() -> raise type_(*content) from from_ (Pdb) exceptions 2 > (3)make_ex_with_stack() -> raise type_(*content) from from_ (Pdb) exceptions 3 > (9)main() -> raise ValueError("With Context and With Cause") from ex (Pdb) exit Nr-r-rrtest_post_mortem_complexreLr0rcg)atTest post mortem traceback debugging. >>> def test_function_2(): ... try: ... 1/0 ... finally: ... print('Exception!') >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... test_function_2() ... print('Not reached.') >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'step', # step to test_function_2() line ... 'next', # step over exception-raising call ... 'bt', # get a backtrace ... 'list', # list code of test_function() ... 'down', # step into test_function_2() ... 'list', # list code of test_function_2() ... 'continue', ... ]): ... try: ... test_function() ... except ZeroDivisionError: ... print('Correctly reraised.') > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_function() -> test_function_2() (Pdb) next Exception! ZeroDivisionError: division by zero > (3)test_function() -> test_function_2() (Pdb) bt ... (11)() -> test_function() > (3)test_function() -> test_function_2() (3)test_function_2() -> 1/0 (Pdb) list 1 def test_function(): 2 import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() 3 -> test_function_2() 4 print('Not reached.') [EOF] (Pdb) down > (3)test_function_2() -> 1/0 (Pdb) list 1 def test_function_2(): 2 try: 3 >> 1/0 4 finally: 5 -> print('Exception!') [EOF] (Pdb) continue Correctly reraised. Nr-r-rrtest_post_mortemrgr0rcg)aWhen pdb returns to a different file, it should not skip if f_trace is not already set >>> import pprint >>> class A: ... def __repr__(self): ... return 'A' >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... pprint.pprint(A()) >>> reset_Breakpoint() >>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE ... 'b A.__repr__', ... 'continue', ... 'return', ... 'next', ... 'return', ... 'return', ... 'continue', ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) b A.__repr__ Breakpoint 1 at :3 (Pdb) continue > (3)__repr__() -> return 'A' (Pdb) return --Return-- > (3)__repr__()->'A' -> return 'A' (Pdb) next > ...pprint.py..._safe_repr() -> return rep,... (Pdb) return --Return-- > ...pprint.py..._safe_repr()->('A'...) -> return rep,... (Pdb) return --Return-- > ...pprint.py...format()->('A'...) -> return... (Pdb) continue A Nr-r-rr!test_pdb_return_to_different_filerir0rcg)aThis illustrates the simple case of module skipping. >>> def skip_module(): ... import string ... import pdb; pdb.Pdb(skip=['stri*'], nosigint=True, readrc=False).set_trace() ... string.capwords('FOO') >>> with PdbTestInput([ ... 'step', ... 'step', ... 'continue', ... ]): ... skip_module() > (3)skip_module() -> import pdb; pdb.Pdb(skip=['stri*'], nosigint=True, readrc=False).set_trace() (Pdb) step > (4)skip_module() -> string.capwords('FOO') (Pdb) step --Return-- > (4)skip_module()->None -> string.capwords('FOO') (Pdb) continue Nr-r-rrtest_pdb_skip_modulesrk'r0rcg)aVThis tests pdb commands that have invalid arguments >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ ... 'a = 3', ... 'll 4', ... 'step 1', ... 'continue' ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) a = 3 *** Invalid argument: = 3 Usage: a(rgs) (Pdb) ll 4 *** Invalid argument: 4 Usage: ll | longlist (Pdb) step 1 *** Invalid argument: 1 Usage: s(tep) (Pdb) continue Nr-r-rrtest_pdb_invalid_argrmAr0rmodule_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonecg)asThis illustrates skipping of modules that call into other code. >>> def skip_module(): ... def callback(): ... return None ... import pdb; pdb.Pdb(skip=['module_to_skip*'], nosigint=True, readrc=False).set_trace() ... mod.foo_pony(callback) >>> with PdbTestInput([ ... 'step', ... 'step', ... 'step', ... 'step', ... 'step', ... 'step', ... 'continue', ... ]): ... skip_module() ... pass # provides something to "step" to > (4)skip_module() -> import pdb; pdb.Pdb(skip=['module_to_skip*'], nosigint=True, readrc=False).set_trace() (Pdb) step > (5)skip_module() -> mod.foo_pony(callback) (Pdb) step --Call-- > (2)callback() -> def callback(): (Pdb) step > (3)callback() -> return None (Pdb) step --Return-- > (3)callback()->None -> return None (Pdb) step --Return-- > (5)skip_module()->None -> mod.foo_pony(callback) (Pdb) step > (11)() -> pass # provides something to "step" to (Pdb) continue Nr-r-rr#test_pdb_skip_modules_with_callbackrpbr0rcg)aTest that "continue" and "next" work properly in bottom frame (issue #5294). >>> def test_function(): ... import pdb, sys; inst = pdb.Pdb(nosigint=True, readrc=False) ... inst.set_trace() ... inst.botframe = sys._getframe() # hackery to get the right botframe ... print(1) ... print(2) ... print(3) ... print(4) >>> with PdbTestInput([ # doctest: +ELLIPSIS ... 'step', ... 'next', ... 'break 7', ... 'continue', ... 'next', ... 'continue', ... 'continue', ... ]): ... test_function() > (3)test_function() -> inst.set_trace() (Pdb) step > (4)test_function() -> inst.botframe = sys._getframe() # hackery to get the right botframe (Pdb) next > (5)test_function() -> print(1) (Pdb) break 7 Breakpoint ... at :7 (Pdb) continue 1 2 > (7)test_function() -> print(3) (Pdb) next 3 > (8)test_function() -> print(4) (Pdb) continue 4 Nr-r-rr test_pdb_continue_in_bottomframerrr0rcN[[R"SSS9U5"U5 g)zRun pdb.method(arg).TF)nosigintreadrcN)getattrpdbPdb)methodargs r pdb_invoker{s CGGT% 0&9#>rcg)aTesting run and runeval with incorrect first argument. >>> pti = PdbTestInput(['continue',]) >>> with pti: ... pdb_invoke('run', lambda x: x) Traceback (most recent call last): TypeError: exec() arg 1 must be a string, bytes or code object >>> with pti: ... pdb_invoke('runeval', lambda x: x) Traceback (most recent call last): TypeError: eval() arg 1 must be a string, bytes or code object Nr-r-rr$test_pdb_run_with_incorrect_argumentr}r0rcg)aTesting run and runeval with code object as a first argument. >>> with PdbTestInput(['step','x', 'continue']): # doctest: +ELLIPSIS ... pdb_invoke('run', compile('x=1', '', 'exec')) > (1)()... (Pdb) step --Return-- > (1)()->None (Pdb) x 1 (Pdb) continue >>> with PdbTestInput(['x', 'continue']): ... x=0 ... pdb_invoke('runeval', compile('x+1', '', 'eval')) > (1)()->None (Pdb) x 1 (Pdb) continue Nr-r-rrtest_pdb_run_with_code_objectrr0rcg)a1Test that pdb stops after a next/until/return issued at a return debug event. >>> def test_function_2(): ... x = 1 ... x = 2 >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... test_function_2() ... test_function_2() ... test_function_2() ... end = 1 >>> reset_Breakpoint() >>> with PdbTestInput(['break test_function_2', ... 'continue', ... 'return', ... 'next', ... 'continue', ... 'return', ... 'until', ... 'continue', ... 'return', ... 'return', ... 'continue']): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) break test_function_2 Breakpoint 1 at :2 (Pdb) continue > (2)test_function_2() -> x = 1 (Pdb) return --Return-- > (3)test_function_2()->None -> x = 2 (Pdb) next > (4)test_function() -> test_function_2() (Pdb) continue > (2)test_function_2() -> x = 1 (Pdb) return --Return-- > (3)test_function_2()->None -> x = 2 (Pdb) until > (5)test_function() -> test_function_2() (Pdb) continue > (2)test_function_2() -> x = 1 (Pdb) return --Return-- > (3)test_function_2()->None -> x = 2 (Pdb) return > (6)test_function() -> end = 1 (Pdb) continue Nr-r-rr&test_next_until_return_at_return_eventrr0rcg)aATesting skip unwindng stack on yield for generators for "next" command >>> def test_gen(): ... yield 0 ... return 1 ... yield 2 >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... it = test_gen() ... try: ... if next(it) != 0: ... raise AssertionError ... next(it) ... except StopIteration as ex: ... if ex.value != 1: ... raise AssertionError ... print("finished") >>> with PdbTestInput(['step', ... 'step', ... 'step', ... 'step', ... 'next', ... 'next', ... 'step', ... 'step', ... 'continue']): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_function() -> it = test_gen() (Pdb) step > (4)test_function() -> try: (Pdb) step > (5)test_function() -> if next(it) != 0: (Pdb) step --Call-- > (1)test_gen() -> def test_gen(): (Pdb) next > (2)test_gen() -> yield 0 (Pdb) next > (3)test_gen() -> return 1 (Pdb) step --Return-- > (3)test_gen()->1 -> return 1 (Pdb) step StopIteration: 1 > (7)test_function() -> next(it) (Pdb) continue finished Nr-r-rr#test_pdb_next_command_for_generatorr*r0rcg)a%Testing skip unwindng stack on yield for coroutines for "next" command >>> import asyncio >>> async def test_coro(): ... await asyncio.sleep(0) ... await asyncio.sleep(0) ... await asyncio.sleep(0) >>> async def test_main(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... await test_coro() >>> def test_function(): ... loop = asyncio.new_event_loop() ... loop.run_until_complete(test_main()) ... loop.close() ... asyncio.set_event_loop_policy(None) ... print("finished") >>> with PdbTestInput(['step', ... 'step', ... 'step', ... 'next', ... 'next', ... 'next', ... 'step', ... 'continue']): ... test_function() > (2)test_main() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_main() -> await test_coro() (Pdb) step --Call-- > (1)test_coro() -> async def test_coro(): (Pdb) step > (2)test_coro() -> await asyncio.sleep(0) (Pdb) next > (3)test_coro() -> await asyncio.sleep(0) (Pdb) next > (4)test_coro() -> await asyncio.sleep(0) (Pdb) next Internal StopIteration > (3)test_main() -> await test_coro() (Pdb) step --Return-- > (3)test_main()->None -> await test_coro() (Pdb) continue finished Nr-r-rr#test_pdb_next_command_for_coroutinerjr0rcg)aTesting skip unwindng stack on yield for coroutines for "next" command >>> import asyncio >>> async def agen(): ... yield 1 ... await asyncio.sleep(0) ... yield 2 >>> async def test_coro(): ... async for x in agen(): ... print(x) >>> async def test_main(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... await test_coro() >>> def test_function(): ... loop = asyncio.new_event_loop() ... loop.run_until_complete(test_main()) ... loop.close() ... asyncio.set_event_loop_policy(None) ... print("finished") >>> with PdbTestInput(['step', ... 'step', ... 'step', ... 'next', ... 'next', ... 'step', ... 'next', ... 'continue']): ... test_function() > (2)test_main() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_main() -> await test_coro() (Pdb) step --Call-- > (1)test_coro() -> async def test_coro(): (Pdb) step > (2)test_coro() -> async for x in agen(): (Pdb) next > (3)test_coro() -> print(x) (Pdb) next 1 > (2)test_coro() -> async for x in agen(): (Pdb) step --Call-- > (2)agen() -> yield 1 (Pdb) next > (3)agen() -> await asyncio.sleep(0) (Pdb) continue 2 finished Nr-r-rr"test_pdb_next_command_for_asyncgenrr0rcg)aTesting no unwindng stack on yield for generators for "return" command >>> def test_gen(): ... yield 0 ... return 1 ... yield 2 >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... it = test_gen() ... try: ... if next(it) != 0: ... raise AssertionError ... next(it) ... except StopIteration as ex: ... if ex.value != 1: ... raise AssertionError ... print("finished") >>> with PdbTestInput(['step', ... 'step', ... 'step', ... 'step', ... 'return', ... 'step', ... 'step', ... 'continue']): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_function() -> it = test_gen() (Pdb) step > (4)test_function() -> try: (Pdb) step > (5)test_function() -> if next(it) != 0: (Pdb) step --Call-- > (1)test_gen() -> def test_gen(): (Pdb) return StopIteration: 1 > (7)test_function() -> next(it) (Pdb) step > (8)test_function() -> except StopIteration as ex: (Pdb) step > (9)test_function() -> if ex.value != 1: (Pdb) continue finished Nr-r-rr%test_pdb_return_command_for_generatorrr0rcg)aXTesting no unwindng stack on yield for coroutines for "return" command >>> import asyncio >>> async def test_coro(): ... await asyncio.sleep(0) ... await asyncio.sleep(0) ... await asyncio.sleep(0) >>> async def test_main(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... await test_coro() >>> def test_function(): ... loop = asyncio.new_event_loop() ... loop.run_until_complete(test_main()) ... loop.close() ... asyncio.set_event_loop_policy(None) ... print("finished") >>> with PdbTestInput(['step', ... 'step', ... 'step', ... 'next', ... 'continue']): ... test_function() > (2)test_main() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_main() -> await test_coro() (Pdb) step --Call-- > (1)test_coro() -> async def test_coro(): (Pdb) step > (2)test_coro() -> await asyncio.sleep(0) (Pdb) next > (3)test_coro() -> await asyncio.sleep(0) (Pdb) continue finished Nr-r-rr%test_pdb_return_command_for_coroutiner#r0rcg)aTesting no unwindng stack on yield for generators for "until" command if target breakpoint is not reached >>> def test_gen(): ... yield 0 ... yield 1 ... yield 2 >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... for i in test_gen(): ... print(i) ... print("finished") >>> with PdbTestInput(['step', ... 'step', ... 'until 4', ... 'step', ... 'step', ... 'continue']): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_function() -> for i in test_gen(): (Pdb) step --Call-- > (1)test_gen() -> def test_gen(): (Pdb) until 4 0 1 > (4)test_gen() -> yield 2 (Pdb) step --Return-- > (4)test_gen()->2 -> yield 2 (Pdb) step > (4)test_function() -> print(i) (Pdb) continue 2 finished Nr-r-rr$test_pdb_until_command_for_generatorrQr0rcg)aTesting no unwindng stack for coroutines for "until" command if target breakpoint is not reached >>> import asyncio >>> async def test_coro(): ... print(0) ... await asyncio.sleep(0) ... print(1) ... await asyncio.sleep(0) ... print(2) ... await asyncio.sleep(0) ... print(3) >>> async def test_main(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... await test_coro() >>> def test_function(): ... loop = asyncio.new_event_loop() ... loop.run_until_complete(test_main()) ... loop.close() ... asyncio.set_event_loop_policy(None) ... print("finished") >>> with PdbTestInput(['step', ... 'step', ... 'until 8', ... 'continue']): ... test_function() > (2)test_main() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_main() -> await test_coro() (Pdb) step --Call-- > (1)test_coro() -> async def test_coro(): (Pdb) until 8 0 1 2 > (8)test_coro() -> print(3) (Pdb) continue 3 finished Nr-r-rr$test_pdb_until_command_for_coroutinerr0rcg)a-The next command on returning from a generator controlled by a for loop. >>> def test_gen(): ... yield 0 ... return 1 >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... for i in test_gen(): ... print('value', i) ... x = 123 >>> reset_Breakpoint() >>> with PdbTestInput(['break test_gen', ... 'continue', ... 'next', ... 'next', ... 'next', ... 'continue']): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) break test_gen Breakpoint 1 at :2 (Pdb) continue > (2)test_gen() -> yield 0 (Pdb) next value 0 > (3)test_gen() -> return 1 (Pdb) next Internal StopIteration: 1 > (3)test_function() -> for i in test_gen(): (Pdb) next > (5)test_function() -> x = 123 (Pdb) continue Nr-r-rr+test_pdb_next_command_in_generator_for_looprr0rcg)aThe next command in a generator with a subiterator. >>> def test_subgenerator(): ... yield 0 ... return 1 >>> def test_gen(): ... x = yield from test_subgenerator() ... return x >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... for i in test_gen(): ... print('value', i) ... x = 123 >>> with PdbTestInput(['step', ... 'step', ... 'step', ... 'next', ... 'next', ... 'next', ... 'continue']): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (3)test_function() -> for i in test_gen(): (Pdb) step --Call-- > (1)test_gen() -> def test_gen(): (Pdb) step > (2)test_gen() -> x = yield from test_subgenerator() (Pdb) next value 0 > (3)test_gen() -> return x (Pdb) next Internal StopIteration: 1 > (3)test_function() -> for i in test_gen(): (Pdb) next > (5)test_function() -> x = 123 (Pdb) continue Nr-r-rr!test_pdb_next_command_subiteratorrr0rcg)aTest for multiline statement >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'def f(x):', ... ' return x * 2', ... '', ... 'val = 2', ... 'if val > 0:', ... ' val = f(val)', ... '', ... '', # empty line should repeat the multi-line statement ... 'val', ... 'c' ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) def f(x): ... return x * 2 ... (Pdb) val = 2 (Pdb) if val > 0: ... val = f(val) ... (Pdb) (Pdb) val 8 (Pdb) c Nr-r-rrtest_pdb_multiline_statementr r0rcg)aTest for all expressions/statements that involve closure >>> k = 0 >>> g = 1 >>> def test_function(): ... x = 2 ... g = 3 ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'k', ... 'g', ... 'y = y', ... 'global g; g', ... 'global g; (lambda: g)()', ... '(lambda: x)()', ... '(lambda: g)()', ... 'lst = [n for n in range(10) if (n % x) == 0]', ... 'lst', ... 'sum(n for n in lst if n > x)', ... 'x = 1; raise Exception()', ... 'x', ... 'def f():', ... ' return x', ... '', ... 'f()', ... 'c' ... ]): ... test_function() > (4)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) k 0 (Pdb) g 3 (Pdb) y = y *** NameError: name 'y' is not defined (Pdb) global g; g 1 (Pdb) global g; (lambda: g)() 1 (Pdb) (lambda: x)() 2 (Pdb) (lambda: g)() 3 (Pdb) lst = [n for n in range(10) if (n % x) == 0] (Pdb) lst [0, 2, 4, 6, 8] (Pdb) sum(n for n in lst if n > x) 18 (Pdb) x = 1; raise Exception() *** Exception (Pdb) x 1 (Pdb) def f(): ... return x ... (Pdb) f() 1 (Pdb) c Nr-r-rrtest_pdb_closurer4 r0rcg)aTest for expressions with command prefix >>> def test_function(): ... n = lambda x: x ... c = {"a": 1} ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'c["a"]', ... 'c.get("a")', ... 'n(1)', ... 'j=1', ... 'j+1', ... 'r"a"', ... 'next(iter([1]))', ... 'list((0, 1))', ... 'c' ... ]): ... test_function() > (4)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) c["a"] 1 (Pdb) c.get("a") 1 (Pdb) n(1) 1 (Pdb) j=1 (Pdb) j+1 2 (Pdb) r"a" 'a' (Pdb) next(iter([1])) 1 (Pdb) list((0, 1)) [0, 1] (Pdb) c Nr-r-rr test_pdb_show_attribute_and_itemrs r0rcg)aTest for reference leaks when the SIGINT handler is set. >>> def test_function(): ... i = 1 ... while i <= 2: ... sess = pdb.Pdb() ... sess.set_trace(sys._getframe()) ... print('pdb %d: %s' % (i, sess._previous_sigint_handler)) ... i += 1 >>> reset_Breakpoint() >>> with PdbTestInput(['continue', ... 'continue']): ... test_function() > (5)test_function() -> sess.set_trace(sys._getframe()) (Pdb) continue pdb 1: > (5)test_function() -> sess.set_trace(sys._getframe()) (Pdb) continue pdb 2: Nr-r-rrtest_pdb_issue_20766r r0rcg)aecho breakpoints cleared with filename:lineno >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... print(1) ... print(2) ... print(3) ... print(4) >>> reset_Breakpoint() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'break 3', ... 'clear :3', ... 'continue' ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) break 3 Breakpoint 1 at :3 (Pdb) clear :3 Deleted breakpoint 1 at :3 (Pdb) continue 1 2 3 4 Nr-r-rrtest_pdb_issue_43318r r0rcg)aSee GH-91742 >>> def test_function(): ... __author__ = "pi" ... __version__ = "3.14" ... ... def about(): ... '''About''' ... print(f"Author: {__author__!r}", ... f"Version: {__version__!r}", ... sep=" ") ... ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... about() >>> reset_Breakpoint() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'step', ... 'step', ... 'next', ... 'next', ... 'jump 5', ... 'continue' ... ]): ... test_function() > (11)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (12)test_function() -> about() (Pdb) step --Call-- > (5)about() -> def about(): (Pdb) next > (7)about() -> print(f"Author: {__author__!r}", (Pdb) next > (8)about() -> f"Version: {__version__!r}", (Pdb) jump 5 > (5)about() -> def about(): (Pdb) continue Author: 'pi' Version: '3.14' Nr-r-rrtest_pdb_issue_gh_91742r r0rcg)aSee GH-94215 Check that frame_setlineno() does not leak references. >>> def test_function(): ... def func(): ... def inner(v): pass ... inner( ... 42 ... ) ... ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... func() >>> reset_Breakpoint() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'step', ... 'step', ... 'next', ... 'next', ... 'jump 3', ... 'next', ... 'next', ... 'jump 3', ... 'next', ... 'next', ... 'jump 3', ... 'continue' ... ]): ... test_function() > (8)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) step > (9)test_function() -> func() (Pdb) step --Call-- > (2)func() -> def func(): (Pdb) next > (3)func() -> def inner(v): pass (Pdb) next > (4)func() -> inner( (Pdb) jump 3 > (3)func() -> def inner(v): pass (Pdb) next > (4)func() -> inner( (Pdb) next > (5)func() -> 42 (Pdb) jump 3 > (3)func() -> def inner(v): pass (Pdb) next > (4)func() -> inner( (Pdb) next > (5)func() -> 42 (Pdb) jump 3 > (3)func() -> def inner(v): pass (Pdb) continue Nr-r-rrtest_pdb_issue_gh_94215r r0rcg)aSee GH-101673 Make sure ll won't revert local variable assignment >>> def test_function(): ... a = 1 ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... '!a = 2', ... 'll', ... 'p a', ... 'continue' ... ]): ... test_function() > (3)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) !a = 2 (Pdb) ll 1 def test_function(): 2 a = 1 3 -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) p a 2 (Pdb) continue Nr-r-rrtest_pdb_issue_gh_101673rH r0rcg)aSee GH-103225 Make sure longlist uses 1-based line numbers in frames that correspond to a module >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'longlist', ... 'continue' ... ]): ... a = 1 ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... b = 2 > (6)() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) longlist 1 with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE 2 'longlist', 3 'continue' 4 ]): 5 a = 1 6 -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() 7 b = 2 (Pdb) continue Nr-r-rrtest_pdb_issue_gh_103225rd r0rcg)aSee GH-101517 Make sure pdb doesn't crash when the exception is caught in a try/except* block >>> def test_function(): ... try: ... raise KeyError ... except* Exception as e: ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'continue' ... ]): ... test_function() > (5)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) continue Nr-r-rrtest_pdb_issue_gh_101517r} r0rcg)aSee GH-108976 Make sure setting f_trace_opcodes = True won't crash pdb >>> def test_function(): ... import sys ... sys._getframe().f_trace_opcodes = True ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... a = 1 >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'continue' ... ]): ... test_function() > (4)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) continue Nr-r-rrtest_pdb_issue_gh_108976r r0rcg)aSee GH-127321 breakpoint() should stop at a opcode that has a line number >>> def test_function(): ... import pdb; pdb_instance = pdb.Pdb(nosigint=True, readrc=False) ... [1, 2] and pdb_instance.set_trace() ... a = 1 >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'continue' ... ]): ... test_function() > (4)test_function() -> a = 1 (Pdb) continue Nr-r-rrtest_pdb_issue_gh_127321r r0rcg)abSee GH-80731 pdb should correctly print exception info if in an except block. >>> with PdbTestInput([ # doctest: +ELLIPSIS ... 'import sys', ... 'sys.exc_info()', ... 'continue' ... ]): ... try: ... raise ValueError('Correct') ... except ValueError: ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() > (9)() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) import sys (Pdb) sys.exc_info() (, ValueError('Correct'), ) (Pdb) continue Nr-r-rrtest_pdb_issue_gh_80731r r0rcg)aRSee GH-104301 Make sure that ambiguous statements prefixed by '!' are properly disambiguated >>> with PdbTestInput([ ... 's', # step to the print line ... '! n = 42', # disambiguated statement: reassign the name n ... 'n', # advance the debugger into the print() ... 'continue' ... ]): ... n = -1 ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... print(f"The value of n is {n}") > (8)() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) s > (9)() -> print(f"The value of n is {n}") (Pdb) ! n = 42 (Pdb) n The value of n is 42 > (1)() -> with PdbTestInput([ (Pdb) continue Nr-r-rrtest_pdb_ambiguous_statementsr r0rcg)aGH-80675 pdb should work even if f_trace_lines is set to False on some frames. >>> reset_Breakpoint() >>> def test_function(): ... import sys ... frame = sys._getframe() ... frame.f_trace_lines = False ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... if frame.f_trace_lines != False: ... print("f_trace_lines is not reset after continue!") >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'continue' ... ]): ... test_function() > (5)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) continue Nr-r-rrtest_pdb_f_trace_linesr r0rcg)a pdb should not leak reference to frames >>> def frame_leaker(container): ... import sys ... container.append(sys._getframe()) ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... pass >>> def test_function(): ... import gc ... container = [] ... frame_leaker(container) # c ... print(len(gc.get_referrers(container[0]))) ... container = [] ... frame_leaker(container) # n c ... print(len(gc.get_referrers(container[0]))) ... container = [] ... frame_leaker(container) # r c ... print(len(gc.get_referrers(container[0]))) >>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE ... 'continue', ... 'next', ... 'continue', ... 'return', ... 'continue', ... ]): ... test_function() > (4)frame_leaker() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) continue 1 > (4)frame_leaker() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) next > (5)frame_leaker() -> pass (Pdb) continue 1 > (4)frame_leaker() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) return --Return-- > (5)frame_leaker()->None -> pass (Pdb) continue 1 Nr-r-rrtest_pdb_frame_refleakr r0rcg)aTesting the line number of break on function >>> def foo(): pass >>> def bar(): ... ... pass >>> def boo(): ... # comments ... global x ... x = 1 >>> def gen(): ... yield 42 >>> def test_function(): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() >>> with PdbTestInput([ # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE ... 'break foo', ... 'break bar', ... 'break boo', ... 'break gen', ... 'continue' ... ]): ... test_function() > (2)test_function() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) break foo Breakpoint ... at :1 (Pdb) break bar Breakpoint ... at :3 (Pdb) break boo Breakpoint ... at :4 (Pdb) break gen Breakpoint ... at :2 (Pdb) continue Nr-r-rrtest_pdb_function_breakr0 r0rcg)aaSee GH-65052 args, retval and display should not crash if the object is not displayable >>> class A: ... def __new__(cls): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... return object.__new__(cls) ... def __init__(self): ... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() ... self.a = 1 ... def __repr__(self): ... return self.a >>> def test_function(): ... A() >>> with PdbTestInput([ # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE ... 's', ... 's', ... 'retval', ... 'continue', ... 'args', ... 'display self', ... 'display', ... 'continue', ... ]): ... test_function() > (3)__new__() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) s > (4)__new__() -> return object.__new__(cls) (Pdb) s --Return-- > (4)__new__()-> -> return object.__new__(cls) (Pdb) retval *** repr(retval) failed: AttributeError: 'A' object has no attribute 'a' *** (Pdb) continue > (6)__init__() -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace() (Pdb) args self = *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' *** (Pdb) display self display self: *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' *** (Pdb) display Currently displaying: self: *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' *** (Pdb) continue Nr-r-rrtest_pdb_issue_gh_65052rY r0rc \rSrSrSr\R "\RRS5S?Sj5r S@Sjr Sr Sr S rS rS rS rS rSrSrSrSrSrSr\S5r\S5rSrSrSrSrSr Sr!Sr"Sr#Sr$Sr%S r&S!r'S"r(S#r)S$r*S%r+S&r,S'r-S(r.S)r/S*r0S+r1S,r2S-r3S.r4S/r5S0r6S1r7S2r8S3r9S4r:S5r;\S7r?S8r@S9rAS:rBS;rCS<rDS=rES>rFg)A PdbTestCasei cL[R"[R5 grrunlinkTESTFNrs rtearDownPdbTestCase.tearDown ))*rz'PYTHONSAFEPATH changes default sys.pathNc UR[RS5 [RSS/U-nUb[ R U-nO[ R n[R"U[R[R[R0UESS0ES9nUR[RU55upSSS5 [W[5(a[RU5OUn[W [5(a[RU 5OU n UR!WR"USUSU 35 X4$!,(df  N=f) N __pycache__-mrwPYTHONIOENCODINGutf-8stdoutrstderrenvzUnexpected return code stdout: z stderr: ) addCleanuprrmtreer executableosenviron subprocessPopenPIPE communicatestrencode isinstancebytesdecode assertEqual returncode) rpdb_argscommandsexpected_returncode extra_envcmdrprocrrs r_run_pdbPdbTestCase._run_pdb s  ((-8~~tU+h6  **y(C**C   ! oo!::0':  !--cjj.BCNF *4FE)B)Bf%)3FE)B)Bf%  OO .vhj I ~  s &'E E!cSn[US5n U R[R"U55 SSS5 UbZ[SS5n U R[R"U55 SSS5 UR [ R S5 UR [ R U5 Sn U(a [RRSS5n Uc/nURU/U-X#U5upU bU [RS'X4$!,(df  N=f!,(df  N=f!U bU [RS'ff=f)z3Run 'script' lines with pdb and the pdb 'commands'.main.pywN.pdbrcHOME) openwritetextwrapdedentrrrrrpopr) rscriptrrr script_argspdbrc remove_homefilenamefhomesaverrs rrun_pdb_scriptPdbTestCase.run_pdb_script s (C A GGHOOF+ ,!  h$./% OOI,,h 7  (((3 zz~~fd3H ." !]]H: +CXdmnNF#%- 6"~'! %$#%- 6"$s#&D &D,$D= D), D:=Ec@SUl[R"UR5 URS-nURS-n[R"UR5 [ US5nSSS5 [ US5nUR [R"U55 SSS5 UR[RUR5 URSUR/U5$!,(df  N=f!,(df  Ng=f)z(Runs the script code as part of a modulet_main /__main__.py /__init__.pyrNr) module_namerrrmkdirrrrrrr)rrr main_file init_filers rrun_pdb_modulePdbTestCase.run_pdb_module s#))*$$~5 $$~5  !!" )S !Q " )S !Q GGHOOF+ ,"  (($*:*:;}}dD$4$45x@@ " ! ! !s2C>&D> D  Dc<[[RS5nURU5 SSS5 U(dSOUS[RUS4nUR U[ R "U[R55 g!,(df  Nf=f)Nwbr)rrrrrrw find_function)r file_content func_nameexpectedrs r_assert_find_function!PdbTestCase._assert_find_function sx )""D )Q GGL !* (4 QK))8A;.8  c'' 93C3CD F * )s B  Bc*URSSS5 g)Nrfoo)rrs rtest_find_function_empty_file)PdbTestCase.test_find_function_empty_file s ""3t4rcFURSR5SS5 g)Nu@def foo(): pass def bœr(): pass def quux(): pass bœr)r rrrs rtest_find_function_found$PdbTestCase.test_find_function_found s$ ""  FH   rcHURSRS5SS5 g)NuV# coding: iso-8859-15 def foo(): pass def bœr(): pass def quux(): pass z iso-8859-15r )r rrs r-test_find_function_found_with_encoding_cookie9PdbTestCase.test_find_function_found_with_encoding_cookie s' ""  F=   rchUR[RSR5-SS5 g)Nudef bœr(): pass r )r )rcodecsBOM_UTF8rrs r!test_find_function_found_with_bom-PdbTestCase.test_find_function_found_with_bom s2 "" OO FH     rcVSnSnURX5up4URSU5 g)NzJ import __main__ print(__main__.__spec__) continueNonerassertInrrrr_s r test_specPdbTestCase.test_spec s0  ''9  ff%rc[R"S5R5nURUSS5 URUSS5 URUSS5 URUSS 5 g) Na def foo(): pass def bar(): pass # line 4 def baz(): # comment pass # line 8 def mul(): # code on multiple lines code = compile( # line 12 'def f()', '', 'exec', ) r )r rbar)r&baz)r(mul)r* )rrrr)rcodes r(test_find_function_first_executable_line4PdbTestCase.test_find_function_first_executable_line sk  "VX# & ""4 ; ""4 ; ""4 ; ""4 ,B6NoneNr-.0ls r .PdbTestCase.test_issue13183..z sJ6I'1,6Iz+Fail to step into the caller after a return) rrrrrrrr assertTrueany splitlines)rrrr&rrrs rtest_issue13183PdbTestCase.test_issue13183Y s   (C A GGHOOC( )!  (((3,,V>  Jf6G6G6IJ J 9 ; ! s &B%% B3c X[[RS5nUR[R "S5R S55 SSS5 [RS[R/n[R"U[R[R[R0[RESS0ES9nURURR 5 UR#S5upEUR%S US 5 g!,(df  N=f) Nra import threading import pdb def start_pdb(): pdb.Pdb(readrc=False).set_trace() x = 1 y = 1 t = threading.Thread(target=start_pdb) t.start()ascii-urrrscont Error*Got an error running test script under PDBrrrrrrrrrrrrrrrrr0rr1r2s rtest_issue13120PdbTestCase.test_issue13120} s)""D )Q GGHOO % %fWo /*~~tY%5%56??//??;2::;17;   ))*)))4 6E G+* ) 5D D)c X[[RS5nUR[R "S5R S55 SSS5 [RS[R/n[R"U[R[R[R0[RESS0ES9nURURR 5 UR#S5upEUR%S US 5 g!,(df  N=f) Nra import threading import pdb evt = threading.Event() def start_pdb(): evt.wait() pdb.Pdb(readrc=False).set_trace() t = threading.Thread(target=start_pdb) t.start() pdb.Pdb(readrc=False).set_trace() evt.set() t.join()rJrKrrrs cont cont rLrMrNr2s rtest_issue36250PdbTestCase.test_issue36250 s )""D )Q GGHOO%$VG_ .* ~~tY%5%56??//??=RZZ=!3W=   ))*))/: 6E G3* )rQcxSnSnSnURX5upEURX5SRX555 g)Nz def f: pass r6z SyntaxError:zE Expected: {} Got: {} Fail to handle a syntax error in the debuggee.)rr format)rrrrrrs rtest_issue16180PdbTestCase.test_issue16180 sG!!,,   h = VH % 'rcSnSnURX5up4URURS5S5 URURS5S5 g)Nz!import ast; ast.literal_eval('') zA continue where quit zast.literal_eval('')rr)rrcountrrrrrs rtest_issue84583PdbTestCase.test_issue84583 sZ6  ,,V> &<=qA &<=qArcSnSnURX5up4SRUR5Vs/sHoUR5PM sn5nUR US5 UR US5 gs snf)Nzprint('hello')z[ continue run a b c run d e f quit  z#Restarting .* with arguments: a b cz#Restarting .* with arguments: d e f)rjoinrFstrip assertRegex)rrrrrxress rtest_issue26053PdbTestCase.test_issue26053 sv!  ,,V>iiF,=,=,?@,?q,?@A DE DEAsA:ctSnSnSn[SS5nUR[R"U55 SSS5 UR [ R S5 URX5upVUR5nURSU5 URSU5 g!,(df  Nv=f)Nz~ import bar def foo(): ret = bar.bar() pass foo() zv b bar.bar c b main.py:5 c p ret quit z: def bar(): return 42 r<r-> passz(Pdb) 42) rrrrrrrrrFr )rrrr&rrrliness rtest_issue58956PdbTestCase.test_issue58956 s   (C A GGHOOC( )!  (((3,,V>!!# i' j%( ! s &B)) B7czSnSnURX5up4URSU5 URSU5 g)Nzx = 1zM step step step quit zThe program finishedzbdb.pyrr r1r!s rtest_step_into_botframe#PdbTestCase.test_step_into_botframe sC  ''9  ,f5 6*rc[R"S5n[R"S5nURUSUSS9up4URSU5 UR SU5 g)Nz- a = 1 b = 2 zU # Comments should be fine n p f"{a+8=}" q Trr SyntaxErrorza+8=9)rrrr1r rrrrrs rtest_pdbrc_basicPdbTestCase.test_pdbrc_basic sf"   !   ,,VU%UY,Z / gv&rc[R"S5n[R"S5nURUSUSS9up4URSU5 UR SU5 g) z,Test that empty lines in .pdbrc are ignored.z? a = 1 b = 2 c = 3 z n rqTrrzb = 2zc = 3N)rrrr r1rts rtest_pdbrc_empty_line!PdbTestCase.test_pdbrc_empty_line sh"   !   ,,VU%UY,Z gv& &)rc[R"S5n[R"S5nURUSUSS9up4URSU5 g)N class A: def __init__(self): self.attr = 1 a = A() b = 2 z alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}") until 6 pi a rqTrrz a.attr = 1rrrr rts rtest_pdbrc_aliasPdbTestCase.test_pdbrc_alias2 sV"  !   ,,VU%UY,Z lF+rc[R"S5n[R"S5nURUSUSS9up4URSU5 g)Nr{z b 5;;c;;n rqTrrz-> b = 2r|rts rtest_pdbrc_semicolon PdbTestCase.test_pdbrc_semicolonD sV"  !  ,,VU%UY,Z j&)rc[R"S5n[R"S5nURUSUSS9up4URSU5 g)Nr{zK b 6 commands 1 ;; p a;; end c rqTrrz<__main__.A object atr|rts rtest_pdbrc_commandsPdbTestCase.test_pdbrc_commandsT sW"  !   ,,VU%UY,Z -v6rc|[R"S5nURUSSSS9up#URSU5 g)Nz$ print('hello') rqinvalidTrrz(NameError: name 'invalid' is not definedr|)rrrrs rtest_readrc_kwargPdbTestCase.test_readrc_kwargf sB"  ,,VU)Y],^ @&Irc[RRSS5n[R"5n[ S5 [R RUS5nU[R Rl [US5nURS5 SSS5 UR[R"5RSS5 UbU[RS'SSS5 SSS5 g!,(df  Ng=f!UbU[RS'ff=f!,(df  ND=f!,(df  g=f)Nrzos.path.expanduserrrrr)rrrrtemp_dirr pathr` expanduser return_valuerrrrwrxrcLines)r save_homerrc_pathrs rtest_readrc_homedirPdbTestCase.test_readrc_homedirn sJJNN640    !Xu5I/Jggll8X6G.5BGG   + 3'3'1GGI&(  !2!21!5yA()2BJJv&0K ! !('()2BJJv&)0K/J ! !sT EAD/ DD!:DD/1E D DD,,D// D= 9E Ecp[5nSn[5nUR[SU55 UR[R"[ R S55 [ R"US9 SSS5 URUR5US-5 g!,(df  N2=f)Nz"Nobody expects... blah, blah, blahz sys.stdout set_trace)headerr_) rr enter_contextr objectrwrxrrgetvalue)rrr resourcess r test_headerPdbTestCase.test_header{ s}5 [I  # #E,$? @  # #ELL+$F G MM ( *FTM: [s A$B'' B5cSnSnURX5up4UR[SUR555U5 g)Nzprint("SUCCESS")/ continue quit c3,# UH nSU;v M g7fSUCCESSNr-r>s rrA.PdbTestCase.test_run_module.. H4GqIN4GrCrrDrErFr[s rtest_run_modulePdbTestCase.test_run_module sD' ,,V> HF4E4E4GHH&QrcSnSnURX5up4UR[SUR555U5 g)NzQ if __name__ == '__main__': print("SUCCESS") rc3,# UH nSU;v M g7frr-r>s rrA9PdbTestCase.test_module_is_run_as_main.. rrCrr[s rtest_module_is_run_as_main&PdbTestCase.test_module_is_run_as_main sF  ,,V> HF4E4E4GHH&QrcSnURSS/USS9 UR/SQU5up#URSU5 UR/SQU5up#URSU5 g) Nz continue calendarrrr)rr1December)rrz--typetext)rr rrrr"s rtest_run_module_with_args%PdbTestCase.test_run_module_with_args sd  z4(( JMM"98D  j&)MM"FQ  j&)rcXSnSnURXSS/S9up4URSU5 g)Nz@ import sys print(sys.argv[1:]) rz--barr )rz['--bar', 'foo']rr[s rtest_run_script_with_args%PdbTestCase.test_run_script_with_args s>   ,,VGUZK[,\ (&1rcSnSnURX5up4UR[SUR555U5 UR[ SUR555U5 g)Nz{ if __name__ == '__main__': pass print("SUCCESS") pass z* b 3 quit c3,# UH nSU;v M g7f)zBreakpoint 1 atNr-r>s rrA.PdbTestCase.test_breakpoint.. Ps rrAr sL8K1IQ.8KrC)rrDrErFallr[s rtest_breakpointPdbTestCase.test_breakpoint si   ,,V> PF>)"2"23333i.>.>'?YZ[ 5i6F6F5GH&Qrc[R"5nURU/SSS9up#URSUS3U5 SSS5 g!,(df  g=f)Nr6rrzError: z is a directory)rrrr )rrrrs rtest_dir_as_scriptPdbTestCase.test_dir_as_script sK    !X!]]H:rq]QNF MMGH:_=v F" ! !s +A  AcURS/SSS9upURSURS5S5 UR/SQSSS9upURS URS5S5 g) Nz-cr6rrz8pdb: error: argument -c/--command: expected one argumentr_r)z--spamrrwz*pdb: error: unrecognized arguments: --spam)rr splitrs rtest_invalid_cmd_line_options)PdbTestCase.test_invalid_cmd_line_options ssvrqI PSYS_S_`dSefgShi'>XYZ BV\\RVEWXYEZ[rcSnSnURX5up4UR[SUR555U5 g)NzY #This is a comment, on line 2 print("SUCCESS") z quit c3,# UH nSU;v M g7f)z__main__.py(4)()Nr-r>s rrA=PdbTestCase.test_blocks_at_first_code_line..s?*=Q7 !*=rCrr[s rtest_blocks_at_first_code_line*PdbTestCase.test_blocks_at_first_code_line sQ   ,,V> ?*0*;*;*=??@F HrczSnSnURX5up4URSU5 URSU5 g)Nz$ print("hello") z filename = $_frame.f_code.co_filename f = open(filename, "w") f.write("print('goodbye')") import time; time.sleep(1) f.close() ll WARNING: was editedrr[s r"test_file_modified_after_execution.PdbTestCase.test_file_modified_after_executions@   ,,V> j&) lF+rc 4SnSnSn[US5nUR[R"U55 SSS5 UR [ R U5 UR [ RS5 [RU/n[R"U[R[R[R0[RESS0ES9nUR[ R#U55upxSSS5 W=(a [$R'U5nUR)WR*S 5 UR-S U5 UR-S U5 g!,(df  GNE=f!,(df  N=f) Nz import pdb; pdb.Pdb().set_trace() with open(__file__, "w") as f: f.write("print('goodbye')\n" * 5) import time; time.sleep(1) import pdb; pdb.Pdb().set_trace() z3 continue continue rrrrrrrrr)rrrrrrrrrrrrrrrrrrrrrrr ) rrrrrrrrr"s r:test_file_modified_after_execution_with_multiple_instancesFPdbTestCase.test_file_modified_after_execution_with_multiple_instancess+    (C A GGHOOF+ ,!  (((3  ((-8~~x(   ! oo!AA%7A  ((H)=>IF 0ELL0 !, j&) lF+#!   s&E7)'F 7 F FcSnSnURX5up4URSU5 URSU5 URSU5 g)Nz import random # Any code with a source to step into so this script is not checked # for changes when it's being changed random.randint(1, 4) print("hello") aL ll n s filename = $_frame.f_back.f_code.co_filename def change_file(content, filename): with open(filename, "w") as f: f.write(f"print({content})") change_file('world', filename) restart ll helloworldrrmr[s r/test_file_modified_after_execution_with_restart;PdbTestCase.test_file_modified_after_execution_with_restart<sR   ,,V> gv& gv& V,rcVSnSnURX5up4URSU5 g)NzZ def foo(): raise ValueError("foo") foo() zX continue restart continue quit Restartingrr[s rtest_post_mortem_restart$PdbTestCase.test_post_mortem_restart[s2   ,,V> lF+rcfSUl[R"UR5 URS-nURS-nURS-nUR[RUR5 [R "UR5 [ US5nUR[R"S55 SSS5 [ US5nUR[R"S55 SSS5 [ US5nUR[R"S55 SSS5 S nURS UR/U5upgUR[S UR555U5 UR[S UR5555 UR[S UR5555 g!,(df  GN4=f!,(df  GN =f!,(df  N=f)Nrrr /module.pyr6 top_var = "VAR from top" z from . import top_var from .module import var from . import module pass # We'll stop here and print the vars zY var = "VAR from module" var2 = "second var" zz b 5 c p top_var p var p module.var2 quit rc3,# UH nSU;v M g7fzVAR from moduleNr-r>s rrA4PdbTestCase.test_relative_imports..rrCc3,# UH nSU;v M g7f)z VAR from topNr-r>s rrArsM9LANa/9LrCc3,# UH nSU;v M g7f)z second varNr-r>s rrArsK7J!LA-7JrCrrrrrrrrrrrrDrErFrrr module_filerrrr"s rtest_relative_imports!PdbTestCase.test_relative_importsls#))*$$~5 $$~5 &&5   (($*:*:; !!" )S !Q GGHOO% ")S !Q GGHOO% "+s #q GGHOO% $  MM4)9)9":HE  PF%&H&H"> H  H" H0cSUl[R"UR5 URS-nURS-nURS-nUR[RUR5 [R "UR5 [ US5nUR[R"S55 SSS5 [ US5nUR[R"S55 SSS5 [ US5nUR[R"S55 SSS5 S nURS URS -/U5upgUR[S UR555U5 g!,(df  N=f!,(df  N=f!,(df  N=f) Nrz /runme.pyrrrrzl from . import module pass # We'll stop here and print the vars z5 var = "VAR from module" zQ b 3 c p module.var quit rz.runmec3,# UH nSU;v M g7frr-r>s rrADPdbTestCase.test_relative_imports_on_plain_module..rrCrrs r%test_relative_imports_on_plain_module1PdbTestCase.test_relative_imports_on_plain_modulesn#))*$${2 $$~5 &&5   (($*:*:; !!" )S !Q GGHOO% ")S !Q GGHOO% " +s #q GGHOO% $  MM4)9)9H)D"ExP  PF (1)()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedr (Pdb) r`rrrFrs rtest_errors_in_command"PdbTestCase.test_errors_in_commandsT99   ''4@  **,QR03  rc6^U4SjnU"SS5 U"SS5 g)z.do_run handles exceptions from parsing its argc>SRSU3S/5nTRSUS-5up4TRUR5SSSSUSU3S /5 g) Nr_zrun qrrrhz(Pdb) *** Cannot run z: r r )bad_argmsgrrr"rs rcheck*PdbTestCase.test_issue34266..checksxyywi "H++FHtODIF   V..04'y3%87 r\zNo escaped character"zNo closing quotationNr-)rrs` rtest_issue34266PdbTestCase.test_issue34266s   d*+ c)*rcb[R"S5nSn[R"5nS[R R U53nURX5upVURURS5SRS5U5 SSS5 g!,(df  g=f)zkWhen running `python foo.py` sys.path[0] is an absolute path. `python -m pdb foo.py` should behave the sameQ import sys print('sys.path[0] is', sys.path[0]) c q(Pdb) sys.path[0] is r_rrN) rrrtemp_cwdrrrealpathrrrrstrip)rrrcwdrrrs rtest_issue42384PdbTestCase.test_issue42384s"      !S.rww/?/?/D.EFH!00BNF   V\\$/299$? J " ! !s A)B  B.c[R"S5nSn[R"5n[R R U5n[R RUS5n[R RUS5nSU3n[R"U5 [[R RUS5S5nURU5 SSS5 [R"U5 [R"[R RUS5[R RUS55 UR[R RSS5/U5upURURS 5S RS 5U5 SSS5 g!,(df  N=f!,(df  g=f) ziWhen running `python foo.py` sys.path[0] resolves symlinks. `python -m pdb foo.py` should behave the samerrdir_onedir_tworfoo.pyrNr_rr)rrrrrrrr`rrrsymlinkrrrr) rrrr r$r%rrrrs rtest_issue42384_symlink#PdbTestCase.test_issue42384_symlinksK"      !S''""3'Cggll3 2Gggll3 2G.wi8H HHW bggll7H5s;q< HHW  JJrww||GX6 Wh8W X!]]BGGLLH,M+NPXYNF   V\\$/299$? J" !<;" !s%B%GG%CG G G G$c [R"S5nSn[R"5nUR XSS0S9upES[ R RU53nURXd5 SSS5 g!,(df  g=f)z5With safe_path set, pdb should not mangle sys.path[0]zk import sys import random print('sys.path[0] is', sys.path[0]) zc PYTHONSAFEPATHr)rzsys.path[0] is N) rrrrrrrrr1)rrrr rr" unexpecteds rtest_safe_pathPdbTestCase.test_safe_paths"      !S++FIY[^H_+`IF*277+;+;C+@*ABJ   Z 0 " ! !s AA?? B c[R"5n[SS5n[R"S5nUR U5 SSS5 [ RRUS5n[ R"U5 [ R"[ RRUS55 [ RRUS5n[US5nUR S5 SSS5 URS/S5upgSnURURS5S RS 5U5 SSS5 g!,(df  GN=f!,(df  Ns=f!,(df  g=f) Nr&rz print('The correct file was executed') import os os.chdir("subdir") subdirz$print("The wrong file was executed")zc c qz#(Pdb) The correct file was executedr_rr)rrrrrrrrr`rrrrr) rr rsr0 wrong_filerrrs rtest_issue42383PdbTestCase.test_issue42383s    !Sh$OO%  %WW\\#x0F HHV  HHRWW\\&(3 4fh7Jj#&!>?'"]]H:yANF  rc SnSnSn[SS5nUR[R"U55 SSS5 [SS5nUR[R"U55 SSS5 UR [ R S5 UR [ R S5 URS/U5upVURSUS5 g!,(df  N=f!,(df  N=f) Nza def func(): x = "Sentinel string for gh-93696" print(x) aL import os import sys def _create_fake_frozen_module(): with open('gh93696.py') as f: src = f.read() # this function has a co_filename as if it were in a frozen module dummy_mod = compile(src, "", "exec") func_code = dummy_mod.co_consts[0] mod = type(sys)("gh93696") mod.func = type(lambda: None)(func_code, mod.__dict__) mod.__file__ = 'gh93696.py' return mod mod = _create_fake_frozen_module() mod.func() zf break 20 continue step list quit z gh93696.pyrzgh93696_host.pyz"x = "Sentinel string for gh-93696"zSentinel statement not found) rrrrrrrrr )r frozen_src host_programrrrrs rtest_gh_93696_frozen_list%PdbTestCase.test_gh_93696_frozen_list<s  * , $ GGHOOJ/ 0%#S )Q GGHOOL1 2*  ((,7  ((*;<(9':HE :FDbc% $* )s&C$ &C5$ C25 DcSnSnURX5up4URSU5 URX5up4URSU5 g)Nr6rqz main.py(0)z__main__.py(0))rr rr!s rtest_empty_filePdbTestCase.test_empty_filejsO''9  lF+''9  &/rcP[RR[RR[5S5n[R "U5HKnUR S5(dMUR[RRX5/S5 MM g)Nencoded_modulesz.pyr)rrr`dirname__file__listdirendswithr)r script_dirrs rtest_non_utf8_encoding"PdbTestCase.test_non_utf8_encodingtsfWW\\"''//(";=NO  :.H  '' rww||JABCH/rc[R"5n[R"[RR US55 [ R"S5n[[RR USS5S5nURU5 SSS5 [R"[RR US5[RR US55 UR[RR US5/SR /SQ55upEURSU5 URS U5 SSS5 g!,(df  N=f!,(df  g=f) Nsourcezg def f(x): return x + 1 f(21 + 21) z __main__.pyrz zipapp.pyzr_)zb frzp xr42z return x + 1)rrrrrr`rrrrzipappcreate_archiverr )rrrrrr"s r test_zipappPdbTestCase.test_zipappzs    !X HHRWW\\(H5 6__Fbggll8X}EsKqL  ! !"'',,x"B"$'',,x"F H rww||Hl'K&LdiiYOIF MM$ ' MM.& 1)" !LK" !s%A6E; E*CE;* E8 4E;; F )r)rN)rNNNF)Gr'r(r)r*runittestskipIfrflags safe_pathrrrrr rrrr#r-r3r9rGrOrSrrWr\rerjrnrurxr}rrrrrrrrrrrrrrrrrrrrrrrr rr!rskip_unless_symlinkr(r-r3r7r<r?rHrOr,r-rrrr s+__SYY((>@&'@6,-!%#'!#( : AF5  "  &=2 MV*";HG8G< ' 'BB F)< +' *$,$* 7$J 3;R R * 2 V   O R G \ H,&!,F->,"#MJZ> 2+ K""K#K01"K.!&,d\0I 2rrc2\rSrSrSrSrSrSrSrSr g) ChecklineTestsic.[R"5 gr) linecache clearcachers rsetUpChecklineTests.setUpsrcL[R"[R5 grrrs rrChecklineTests.tearDownrrc[[RS5nURS5 SSS5 [R "5nUR UR[RS5S5 g!,(df  NT=fNrz print(123)r)rrrrrwrxr checklinerrdbs rtest_checkline_before_debugging.ChecklineTests.test_checkline_before_debuggingsZ )""C (A GGL !) WWY i&6&6:A>) (s A;; B c8[[RS5nURS5 SSS5 [R "5nUR 5 URUR[RS5S5 g!,(df  Nd=fr`) rrrrrwrxresetrrarbs rtest_checkline_after_reset)ChecklineTests.test_checkline_after_resetsc )""C (A GGL !) WWY   i&6&6:A> ) (s B  Bc[R"S5n[[RS5nUR U5 SSS5 [ UR55S-n[[55 [R"5n[U5H2nURUR[RU55 M4 SSS5 g!,(df  N=f!,(df  g=f)Nz\ # Comment """ docstring """ ''' docstring ''' rr)rrrrrrlenrFrrrwrxranger6ra)rr1r num_linesrclinenos r test_checkline_is_not_executable/ChecklineTests.test_checkline_is_not_executables OO   )""C (A GGAJ) '!+ XZ (B *  i.>.>!GH+) () () (sC:AC+ C(+ C9r-N) r'r(r)r*r[rrdrhror,r-rrrWrWs+? ?IrrWcB\rSrSr\S5rSrSrSrSr Sr Sr g ) PdbTestReadlineicf[S5nURS:Xa[R"S5eg)Nreadlineeditlinez)libedit readline is not supported for pdb)r backendrQSkipTest)clsrts r setUpClassPdbTestReadline.setUpClasss3!,   z )##$OP P *rc[R"S5nSn[X5nURSU5 URSU5 URSU5 URSU5 g)Nz import pdb; pdb.Pdb().set_trace() # Concatenate strings so that the output doesn't appear in the source print('hello' + '!') s co ntin scommandss conditionscontinueshello!rrr r rrrr8s rtest_basic_completion%PdbTestReadline.test_basic_completions^"  "' k6* lF+ k6* i(rc[R"S5nSnUS- nUS- nUS- n[X5nURSU5 URSU5 URSU5 g) NS value = "speci" import pdb; pdb.Pdb().set_trace() s val + 'al' sp val + 'es' s$_fra c specialsspeciess$_framer|r}s rtest_expression_completion*PdbTestReadline.test_expression_completionsn"   " $$  ' j&) j&) j&)rcx[R"S5nSnUS- n[X5nURSU5 g)Nrspri val + 'al') rrr|r}s rtest_builtin_completion'PdbTestReadline.test_builtin_completions?"   ( ' j&)rcx[R"S5nSnUS- n[X5nURSU5 g)Nz def f(): original = "I live Pythin" import pdb; pdb.Pdb().set_trace() f() sorig .repl ('i', 'o') rs I love Pythonr|r}s rtest_local_namespace$PdbTestReadline.test_local_namespaces@"  - ' &/rc[R"S5nSnUS- nUS- nUS- nUS- n[X5nURSU5 g)Nz7 import pdb; pdb.Pdb().set_trace() s def func(): s ret 40 + 2  sfun () rs42r|r}s rtest_multiline_completion)PdbTestReadline.test_multiline_completion s["  ! $$   ' eV$rr-N) r'r(r)r* classmethodryr~rrrrr,r-rrrrrrs1QQ)$*** 0$%rrrc\SSKJn UR[R"U55 U$)Nr)test_pdb)testraddTestdoctest DocTestSuite)loadertestspatternrs r load_testsrs! MM'&&x01 Lr__main__)lrrrwrtypesrrQrrrYrM contextlibrriorrr test.supportrrtest.support.import_helperr test.support.pty_helperr r unittest.mockr has_socket_supportSKIP_ASYNCIO_TESTSrrr/r2r7r9r;r=r?rArCrErIrKrMrOrQrSrSno_siterUrWrYr[r]r_rarcrergrirkrm ModuleTypemodexec__dict__rprrr{r}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrequires_subprocessTestCaserrWrrrr'mainr-rrrs  1746"444*6*"8Wr&BH"H&PAF4@ aF'R=~GR8z yy2 hYxNb5pGT"J"J*bJ?D1h4: '(=s||L,^+\?  ,>@=~: x? B9v, \.`1 f(T1f D=~&P2:/bDL82("".601f'R1h A2(##A2A2H "IX&&"IJ b%h''b%b%J  z MMOr