| Server IP : 121.121.20.254 / Your IP : 216.73.216.202 Web Server : Microsoft-IIS/10.0 System : Windows NT WEB-SERVER 10.0 build 20348 (Windows Server 2022) AMD64 User : IUSR ( 0) PHP Version : 8.3.28 Disable Function : NONE MySQL : ON | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /Python315/Lib/test/__pycache__/ |
Upload File : |
R
>lqj'� c �v � ] PH s ] PHs] PHs] PH s] PHs] PHs] PHs] PH s] PH s] PH$s ] PH(s
] PH,s ] PH0s ] PH4s
] PH8s] PH<s] QH@Gs ] QHHGsGs ] QH Gs ] QHXGs ] QH`GsGs ] QHlG s ] QHtG s G s ] QH�G!s! ] Q H�G#s# P
s$ Q
Q \%2 s&Q s'Q
s(Q s)Q s*Q s+Q s,Q s-Q s.Q s/Q s0Q s1Q s2Q s3Q s4Q s5Q s6Q s7Q s8Q s9Q s:Q s;\Ox Oz % f Q! s>Q" s?Q# s@Q$ sAQ% sBQ& sCQ' sDQ( sEQ) sFQ* sGQ+ sHQ, sIQ- sJ\O� Q.2 sL\M Q/\LO� 2 Q0 sOQ1 sPQ2 sQQ3 sRQ4 sSQ5 sTQ6 sU\$% f \% c
Q7 sVQ8 sWQ9 sXQ: sYQ; sZQ< s[Q= s\\$% f Q> s]Q? s^\$% f Q@ s_QA s`QB saQC sbQD scQE sdQF se\O� sgQG shQH siQI sjQJ skQK slQL smQM snQN soQO spQP sqQQ srQR ssQS stQT suQU svQV swQW sxQX sy\O� \O� 2 QY QZ\
O� 2 2 2 s} Q[ Q\\
O� 2 s~\O� 2 Q] Q^\
O� 2 2 s\CO Q_ Q`\
O� 2 2 s�\O� \O� 2 Qa Qb\
O� 2 2 2 s�\O� \O� 2 Qc Qd\
O� 2 2 2 s�\
CO \CO
2 % ( Qe2 Qf Qg\�2 2 s�Qh s�\�Qi6X c \
CO 2 P! P! )j� )�_set_event_loop_policy)� ExitStack�redirect_stdout)�StringIO)�support)�has_socket_support� os_helper)�
import_module)�run_pty� FakeInput)� kill_python)�patchc �8 ` � \ sQ s]!s n QsQ sQ sQ sQsU s P! )� PdbTestInputz:Context manager that makes testing Pdb in doctests easier.c � � Vm P! �N)�input)�selfr s &&�"C:\Python315\\Lib\test\test_pdb.py�__init__�PdbTestInput.__init__$ s � ��
� c �� � [ O U m [ U O 2 [ m [ [ Q 2 % c [ O 2 U m P! PU m P! )�gettrace)�sys�stdin�
real_stdinr r �hasattrr �
orig_trace�r s &r � __enter__�PdbTestInput.__enter__' s< � � �)�)��� �d�j�j�)�� �,3�C��,D�,D�#�,�,�.���$��r c � � U O [ m U O % c# [ O U O 2 P! P! r )r r r r �settrace)r �excs &*r �__exit__�PdbTestInput.__exit__, s+ � ��O�O�� � �?�?�?� �L�L�� � � )� r )r r r )
�__name__�
__module__� __qualname__�__firstlineno__�__doc__r r r% �__static_attributes__�__classdictcell__��
__classdict__s @r r r ! s �� � �D��O�
*� *r r c � � P! )a This 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)
> <doctest test.test_pdb.test_pdb_displayhook[0]>(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
� r1 r r �test_pdb_displayhookr2 2 � � r c � � P! )aB Test 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()
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
-> ret = test_function_2('baz')
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(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
...
<doctest test.test_pdb.test_pdb_basic_commands[4]>(26)<module>()
-> test_function()
<doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
-> ret = test_function_2('baz')
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
-> def test_function_2(foo, bar='default'):
(Pdb) up
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
-> ret = test_function_2('baz')
(Pdb) down
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
-> def test_function_2(foo, bar='default'):
(Pdb) next
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(2)test_function_2()
-> print(foo)
(Pdb) next
baz
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(3)test_function_2()
-> for i in range(5):
(Pdb) step
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(4)test_function_2()
-> print(i)
(Pdb) until
0
1
2
3
4
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(5)test_function_2()
-> print(bar)
(Pdb) next
default
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(6)test_function_2()
-> for i in range(10):
(Pdb) jump 8
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(8)test_function_2()
-> print('after for')
(Pdb) return
after for
...
--Return--
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(10)test_function_2()->'BAZ'
-> return foo.upper()
(Pdb) retval
'BAZ'
(Pdb) next
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(4)test_function()
-> test_function3(kwonly=True)
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_basic_commands[1]>(1)test_function3()
-> def test_function3(arg=None, *, kwonly=None):
(Pdb) args
arg = None
kwonly = True
(Pdb) return
--Return--
> <doctest test.test_pdb.test_pdb_basic_commands[1]>(2)test_function3()->None
-> pass
(Pdb) next
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(5)test_function()
-> test_function4(1, 2, 3)
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_basic_commands[2]>(1)test_function4()
-> def test_function4(a, b, c, /):
(Pdb) args
a = 1
b = 2
c = 3
(Pdb) continue
BAZ
r1 r1 r r �test_pdb_basic_commandsr5 N r3 r c � � P! )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)
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',
... 'commands 1',
... 'EOF', # Simulate Ctrl-D/Ctrl-Z from user, should end input
... '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()
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break 3
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
(Pdb) break 4, +
*** Invalid condition +: SyntaxError: invalid syntax
(Pdb) disable 1
Disabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>: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 <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) break 4
Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) break
Num Type Disp Enb Where
1 breakpoint keep no at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
stop only if 1 < 2
ignore next 10 hits
2 breakpoint keep yes at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
3 breakpoint keep yes at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) clear 3
Deleted breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) break
Num Type Disp Enb Where
1 breakpoint keep no at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
stop only if 1 < 2
ignore next 10 hits
2 breakpoint keep yes at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) condition 1
Breakpoint 1 is now unconditional.
(Pdb) commands 1
(com) EOF
<BLANKLINE>
(Pdb) enable 1
Enabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
(Pdb) commands 2
(com) p "42"
(com) print("42", 7*6)
(com) end
(Pdb) continue
1
'42'
42 42
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(4)test_function()
-> print(2)
(Pdb) clear
Clear all breaks? y
Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) tbreak 5
Breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
(Pdb) continue
2
Deleted breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(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 <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:6
(Pdb) continue
3
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(6)test_function()
-> print(4)
(Pdb) continue
4
r1 r1 r r � test_pdb_breakpoint_commandsr7 � r3 r c � � P! )aq
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... for i in range(5):
... print(i)
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'break 4',
... 'ignore 1 2', # ignore once
... 'continue',
... 'condition 1 i == 4',
... 'continue',
... 'clear 1',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break 4
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>:4
(Pdb) ignore 1 2
Will ignore next 2 crossings of breakpoint 1.
(Pdb) continue
0
1
> <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>(4)test_function()
-> print(i)
(Pdb) condition 1 i == 4
New condition set for breakpoint 1.
(Pdb) continue
2
3
> <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>(4)test_function()
-> print(i)
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>:4
(Pdb) continue
4
r1 r1 r r �(test_pdb_breakpoint_ignore_and_conditionr9 k r3 r c � � P! )a� Test breakpoints on function definitions with annotation.
>>> def foo[T]():
... return 0
>>> def bar() -> int:
... return 0
>>> def foobar[T]() -> int:
... return 0
>>> 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()
> <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[3]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break foo
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[0]>:2
(Pdb) break bar
Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[1]>:2
(Pdb) break foobar
Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[2]>:2
(Pdb) continue
r1 r1 r r �-test_pdb_breakpoint_on_annotated_function_defr; � r3 r c � � P! )a` Test the commands command of pdb.
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... print(1)
... print(2)
... print(3)
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'b 3',
... 'commands',
... 'silent', # suppress the frame status output
... 'p "hello"',
... 'end',
... 'b 4',
... 'commands',
... 'until 5', # no output, should stop at line 5
... 'continue', # hit breakpoint at line 3
... '', # repeat continue, hit breakpoint at line 4 then `until` to line 5
... '',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_commands[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) b 3
Breakpoint 1 at <doctest test.test_pdb.test_pdb_commands[0]>:3
(Pdb) commands
(com) silent
(com) p "hello"
(com) end
(Pdb) b 4
Breakpoint 2 at <doctest test.test_pdb.test_pdb_commands[0]>:4
(Pdb) commands
(com) until 5
(Pdb) continue
'hello'
(Pdb)
1
2
> <doctest test.test_pdb.test_pdb_commands[0]>(5)test_function()
-> print(3)
(Pdb)
3
r1 r1 r r �test_pdb_commandsr= � r3 r c � � P! )aM Breakpoints 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()
>>> 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()
> <doctest test.test_pdb.test_pdb_breakpoint_with_filename[0]>(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
r1 r1 r r �!test_pdb_breakpoint_with_filenamer? � r3 r c � � P! )a� New breakpoint on once disabled line should work
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... for i in range(3):
... j = i * 2
... print(j)
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'break 5',
... 'c',
... 'clear 1',
... 'break 4',
... 'c',
... 'clear 2',
... 'c'
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break 5
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>:5
(Pdb) c
> <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>(5)test_function()
-> print(j)
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>:5
(Pdb) break 4
Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>:4
(Pdb) c
0
> <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>(4)test_function()
-> j = i * 2
(Pdb) clear 2
Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>:4
(Pdb) c
2
4
r1 r1 r r �$test_pdb_breakpoint_on_disabled_linerA r3 r c � � P! )a1 Breakpoints are remembered between interactive sessions
>>> 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()')
> <string>(1)<module>()...
(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()')
> <string>(1)<module>()...
(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()')
> <string>(1)<module>()...
(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
r1 r1 r r �:test_pdb_breakpoints_preserved_across_interactive_sessionsrC . r3 r c � � P! )a, Test break_anywhere() method of Pdb.
>>> def outer():
... def inner():
... import pdb
... import sys
... p = pdb.Pdb(nosigint=True, readrc=False)
... p.set_trace()
... frame = sys._getframe()
... print(p.break_anywhere(frame)) # inner
... print(p.break_anywhere(frame.f_back)) # outer
... print(p.break_anywhere(frame.f_back.f_back)) # caller
... inner()
>>> def caller():
... outer()
>>> def test_function():
... caller()
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'b 3',
... 'c',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_break_anywhere[0]>(6)inner()
-> p.set_trace()
(Pdb) b 3
Breakpoint 1 at <doctest test.test_pdb.test_pdb_break_anywhere[0]>:3
(Pdb) c
True
False
False
r1 r1 r r �test_pdb_break_anywhererE p r3 r c � � P! )ah Test 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()
> <doctest test.test_pdb.test_pdb_pp_repr_exc[2]>(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
r1 r1 r r �test_pdb_pp_repr_excrG � r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_empty_line[0]>(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
> <doctest test.test_pdb.test_pdb_empty_line[0]>(4)test_function()
-> y = 2
(Pdb)
1
(Pdb) continue
r1 r1 r r �test_pdb_empty_linerI � r3 r c � � P! r r1 r1 r r �
do_nothingrK � s � �r c � � [ ]*2 P! )�* )�printr1 r r � do_somethingrO � s � � �"�Ir c � � P! )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()
> <doctest test.test_pdb.test_list_commands[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_list_commands[1]>(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--
> <doctest test.test_pdb.test_list_commands[0]>(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
> <doctest test.test_pdb.test_list_commands[0]>(2)test_function_2()
-> import test.test_pdb
(Pdb) next
> <doctest test.test_pdb.test_list_commands[0]>(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
r1 r1 r r �test_list_commandsrQ � r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_whatis_command[3]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) whatis myvar
<class 'tuple'>
(Pdb) whatis myfunc
Function myfunc
(Pdb) whatis MyClass
Class test.test_pdb.MyClass
(Pdb) whatis MyClass()
<class 'test.test_pdb.MyClass'>
(Pdb) whatis MyClass.mymethod
Function mymethod
(Pdb) whatis MyClass().mymethod
Method mymethod
(Pdb) continue
r1 r1 r r �test_pdb_whatis_commandrS 7 r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_display_command[0]>(3)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) s
> <doctest test.test_pdb.test_pdb_display_command[0]>(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
> <doctest test.test_pdb.test_pdb_display_command[0]>(5)test_function()
-> a = 2
display a: 1 [old: 0]
(Pdb) display
Currently displaying:
a: 1
(Pdb) undisplay a
(Pdb) n
> <doctest test.test_pdb.test_pdb_display_command[0]>(6)test_function()
-> a = 3
(Pdb) display a
display a: 2
(Pdb) undisplay
(Pdb) display a < 1
display a < 1: False
(Pdb) n
> <doctest test.test_pdb.test_pdb_display_command[0]>(7)test_function()
-> a = 4
(Pdb) display undefined
display undefined: ** raised NameError: name 'undefined' is not defined **
(Pdb) continue
r1 r1 r r �test_pdb_display_commandrU ` r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_alias_command[1]>(3)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) s
> <doctest test.test_pdb.test_pdb_alias_command[1]>(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--
> <doctest test.test_pdb.test_pdb_alias_command[0]>(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
r1 r1 r r �test_pdb_alias_commandrW � r3 r c � � P! )a}
Test 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',
... 'w 1',
... 'w invalid',
... 'u',
... 'w',
... 'w 0',
... 'w 100',
... 'w -100',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w
...
<doctest test.test_pdb.test_pdb_where_command[3]>(13)<module>()
-> test_function()
<doctest test.test_pdb.test_pdb_where_command[2]>(2)test_function()
-> f()
<doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g()
> <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) where
...
<doctest test.test_pdb.test_pdb_where_command[3]>(13)<module>()
-> test_function()
<doctest test.test_pdb.test_pdb_where_command[2]>(2)test_function()
-> f()
<doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g()
> <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w 1
> <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w invalid
*** Invalid count (invalid)
(Pdb) u
> <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g()
(Pdb) w
...
<doctest test.test_pdb.test_pdb_where_command[3]>(13)<module>()
-> test_function()
<doctest test.test_pdb.test_pdb_where_command[2]>(2)test_function()
-> f()
> <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g()
<doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w 0
> <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g()
(Pdb) w 100
...
<doctest test.test_pdb.test_pdb_where_command[3]>(13)<module>()
-> test_function()
<doctest test.test_pdb.test_pdb_where_command[2]>(2)test_function()
-> f()
> <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g()
<doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w -100
...
<doctest test.test_pdb.test_pdb_where_command[3]>(13)<module>()
-> test_function()
<doctest test.test_pdb.test_pdb_where_command[2]>(2)test_function()
-> f()
> <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g()
<doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
r1 r1 r r �test_pdb_where_commandrY � r3 r c � � P! )ad Test restart command
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False, mode='inline').set_trace()
... x = 1
>>> with PdbTestInput([ # doctest: +ELLIPSIS
... 'restart',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_restart_command[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False, mode='inline').set_trace()
(Pdb) restart
*** run/restart command is disabled when pdb is running in inline mode.
Use the command line interface to enable restarting your program
e.g. "python -m pdb myscript.py"
(Pdb) continue
r1 r1 r r �test_pdb_restart_commandr[ C r3 r c � � P! )z�Test that commands can be passed to Pdb.set_trace()
>>> def test_function():
... x = 1
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace(commands=['p x', 'c'])
>>> test_function()
1
r1 r1 r r � test_pdb_commands_with_set_tracer] X r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_interact_command[2]>(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
r1 r1 r r �test_pdb_interact_commandr_ g r3 r c � � P! )a;
Test convenience variables
>>> def util_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... try:
... raise Exception('test')
... except Exception:
... 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()
> <doctest test.test_pdb.test_convenience_variables[0]>(2)util_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_convenience_variables[0]>(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
> <doctest test.test_pdb.test_convenience_variables[1]>(2)test_function()
-> util_function()
(Pdb) $_frame.f_lineno
2
(Pdb) $a
10
(Pdb) d
> <doctest test.test_pdb.test_convenience_variables[0]>(3)util_function()
-> try:
(Pdb) next
> <doctest test.test_pdb.test_convenience_variables[0]>(4)util_function()
-> raise Exception('test')
(Pdb) $a
*** KeyError: 'a'
(Pdb) next
Exception: test
> <doctest test.test_pdb.test_convenience_variables[0]>(4)util_function()
-> raise Exception('test')
(Pdb) $_exception
Exception('test')
(Pdb) next
> <doctest test.test_pdb.test_convenience_variables[0]>(5)util_function()
-> except Exception:
(Pdb) $_exception
*** KeyError: '_exception'
(Pdb) return
--Return--
> <doctest test.test_pdb.test_convenience_variables[0]>(7)util_function()->1
-> return 1
(Pdb) $_retval
1
(Pdb) continue
r1 r1 r r �test_convenience_variablesra � r3 r c � � P! )a� Test 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!
> <doctest test.test_pdb.test_post_mortem_chained[1]>(5)test_function_reraise()
-> raise ZeroDivisionError('reraised') from e
(Pdb) exceptions
0 ZeroDivisionError('division by zero')
> 1 ZeroDivisionError('reraised')
(Pdb) exceptions 0
> <doctest test.test_pdb.test_post_mortem_chained[0]>(3)test_function_2()
-> 1/0
(Pdb) $_exception
ZeroDivisionError('division by zero')
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_chained[1]>(3)test_function_reraise()
-> test_function_2()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_chained[0]>(3)test_function_2()
-> 1/0
(Pdb) exceptions 1
> <doctest test.test_pdb.test_post_mortem_chained[1]>(5)test_function_reraise()
-> raise ZeroDivisionError('reraised') from e
(Pdb) $_exception
ZeroDivisionError('reraised')
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_chained[2]>(5)test_function()
-> test_function_reraise()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_chained[1]>(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
> <doctest test.test_pdb.test_post_mortem_chained[2]>(5)test_function()
-> test_function_reraise()
(Pdb) exit
r1 r1 r r �test_post_mortem_chainedrc � r3 r c � � P! )a� Test 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.')
> <doctest test.test_pdb.test_post_mortem_cause_no_context[1]>(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
> <doctest test.test_pdb.test_post_mortem_cause_no_context[0]>(3)make_exc_with_stack()
-> raise type_(*content) from from_
(Pdb) exceptions 1
> <doctest test.test_pdb.test_post_mortem_cause_no_context[1]>(5)main()
-> raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause')
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_cause_no_context[2]>(5)test_function()
-> main()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_cause_no_context[1]>(5)main()
-> raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause')
(Pdb) exitr1 r1 r r �!test_post_mortem_cause_no_contextre H r3 r c � � P! )a� Test 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.')
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(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
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[1]>(5)test_function()
-> main()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) exceptions 3
*** No exception with that number
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[1]>(5)test_function()
-> main()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) exceptions 4
*** No exception with that number
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[1]>(5)test_function()
-> main()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) exit
r1 r1 r r �%test_post_mortem_context_of_the_causerg � r3 r c � � P! )a� Test post mortem traceback debugging of chained exception
In particular that cause from None (which sets __suppress_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.')
> <doctest test.test_pdb.test_post_mortem_from_none[0]>(5)main()
-> raise ValueError("With Cause, and cause has context") from None
(Pdb) exceptions
> 0 ValueError('With Cause, and cause has context')
(Pdb) exit
r1 r1 r r �test_post_mortem_from_noneri � r3 r c � � P! )ag Test 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.')
> <doctest test.test_pdb.test_post_mortem_from_no_stack[0]>(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
r1 r1 r r � test_post_mortem_from_no_stackrk � r3 r c � � P! )a� Test 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
r1 r1 r r � test_post_mortem_single_no_stackrm r3 r c � � P! )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.')
> <doctest test.test_pdb.test_post_mortem_complex[5]>(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
> <doctest test.test_pdb.test_post_mortem_complex[0]>(3)make_ex_with_stack()
-> raise type_(*content) from from_
(Pdb) exceptions 1
> <doctest test.test_pdb.test_post_mortem_complex[0]>(3)make_ex_with_stack()
-> raise type_(*content) from from_
(Pdb) exceptions 2
> <doctest test.test_pdb.test_post_mortem_complex[0]>(3)make_ex_with_stack()
-> raise type_(*content) from from_
(Pdb) exceptions 3
> <doctest test.test_pdb.test_post_mortem_complex[5]>(9)main()
-> raise ValueError("With Context and With Cause") from ex
(Pdb) exit
r1 r1 r r �test_post_mortem_complexro ) r3 r c � � P! )at Test 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.')
> <doctest test.test_pdb.test_post_mortem[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
-> test_function_2()
(Pdb) next
Exception!
ZeroDivisionError: division by zero
> <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
-> test_function_2()
(Pdb) bt
...
<doctest test.test_pdb.test_post_mortem[2]>(11)<module>()
-> test_function()
> <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
-> test_function_2()
<doctest test.test_pdb.test_post_mortem[0]>(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
> <doctest test.test_pdb.test_post_mortem[0]>(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.
r1 r1 r r �test_post_mortemrq � r3 r c � � P! )a� When 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())
>>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
... 'b A.__repr__',
... 'continue',
... 'return',
... 'next',
... 'return',
... 'return',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_return_to_different_file[2]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) b A.__repr__
Breakpoint 1 at <doctest test.test_pdb.test_pdb_return_to_different_file[1]>:3
(Pdb) continue
> <doctest test.test_pdb.test_pdb_return_to_different_file[1]>(3)__repr__()
-> return 'A'
(Pdb) return
--Return--
> <doctest test.test_pdb.test_pdb_return_to_different_file[1]>(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
r1 r1 r r �!test_pdb_return_to_different_filers � r3 r c � � P! )a� This 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()
> <doctest test.test_pdb.test_pdb_skip_modules[0]>(3)skip_module()
-> import pdb; pdb.Pdb(skip=['stri*'], nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()
-> string.capwords('FOO')
(Pdb) step
--Return--
> <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()->None
-> string.capwords('FOO')
(Pdb) continue
r1 r1 r r �test_pdb_skip_modulesru r3 r c � � P! )aG This tests pdb commands that have invalid arguments
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'a = 3',
... 'll 4',
... 'step 1',
... 'p',
... 'enable ',
... 'continue'
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_invalid_arg[0]>(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) p
*** Argument is required for this command
Usage: p expression
(Pdb) enable
*** Argument is required for this command
Usage: enable bpnumber [bpnumber ...]
(Pdb) continue
r1 r1 r r �test_pdb_invalid_argrw r3 r �module_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonec � � P! )as This 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
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(4)skip_module()
-> import pdb; pdb.Pdb(skip=['module_to_skip*'], nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(5)skip_module()
-> mod.foo_pony(callback)
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(2)callback()
-> def callback():
(Pdb) step
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(3)callback()
-> return None
(Pdb) step
--Return--
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(3)callback()->None
-> return None
(Pdb) step
--Return--
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(5)skip_module()->None
-> mod.foo_pony(callback)
(Pdb) step
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[1]>(11)<module>()
-> pass # provides something to "step" to
(Pdb) continue
r1 r1 r r �#test_pdb_skip_modules_with_callbackrz F r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(3)test_function()
-> inst.set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(4)test_function()
-> inst.botframe = sys._getframe() # hackery to get the right botframe
(Pdb) next
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(5)test_function()
-> print(1)
(Pdb) break 7
Breakpoint ... at <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>:7
(Pdb) continue
1
2
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(7)test_function()
-> print(3)
(Pdb) next
3
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(8)test_function()
-> print(4)
(Pdb) continue
4
r1 r1 r r � test_pdb_continue_in_bottomframer| u r3 r c �X � [ [ O P P
Q5 U 2 U2 P! )zRun pdb.method(arg).)�nosigint�readrc)�getattr�pdb�Pdb)�method�args &&r �
pdb_invoker� � s � � �C�G�G�T�%� 0�&�9�#�>r c � � P! )a� Testing 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
r1 r1 r r �$test_pdb_run_with_incorrect_argumentr� � r3 r c � � P! )a� Testing run and runeval with code object as a first argument.
>>> with PdbTestInput(['step','x', 'continue']): # doctest: +ELLIPSIS
... pdb_invoke('run', compile('x=1', '<string>', 'exec'))
> <string>(1)<module>()...
(Pdb) step
--Return--
> <string>(1)<module>()->None
(Pdb) x
1
(Pdb) continue
>>> with PdbTestInput(['x', 'continue']):
... x=0
... pdb_invoke('runeval', compile('x+1', '<string>', 'eval'))
> <string>(1)<module>()->None
(Pdb) x
1
(Pdb) continue
r1 r1 r r � test_pdb_run_with_code_objectr� � r3 r c � � P! )a Test 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
>>> with PdbTestInput(['break test_function_2',
... 'continue',
... 'return',
... 'next',
... 'continue',
... 'return',
... 'until',
... 'continue',
... 'return',
... 'return',
... 'continue']):
... test_function()
> <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break test_function_2
Breakpoint 1 at <doctest test.test_pdb.test_next_until_return_at_return_event[0]>:2
(Pdb) continue
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
-> x = 1
(Pdb) return
--Return--
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
-> x = 2
(Pdb) next
> <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(4)test_function()
-> test_function_2()
(Pdb) continue
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
-> x = 1
(Pdb) return
--Return--
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
-> x = 2
(Pdb) until
> <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(5)test_function()
-> test_function_2()
(Pdb) continue
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
-> x = 1
(Pdb) return
--Return--
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
-> x = 2
(Pdb) return
> <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(6)test_function()
-> end = 1
(Pdb) continue
r1 r1 r r �&test_next_until_return_at_return_eventr� � r3 r c � � P! )aB Testing skip unwinding 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()
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(3)test_function()
-> it = test_gen()
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(4)test_function()
-> try:
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(5)test_function()
-> if next(it) != 0:
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(1)test_gen()
-> def test_gen():
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(2)test_gen()
-> yield 0
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(3)test_gen()
-> return 1
(Pdb) step
--Return--
> <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(3)test_gen()->1
-> return 1
(Pdb) step
StopIteration: 1
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(7)test_function()
-> next(it)
(Pdb) continue
finished
r1 r1 r r �#test_pdb_next_command_for_generatorr�
r3 r c � � P! )aq Testing $_asynctask is accessible in async context
>>> import asyncio
>>> async def test():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
>>> def test_function():
... asyncio.run(test(), loop_factory=asyncio.EventLoop)
>>> with PdbTestInput([ # doctest: +ELLIPSIS
... '$_asynctask',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_asynctask[1]>(2)test()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) $_asynctask
<Task pending name=... coro=<test() running at <doctest test.test_pdb.test_pdb_asynctask[1]>:2> ...
(Pdb) continue
r1 r1 r r �test_pdb_asynctaskr� N r3 r c � � P! )a� Testing await support in pdb
>>> import asyncio
>>> async def test():
... print("hello")
... await asyncio.sleep(0)
... print("world")
... return 42
>>> async def main():
... import pdb
... task = asyncio.create_task(test())
... await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
... pass
>>> def test_function():
... asyncio.run(main(), loop_factory=asyncio.EventLoop)
>>> with PdbTestInput([ # doctest: +ELLIPSIS
... 'x = await task',
... 'p x',
... 'x = await test()',
... 'p x',
... 'new_task = asyncio.create_task(test())',
... 'await new_task',
... 'await non_exist()',
... 's',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) x = await task
hello
world
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p x
42
(Pdb) x = await test()
hello
world
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p x
42
(Pdb) new_task = asyncio.create_task(test())
(Pdb) await new_task
hello
world
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) await non_exist()
*** NameError: name 'non_exist' is not defined
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) s
> <doctest test.test_pdb.test_pdb_await_support[2]>(5)main()
-> pass
(Pdb) continue
r1 r1 r r �test_pdb_await_supportr� e r3 r c � � P! )a� Testing await support with breakpoints set in tasks
>>> import asyncio
>>> async def test():
... x = 2
... await asyncio.sleep(0)
... return 42
>>> async def main():
... import pdb
... task = asyncio.create_task(test())
... await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
>>> def test_function():
... asyncio.run(main(), loop_factory=asyncio.EventLoop)
>>> with PdbTestInput([ # doctest: +ELLIPSIS
... 'b test',
... 'k = await task',
... 'n',
... 'p x',
... 'continue',
... 'p k',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_await_with_breakpoint[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) b test
Breakpoint 1 at <doctest test.test_pdb.test_pdb_await_with_breakpoint[1]>:2
(Pdb) k = await task
> <doctest test.test_pdb.test_pdb_await_with_breakpoint[1]>(2)test()
-> x = 2
(Pdb) n
> <doctest test.test_pdb.test_pdb_await_with_breakpoint[1]>(3)test()
-> await asyncio.sleep(0)
(Pdb) p x
2
(Pdb) continue
> <doctest test.test_pdb.test_pdb_await_with_breakpoint[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p k
42
(Pdb) continue
r1 r1 r r � test_pdb_await_with_breakpointr� � r3 r c � � P! )ak Testing await support context vars
>>> import asyncio
>>> import contextvars
>>> var = contextvars.ContextVar('var')
>>> async def get_var():
... return var.get()
>>> async def set_var(val):
... var.set(val)
... return var.get()
>>> async def main():
... var.set(42)
... import pdb
... await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
>>> def test_function():
... asyncio.run(main(), loop_factory=asyncio.EventLoop)
>>> with PdbTestInput([
... 'p var.get()',
... 'print(await get_var())',
... 'print(await asyncio.create_task(set_var(100)))',
... 'p var.get()',
... 'print(await set_var(99))',
... 'p var.get()',
... 'print(await get_var())',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p var.get()
42
(Pdb) print(await get_var())
42
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) print(await asyncio.create_task(set_var(100)))
100
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p var.get()
42
(Pdb) print(await set_var(99))
99
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p var.get()
99
(Pdb) print(await get_var())
99
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) continue
r1 r1 r r �test_pdb_await_contextvarr� � r3 r c � � P! )a� Testing skip unwinding stack on yield for coroutines for "next" command
>>> from test.support import run_yielding_async_fn, async_yield
>>> async def test_coro():
... await async_yield(0)
... await async_yield(0)
... await async_yield(0)
>>> async def test_main():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... await test_coro()
>>> def test_function():
... run_yielding_async_fn(test_main)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'step',
... 'next',
... 'next',
... 'next',
... 'step',
... 'continue']):
... test_function()
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(2)test_main()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()
-> await test_coro()
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(1)test_coro()
-> async def test_coro():
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(2)test_coro()
-> await async_yield(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(3)test_coro()
-> await async_yield(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(4)test_coro()
-> await async_yield(0)
(Pdb) next
Internal StopIteration
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()
-> await test_coro()
(Pdb) step
--Return--
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()->None
-> await test_coro()
(Pdb) continue
finished
r1 r1 r r �#test_pdb_next_command_for_coroutiner� r3 r c � � P! )a� Testing skip unwinding stack on yield for coroutines for "next" command
>>> from test.support import run_yielding_async_fn, async_yield
>>> async def agen():
... yield 1
... await async_yield(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():
... run_yielding_async_fn(test_main)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'step',
... 'next',
... 'next',
... 'step',
... 'next',
... 'continue']):
... test_function()
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[3]>(2)test_main()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[3]>(3)test_main()
-> await test_coro()
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(1)test_coro()
-> async def test_coro():
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(2)test_coro()
-> async for x in agen():
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(3)test_coro()
-> print(x)
(Pdb) next
1
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(2)test_coro()
-> async for x in agen():
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[1]>(2)agen()
-> yield 1
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[1]>(3)agen()
-> await async_yield(0)
(Pdb) continue
2
finished
r1 r1 r r �"test_pdb_next_command_for_asyncgenr� K r3 r c � � P! )a� Testing no unwinding 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()
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(3)test_function()
-> it = test_gen()
(Pdb) step
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(4)test_function()
-> try:
(Pdb) step
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(5)test_function()
-> if next(it) != 0:
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_return_command_for_generator[0]>(1)test_gen()
-> def test_gen():
(Pdb) return
StopIteration: 1
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(7)test_function()
-> next(it)
(Pdb) step
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(8)test_function()
-> except StopIteration as ex:
(Pdb) step
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(9)test_function()
-> if ex.value != 1:
(Pdb) continue
finished
r1 r1 r r �%test_pdb_return_command_for_generatorr� � r3 r c � � P! )a Testing no unwinding stack on yield for coroutines for "return" command
>>> from test.support import run_yielding_async_fn, async_yield
>>> async def test_coro():
... await async_yield(0)
... await async_yield(0)
... await async_yield(0)
>>> async def test_main():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... await test_coro()
>>> def test_function():
... run_yielding_async_fn(test_main)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'step',
... 'next',
... 'continue']):
... test_function()
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[2]>(2)test_main()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[2]>(3)test_main()
-> await test_coro()
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(1)test_coro()
-> async def test_coro():
(Pdb) step
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(2)test_coro()
-> await async_yield(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(3)test_coro()
-> await async_yield(0)
(Pdb) continue
finished
r1 r1 r r �%test_pdb_return_command_for_coroutiner� � r3 r c � � P! )a Testing no unwinding 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()
> <doctest test.test_pdb.test_pdb_until_command_for_generator[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_until_command_for_generator[1]>(3)test_function()
-> for i in test_gen():
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(1)test_gen()
-> def test_gen():
(Pdb) until 4
0
1
> <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(4)test_gen()
-> yield 2
(Pdb) step
--Return--
> <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(4)test_gen()->2
-> yield 2
(Pdb) step
> <doctest test.test_pdb.test_pdb_until_command_for_generator[1]>(4)test_function()
-> print(i)
(Pdb) continue
2
finished
r1 r1 r r �$test_pdb_until_command_for_generatorr� � r3 r c � � P! )a� Testing no unwinding stack for coroutines
for "until" command if target breakpoint is not reached
>>> from test.support import run_yielding_async_fn, async_yield
>>> async def test_coro():
... print(0)
... await async_yield(0)
... print(1)
... await async_yield(0)
... print(2)
... await async_yield(0)
... print(3)
>>> async def test_main():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... await test_coro()
>>> def test_function():
... run_yielding_async_fn(test_main)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'until 8',
... 'continue']):
... test_function()
> <doctest test.test_pdb.test_pdb_until_command_for_coroutine[2]>(2)test_main()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_until_command_for_coroutine[2]>(3)test_main()
-> await test_coro()
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_until_command_for_coroutine[1]>(1)test_coro()
-> async def test_coro():
(Pdb) until 8
0
1
2
> <doctest test.test_pdb.test_pdb_until_command_for_coroutine[1]>(8)test_coro()
-> print(3)
(Pdb) continue
3
finished
r1 r1 r r �$test_pdb_until_command_for_coroutiner� !
r3 r c � � P! )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
>>> with PdbTestInput(['break test_gen',
... 'continue',
... 'next',
... 'next',
... 'next',
... 'continue']):
... test_function()
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break test_gen
Breakpoint 1 at <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>:2
(Pdb) continue
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>(2)test_gen()
-> yield 0
(Pdb) next
value 0
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>(3)test_gen()
-> return 1
(Pdb) next
Internal StopIteration: 1
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[1]>(3)test_function()
-> for i in test_gen():
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[1]>(5)test_function()
-> x = 123
(Pdb) continue
r1 r1 r r �+test_pdb_next_command_in_generator_for_loopr� Q
r3 r c � � P! )a� The 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()
> <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(3)test_function()
-> for i in test_gen():
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(1)test_gen()
-> def test_gen():
(Pdb) step
> <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(2)test_gen()
-> x = yield from test_subgenerator()
(Pdb) next
value 0
> <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(3)test_gen()
-> return x
(Pdb) next
Internal StopIteration: 1
> <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(3)test_function()
-> for i in test_gen():
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(5)test_function()
-> x = 123
(Pdb) continue
r1 r1 r r �!test_pdb_next_command_subiteratorr� z
r3 r c � � P! )aW GH-132536: PY_THROW event should not be turned off
>>> def gen():
... yield 0
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... g = gen()
... try:
... g.throw(TypeError)
... except TypeError:
... pass
>>> with PdbTestInput([
... 'b 7',
... 'continue',
... 'clear 1',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_with_throw[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) b 7
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_with_throw[1]>:7
(Pdb) continue
> <doctest test.test_pdb.test_pdb_breakpoint_with_throw[1]>(7)test_function()
-> pass
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_with_throw[1]>:7
(Pdb) continue
r1 r1 r r � test_pdb_breakpoint_with_throwr� �
r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_multiline_statement[0]>(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
r1 r1 r r � test_pdb_multiline_statementr� �
r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_closure[2]>(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
r1 r1 r r �test_pdb_closurer� �
r3 r c � � P! )a� Test 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()
> <doctest test.test_pdb.test_pdb_show_attribute_and_item[0]>(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
r1 r1 r r � test_pdb_show_attribute_and_itemr� / r3 r c � � P! )a+ Hard-coded breakpoint() calls should invoke the same debugger instance
>>> def test_function():
... x = 1
... import pdb; pdb.Pdb().set_trace()
... original_pdb_settrace()
... x = 2
>>> with PdbTestInput(['display x',
... 'n',
... 'n',
... 'n',
... 'n',
... 'undisplay',
... 'c']):
... test_function()
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(3)test_function()
-> import pdb; pdb.Pdb().set_trace()
(Pdb) display x
display x: 1
(Pdb) n
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(4)test_function()
-> original_pdb_settrace()
(Pdb) n
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(4)test_function()
-> original_pdb_settrace()
(Pdb) n
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(5)test_function()
-> x = 2
(Pdb) n
--Return--
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(5)test_function()->None
-> x = 2
display x: 2 [old: 1]
(Pdb) undisplay
(Pdb) c
r1 r1 r r � test_pdb_with_inline_breakpointr� [ r3 r c � � P! )a� Test 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
>>> with PdbTestInput(['continue',
... 'continue']):
... test_function()
> <doctest test.test_pdb.test_pdb_issue_20766[0]>(5)test_function()
-> sess.set_trace(sys._getframe())
(Pdb) continue
pdb 1: <built-in function default_int_handler>
> <doctest test.test_pdb.test_pdb_issue_20766[0]>(5)test_function()
-> sess.set_trace(sys._getframe())
(Pdb) continue
pdb 2: <built-in function default_int_handler>
r1 r1 r r �test_pdb_issue_20766r� � r3 r c � � P! )a echo 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)
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'break 3',
... 'clear <doctest test.test_pdb.test_pdb_issue_43318[0]>:3',
... 'continue'
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_issue_43318[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break 3
Breakpoint 1 at <doctest test.test_pdb.test_pdb_issue_43318[0]>:3
(Pdb) clear <doctest test.test_pdb.test_pdb_issue_43318[0]>:3
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_issue_43318[0]>:3
(Pdb) continue
1
2
3
4
r1 r1 r r �test_pdb_issue_43318r� � r3 r c � � P! )a� See 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()
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'step',
... 'step',
... 'next',
... 'next',
... 'jump 5',
... 'continue'
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(11)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(12)test_function()
-> about()
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(5)about()
-> def about():
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(7)about()
-> print(f"Author: {__author__!r}",
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(8)about()
-> f"Version: {__version__!r}",
(Pdb) jump 5
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(5)about()
-> def about():
(Pdb) continue
Author: 'pi' Version: '3.14'
r1 r1 r r �test_pdb_issue_gh_91742r� � r3 r c � � P! )a� See 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()
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'step',
... 'step',
... 'next',
... 'next',
... 'jump 3',
... 'next',
... 'next',
... 'jump 3',
... 'next',
... 'next',
... 'jump 3',
... 'continue'
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(8)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(9)test_function()
-> func()
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(2)func()
-> def func():
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
-> def inner(v): pass
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
-> inner(
(Pdb) jump 3
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
-> def inner(v): pass
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
-> inner(
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(5)func()
-> 42
(Pdb) jump 3
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
-> def inner(v): pass
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
-> inner(
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(5)func()
-> 42
(Pdb) jump 3
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
-> def inner(v): pass
(Pdb) continue
r1 r1 r r �test_pdb_issue_gh_94215r� � r3 r c � � P! )a� See GH-101673
Make sure ll and switching frames 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',
... 'u',
... 'p a',
... 'd',
... 'p a',
... 'continue'
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_101673[0]>(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) u
> <doctest test.test_pdb.test_pdb_issue_gh_101673[1]>(11)<module>()
-> test_function()
(Pdb) p a
*** NameError: name 'a' is not defined
(Pdb) d
> <doctest test.test_pdb.test_pdb_issue_gh_101673[0]>(3)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) p a
2
(Pdb) continue
r1 r1 r r �test_pdb_issue_gh_101673r� + r3 r c � � P! )a� See 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
> <doctest test.test_pdb.test_pdb_issue_gh_103225[0]>(6)<module>()
-> 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
r1 r1 r r �test_pdb_issue_gh_103225r� U r3 r c � � P! )a See 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()
> <doctest test.test_pdb.test_pdb_issue_gh_101517[0]>(5)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
r1 r1 r r �test_pdb_issue_gh_101517r� n r3 r c � � P! )a� See 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()
> <doctest test.test_pdb.test_pdb_issue_gh_108976[0]>(4)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
r1 r1 r r �test_pdb_issue_gh_108976r� � r3 r c � � P! )a� See 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()
> <doctest test.test_pdb.test_pdb_issue_gh_127321[0]>(4)test_function()
-> a = 1
(Pdb) continue
r1 r1 r r �test_pdb_issue_gh_127321r� � r3 r c � � P! )a� See GH-136057
"step" and "next" commands should be able to get over list comprehensions
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... lst = [i for i in range(10)]
... for i in lst: pass
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'next',
... 'next',
... 'step',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_136057[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_136057[0]>(3)test_function()
-> lst = [i for i in range(10)]
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_136057[0]>(4)test_function()
-> for i in lst: pass
(Pdb) step
--Return--
> <doctest test.test_pdb.test_pdb_issue_gh_136057[0]>(4)test_function()->None
-> for i in lst: pass
(Pdb) continue
r1 r1 r r �test_pdb_issue_gh_136057r� � r3 r c � � P! )ab See 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()
> <doctest test.test_pdb.test_pdb_issue_gh_80731[0]>(9)<module>()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) import sys
(Pdb) sys.exc_info()
(<class 'ValueError'>, ValueError('Correct'), <traceback object at ...>)
(Pdb) continue
r1 r1 r r �test_pdb_issue_gh_80731r� � r3 r c � � P! )aR See 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}")
> <doctest test.test_pdb.test_pdb_ambiguous_statements[0]>(8)<module>()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) s
> <doctest test.test_pdb.test_pdb_ambiguous_statements[0]>(9)<module>()
-> print(f"The value of n is {n}")
(Pdb) ! n = 42
(Pdb) n
The value of n is 42
> <doctest test.test_pdb.test_pdb_ambiguous_statements[0]>(1)<module>()
-> with PdbTestInput([
(Pdb) continue
r1 r1 r r � test_pdb_ambiguous_statementsr� � r3 r c � � P! )aq GH-80675
pdb should work even if f_trace_lines is set to False on some frames.
>>> 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()
> <doctest test.test_pdb.test_pdb_f_trace_lines[0]>(5)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
r1 r1 r r �test_pdb_f_trace_linesr� � r3 r c � � P! )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()
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(4)frame_leaker()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
1
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(4)frame_leaker()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) next
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()
-> pass
(Pdb) continue
1
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(4)frame_leaker()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) return
--Return--
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()->None
-> pass
(Pdb) continue
1
r1 r1 r r �test_pdb_frame_refleakr�
r3 r c � � P! )a� Testing 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()
> <doctest test.test_pdb.test_pdb_function_break[4]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break foo
Breakpoint ... at <doctest test.test_pdb.test_pdb_function_break[0]>:1
(Pdb) break bar
Breakpoint ... at <doctest test.test_pdb.test_pdb_function_break[1]>:3
(Pdb) break boo
Breakpoint ... at <doctest test.test_pdb.test_pdb_function_break[2]>:4
(Pdb) break gen
Breakpoint ... at <doctest test.test_pdb.test_pdb_function_break[3]>:2
(Pdb) continue
r1 r1 r r �test_pdb_function_breakr� >
r3 r c � � P! )aa See 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()
> <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(3)__new__()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) s
> <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(4)__new__()
-> return object.__new__(cls)
(Pdb) s
--Return--
> <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(4)__new__()-><A instance at ...>
-> return object.__new__(cls)
(Pdb) retval
*** repr(retval) failed: AttributeError: 'A' object has no attribute 'a' ***
(Pdb) continue
> <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(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
r1 r1 r r �test_pdb_issue_gh_65052r� g
r3 r c � � P! )a� See GH-142834
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... foo = 1
... bar = 2
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'break 4',
... 'break 3',
... 'clear 2',
... 'commands',
... 'p "success"',
... 'end',
... 'continue',
... 'clear 1',
... 'commands',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_commands_last_breakpoint[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break 4
Breakpoint 1 at <doctest test.test_pdb.test_pdb_commands_last_breakpoint[0]>:4
(Pdb) break 3
Breakpoint 2 at <doctest test.test_pdb.test_pdb_commands_last_breakpoint[0]>:3
(Pdb) clear 2
Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_commands_last_breakpoint[0]>:3
(Pdb) commands
(com) p "success"
(com) end
(Pdb) continue
'success'
> <doctest test.test_pdb.test_pdb_commands_last_breakpoint[0]>(4)test_function()
-> bar = 2
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_commands_last_breakpoint[0]>:4
(Pdb) commands
*** cannot set commands: no existing breakpoint
(Pdb) continue
r1 r1 r r �!test_pdb_commands_last_breakpointr� �
r3 r c �r ` � \ sQ sQs n Q s\O \O O Q2 QLQ k2 s
QMQ ks Q s Q s
Q sQ sQ
sQ sQ sQ
sQ sQ sQ sQ sQ sQ sQ sQ sQ s Q s Q s Q s Q s Q s!Q s"Q s#Q s$Q s%Q s&Q! s'Q" s(Q# s)Q$ s*Q% s+Q& s,Q' s-Q( s.Q) s/Q* s0Q+ s1Q, s2Q- s3Q. s4Q/ s5Q0 s6Q1 s7Q2 s8Q3 s9Q4 s:Q5 s;Q6 s<Q7 s=Q8 s>Q9 s?Q: s@Q; sAQ< sB\CO� Q= 2 sEQ> sFQ? sGQ@ sHQA sIQB sJQC sKQD sLQE sMQF sN\O \OQG2 QH 2 sPQI sQQJ sRQKsSU sTP! )N� PdbTestCasei�
c �P � [ O [ O 2 P! r �r �unlink�TESTFNr s &r �tearDown�PdbTestCase.tearDown�
� � �����)�)�*r �'PYTHONSAFEPATH changes default sys.pathc � � U O [ O Q 2 [ O QQ,U* oUd [
O U* oL[
O o[ O U[ O [ O [ O - UAQQ-AQ5 9^tt^ 2 oUO [ O U2 2 v q�PPP2 [ W[ 2 % c [ O U2 LSo[ W [ 2 % c [ O U 2 LS o U O! WO" UQU QU 02 V�1! ) % f h K�9 h)� __pycache__�-mr� �PYTHONIOENCODING�utf-8��stdoutr �stderr�env� Unexpected return code
stdout: �
stderr: )�
addCleanupr �rmtreer �
executable�os�environ�
subprocess�Popen�PIPE� communicate�str�encode�
isinstance�bytes�decode� assertEqual�
returncode)
r �pdb_args�commands�expected_returncode� extra_env�cmdr� �procr� r� s
&&&&& r �_run_pdb�PdbTestCase._run_pdb�
s! � �
��� �(�(�-�8��~�~�t�U�+�h�6�� � ��*�*�y�(�C��*�*�C�
�
�
��!��� �o�o�!���:��:� 0�'�:�
�
� � !� -� -�c�j�j��.B� C�N�F�
� *4�F�E�)B�)B�� � �f�%���)3�F�E�)B�)B�� � �f�%��� ��� �O�O� �.�v�h�j��� I�
�
�~� �
�
�s �;'E*�*E: �3E: c �� � Qo[ UQ2 9^tt^ 2 o U O [ O U2 2 PPP2 Udc [ QQ2 9^tt^ 2 o U O [ O U2 2 PPP2 U O [
O Q2 U O [
O U2 [
O 2 9^tt^ 2 o
U% c U
O Q2 Ue , oU O U,U* V#U2 v q�PPP2 V�1! ) % f h K�9 h ) % f h K�9 h ) % f h W W 1! 9 h)z3Run 'script' lines with pdb and the pdb 'commands'.�main.py�w�.pdbrc�HOME)
�open�write�textwrap�dedentr� r r� �EnvironmentVarGuard�unsetr� )
r �scriptr� r� r� � script_args�pdbrc� remove_home�filename�fr� r� r� s
&&&&&&&& r �run_pdb_script�PdbTestCase.run_pdb_script�
s � � ��
�(�C�
�
�A�
�G�G�H�O�O�F�+� ,� !� � ��h��$�$���������.�/� %� �O�O�I� ,� ,�h� 7� ��� �(�(�(�3�
�
*�
*�
,�
,���� � �&�!��"� � � !�]�]�H�:� �+C�X�dm� n�N�F� -� �~� � !�
�� %�$��
-�
,� �v�~� �sA �&D1� &E�)E�2E� E�1E �:E �E �
E �E* � E* c �z � QU m [ O U O 2 U O Q* oU O Q* o[ O U O 2 [ UQ2 9^tt^ 2 o PPP2 [ UQ2 9^tt^ 2 oUO
[ O U2 2 PPP2 U O [ O U O 2 U O QU O ,U2 ! ) % f h K�9 h ) % f h Kk9 h)z(Runs the script code as part of a module�t_main� /__main__.py� /__init__.pyr r� ) � module_namer r� r� �mkdirr r r r r� r� )r r
r� � main_file� init_filer s &&& r �run_pdb_module�PdbTestCase.run_pdb_module s� � �#�������)�)�*��$�$�~�5� ��$�$�~�5� �
����!�!�"�
�)�S�
!�
!�Q� � "�
�)�S�
!�
!�Q�
�G�G�H�O�O�F�+� ,� "� ��� �(�(�$�*:�*:�;��}�}�d�D�$4�$4� 5�x�@�@� "�
!��
!�
!�s$ �D�!&D*�D' � D' �*D: �3D: c �f � [ [ O Q 2 9^tt^ 2 oUO U2 PPP2 U% f PL U] * [ O U]* 1oU O U[
O U[ O 2 2 P! ) % f h Kr9 h)�wb)r r r� r r� r� �
find_function)r � file_content� func_name�expectedr s &&&& r �_assert_find_function�!PdbTestCase._assert_find_function s{ � �
�)�"�"�D�
)�
)�Q�
�G�G�L� !� *� (�4� �Q�K��)�)�8�A�;�.8�� ��� �c�'�'� �9�3C�3C�D� F� *�
)�s �B � B0 �)B0 c �T � U O 2 9% f U O 2 ! )z:Return a directory exposing live file descriptors, if any.)� _proc_fd_dir� _dev_fd_dirr s &r �_fd_dir_for_pipe_targets�$PdbTestCase._fd_dir_for_pipe_targets s" � �� � �"�8�8�d�&6�&6�&8�8r c �. � [ O O Q2 % c P! Qo[ O O U2 % cF [ O O
[ O O UQ2 2 % c U! P! )z9Return /proc-backed fd dir when it can be used for pipes.�sunosz
/proc/self/fd�0)r �platform�
startswithr� �path�isdir�exists�join)r �proc_fds & r r% �PdbTestCase._proc_fd_dir s] � � �<�<� "� "�7� +� +��!��
�7�7�=�=�� !� !�b�g�g�n�n�R�W�W�\�\�'�3�5O�&P�&P��N�r c �� � Qo[ O O U2 % c� [ O O [ O O UQ2 2 % cq [
O O Q2 % cJ [ O Q2 O [ O U2 O 6X c P! U! U! P! [ c P! h 9 h)z&Return /dev-backed fd dir when usable.z/dev/fdr+ �freebsdz/dev) r� r. r/ r0 r1 r r, r- �stat�st_dev�FileNotFoundError)r �dev_fds & r r& �PdbTestCase._dev_fd_dir( s� � ���
�7�7�=�=�� � �R�W�W�^�^�B�G�G�L�L���4M�%N�%N��|�|�&�&�y�1�1� ��w�w�v��-�-����� �1G�1G�G� #� H� �M�6�M��� )� � � �s �AC � C-�(C-�,C-c �. � U O Q QP2 P! )r �foo)r" r s &r � test_find_function_empty_file�)PdbTestCase.test_find_function_empty_file5 s � � �"�"�3��t�4r c �J � U O Q O 2 QQ2 P! )u@ def foo():
pass
def bœr():
pass
def quux():
pass
� bœr)r@ � �r" r� r s &r �test_find_function_found�$PdbTestCase.test_find_function_found8 s$ � � �"�"�
� �F�H� � �
r c � � [ O 2 o[ O UQ5 o[ O
2 o[ O [ QQ2 9^tt^ 2 UO V3O 12 PPP2 U O QUO 2 2 P! ) % f h K29 h)z9Test that pdb.line_prefix binding is dynamic (gh-141781).�r� � line_prefixzCUSTOM_PREFIX> ) �ior r� r� r � _getframer � swap_attr�print_stack_entry�f_lineno�assertIn�getvalue)r r� �p�frames & r �/test_print_stack_entry_uses_dynamic_line_prefix�;PdbTestCase.test_print_stack_entry_uses_dynamic_line_prefixH s{ � ���� �� �G�G�6� "�� �
�
���
�
�
�s�M�3D�
E�
E�
� � ���� 7� 8� F�
�
�
�'�� � �):�;� F�
E�s �' B.�.B> �7B> c �L � U O Q O Q2 QQ2 P! )uV # coding: iso-8859-15
def foo():
pass
def bœr():
pass
def quux():
pass
z iso-8859-15r@ )r@ � rB r s &r �-test_find_function_found_with_encoding_cookie�9PdbTestCase.test_find_function_found_with_encoding_cookieV s' � � �"�"�
� �F�=�� � �
r c �t � U O [ O Q O 2 * QQ2 P! )u def bœr():
pass
r@ )r@ � )r" �codecs�BOM_UTF8r� r s &r �!test_find_function_found_with_bom�-PdbTestCase.test_find_function_found_with_bomg s2 � � �"�"� �O�O� � �F�H�
�
� �
r c �Z � Q oQoU O V2 v q4U O QU2 P! )zJ
import __main__
print(__main__.__spec__)
�continue�None�r rM �r r
r� r� �_s & r � test_spec�PdbTestCase.test_specq s0 � � ��
���'�'��9� �� �
�
�f�f�%r c � � U O 2 oUe U O Q2 [ O 2 v q#Q oU O VB2 U O VC2 [ O
O
U[ U2 2 o[ O
O U2 % f U O Q2 Qo[ O V6O Q2 2 [ O U2 [ O
] * oU O [ O
O ] U2 [ O U2 oUO o UO" o
[% V�2 U O' U
Q* Q2 U O' U
Q* UO( 2 U O+ U
Q * 2 P! )
z=
_ScriptTarget doesn't fail on an anonymous pipe.
GH-142315
z7anonymous pipe targets require /proc/self/fd or /dev/fdc �Z � [ O U 2 P! [ c P! h 9 hr )r� �close�OSError)�fds &r �
safe_close�APdbTestCase.test_script_target_anonymous_pipe.<locals>.safe_close� s$ � �
����� ���
��
�s � � *�*�*z,fd directory does not expose anonymous pipeszmarker = "via_pipe"
r� �marker�via_pipe�__file__�__spec__)r' �skipTestr� �piper� r. r1 r� r0 r r� rg r � __setitem__r� �
_ScriptTarget�code� namespace�execr� r � assertIsNone) r �fd_dir�read_fd�write_fdrj � pipe_path�
script_source�original_path0�target� code_textru s & r �!test_script_target_anonymous_pipe�-PdbTestCase.test_script_target_anonymous_pipe} sE � � �.�.�0�� �>� �M�M�S� T� �G�G�I��� �
���
�,� ���
�-��G�G�L�L���W� �6� ��w�w�~�~�i�(�(� �M�M�H� I�/�
�
����/�/��8�9�
����� ���!��� ������,�,�a� �@��"�"�9�-���K�K� ��$�$� � �Y�"� ����8�,�j�9� ����:�.����@� ���)�J�/�0r c �� � [ O Q 2 O 2 oU O UQQ2 U O UQQ2 U O UQQ2 U O UQQ2 P! ) a� 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()',
'<string>',
'exec',
)
r< �bar�baz�mul)r< � )r� � )r� � )r� � )r r r� r" )r rt s & r �(test_find_function_first_executable_line�4PdbTestCase.test_find_function_first_executable_line� sk � ���� �
�" �V�X�#
�&
�"�"�4��
�;� �"�"�4��
�;� �"�"�4��
�;� �"�"�4�� �<r c � � [ [ O Q 2 9^tt^ 2 oUO Q2 PPP2 [ O
QQ[ O ,o[ O U[ O [ O [ O Q5 oU O UO O 2 UO Q2 v qEU O QUQ2 P! ) % f h K�9 h)r s print("testing my pdb")
r� r� )r� r r� s quit
s SyntaxErrorz0Got a syntax error running test script under PDB)r r r� r r r� r� r� r� r� r� rg r� � assertNotIn�r r r� r� r� r� s & r �test_issue7964�PdbTestCase.test_issue7964� s� � �
�)�"�"�D�
)�
)�Q�
�G�G�2� 3� *��~�~�t�U�I�,<�,<�=��� � �� �?�?� �/�/� �?�?���
���� � �)�)�*� �)�)�)�4��� ��� ��K� M� *�
)�s �C1�1D �:D c � � Q oQoU O V2 v q4S9% f PS9% f P* oU O QUQ2 U O QUQ2 P! )z�
def do_testcmdwithnodocs(self, arg):
pass
import pdb
pdb.Pdb.do_testcmdwithnodocs = do_testcmdwithnodocs
zA
continue
help testcmdwithnodocs
�AttributeErrorzCCalling help on a command with no docs should be handled gracefullyz;*** No help for 'testcmdwithnodocs'; __doc__ string missingz<Calling help on a command with no docs should print an error)r r� rM )r r
r� r� r� �outputs & r �test_issue46434�PdbTestCase.test_issue46434� sg � � �� �� �,�,�V�>����,�,�B�6�<�<�R�0�� ���)�6�^� `� �
�
�S�U[�T� Vr c �� � Q oQoQo[ QQ2 9^tt^ 2 oUO [ O U2 2 PPP2 U O [
O Q2 U O V2 v qVS O [ 9PI c* Q UO 2 2 D % f J P L P
L Q UO 2 2 2 Q2 P! ) % f h K�9 h)z�
from bar import bar
def foo():
bar()
def nope():
pass
def foobar():
foo()
nope()
foobar()
z�
from bar import bar
break bar
continue
step
step
quit
z5
def bar():
pass
�bar.pyr c 3 �8 � S F � D oQ U7 w � J
P! 3h)zmain.py(5)foo()->Noner1 ��.0�ls & r � <genexpr>�.PdbTestCase.test_issue13183.<locals>.<genexpr> s ��6I� � �6I��'�1�,�6I�� �z+Fail to step into the caller after a return) r r r r r� r r� r �
assertTrue�any�
splitlines)r r
r� r� r r� r� s & r �test_issue13183�PdbTestCase.test_issue13183� s� � � �� �� �� �(�C�
�
�A�
�G�G�H�O�O�C�(� )� !� ��� �(�(�(�3� �,�,�V�>��� ��� �C�J�f�6G�6G�6I�J�C�C�C�J�f�6G�6G�6I�J� J� 9� ;� !�
�s �&C � C. �'C. c �v � [ [ O Q 2 9^tt^ 2 oUO [ O
Q2 O
Q2 2 PPP2 [ O Q[ O ,o[ O U[ O [ O [ O - [ O AQQ-AQ5 oU O UO O 2 UO# Q2 v qEU O% QUQ 2 P! ) % f h K�9 h)
r a
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�-ur� r� r� s cont
� Error�*Got an error running test script under PDB�r r r� r r r r� r r� r� r� r� r� r� r� r� rg r� r� r� s & r �test_issue13120�PdbTestCase.test_issue13120 s� � � �)�"�"�D�
)�
)�Q�
�G�G�H�O�O�
% �
� %�f�W�o�
/� *� �~�~�t�Y�%5�%5�6��� � �� �?�?� �/�/� �?�?�;�2�:�:�;� 1�7�;� ��
���� � �)�)�*� �)�)�)�4��� ����6�E� G�+ *�
)�� �5D(�(D8 �1D8 c �v � [ [ O Q 2 9^tt^ 2 oUO [ O
Q2 O
Q2 2 PPP2 [ O Q[ O ,o[ O U[ O [ O [ O - [ O AQQ-AQ5 oU O UO O 2 UO# Q2 v qEU O% QUQ 2 P! ) % f h K�9 h)
r a�
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()r� r� r� r� r� s
cont
cont
r� r� r� r� s & r �test_issue36250�PdbTestCase.test_issue36250# s� � �
�)�"�"�D�
)�
)�Q�
�G�G�H�O�O� % � � $�V�G�_�
.� *� �~�~�t�Y�%5�%5�6��� � �� �?�?� �/�/� �?�?�=�R�Z�Z�=�!3�W�=� ��
���� � �)�)�*� �)�)�/�:��� ����6�E� G�3 *�
)�r� c �| � Q oPoQoU O V2 v qEU O V5QO V52 2 P! )z def f: pass
z SyntaxError:zE
Expected:
{}
Got:
{}
Fail to handle a syntax error in the debuggee.)r rM �format)r r
r� r! r� r� s & r �test_issue16180�PdbTestCase.test_issue16180A sE � � ����!�� �,�,� �
���
�
�
�h�
=�
�V�H�
%� 'r c � � Q oQoU O V2 v q4U O UO Q2 ]2 U O UO Q2 ]2 P! )z!import ast; ast.literal_eval('')
zA
continue
where
quit
zast.literal_eval(''))r r� �count�r r
r� r� r� s & r �test_issue84583�PdbTestCase.test_issue84583N sX � �5�� ��
�,�,�V�>���
���� � �&<�=�q�A� ���� � �&<�=�q�Ar c � � Q oQoU O V2 v q4QO UO 2 Tt, tF D pUO 2 MJ to2 oU O UQ2 U O UQ2 P! t toh )zprint('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)r r1 r� �strip� assertRegex)r r
r� r� r� �x�ress & r �test_issue26053�PdbTestCase.test_issue26053^ sv � �!�� �� �,�,�V�>����i�i�F�,=�,=�,?�@�,?�q����,?�@�A�� ���� D�E� ���� D�E�� As �A<c � � Q oQoQo[ QQ2 9^tt^ 2 oUO [ O U2 2 PPP2 U O [
O Q2 U O V2 v qVUO 2 oU O QU2 U O QU2 P! ) % f h Ky9 h)z~
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)
r r r r r� r r� r r� rM )r r
r� r� r r� r� �liness & r �test_issue58956�PdbTestCase.test_issue58956l s� � � �� �� �� �(�C�
�
�A�
�G�G�H�O�O�C�(� )� !� ��� �(�(�(�3� �,�,�V�>����!�!�#�� �
�
�i��'� �
�
�j�%�(�
!�
�s �&B3�3C �<C c �~ � Q oQoU O V2 v q4U O QU2 U O QU2 P! )zx = 1zM
step
step
step
quit
zThe program finishedzbdb.py�r rM r� ra s & r �test_step_into_botframe�#PdbTestCase.test_step_into_botframe� sC � � �� �� �'�'��9� �� �
�
�,�f�5� ����6�*r c � � [ O Q 2 o[ O Q2 oU O UQUP Q5 v q4U O QU2 U O QU2 U O QU2 P! )z-
a = 1
b = 2
zU
# Comments should be fine
n
p f"{a+8=}"
�q
�r r
� SyntaxErrorza+8=9�-> b = 2)r r r r� rM �r r
r r� r� s & r �test_pdbrc_basic� PdbTestCase.test_pdbrc_basic� st � �� � � " �
��
��� ! �
�� �,�,�V�U�%�UY�,�Z��� ��� ��/� �
�
�g�v�&� �
�
�j�&�)r c �� � [ O Q2 o[ O Q2 oU O UQUP Q5 v q4U O QU2 U O QU2 P! )z,Test that empty lines in .pdbrc are ignored.z?
a = 1
b = 2
c = 3
z
n
r� r� zb = 2zc = 3)r r r rM r� r� s & r �test_pdbrc_empty_line�!PdbTestCase.test_pdbrc_empty_line� sh � � � � � " �
�� ��� ! �
��
�,�,�V�U�%�UY�,�Z��� �
�
�g�v�&� ����&�)r c � � [ O Q 2 o[ O Q2 oU O UQUP Q5 v q4U O QU2 P! )��
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
r� r� z
a.attr = 1�r r r rM r� s & r �test_pdbrc_alias� PdbTestCase.test_pdbrc_alias� sV � �� � � " �
�� ��� ! �
�� �,�,�V�U�%�UY�,�Z��� �
�
�l�F�+r c � � [ O Q 2 o[ O Q2 oU O UQUP Q5 v q4U O QU2 P! )r� z
b 5;;c;;n
r� r� r� r� r� s & r �test_pdbrc_semicolon� PdbTestCase.test_pdbrc_semicolon� sV � �� � � " �
�� ��� ! �
�� �,�,�V�U�%�UY�,�Z��� �
�
�j�&�)r c � � [ O Q 2 o[ O Q2 oU O UQUP Q5 v q4U O QU2 P! )r� zK
b 6
commands 1 ;; p a;; end
c
r� r� z<__main__.A object atr� r� s & r �test_pdbrc_commands� PdbTestCase.test_pdbrc_commands� sW � �� � � " �
�� ��� ! �
�� �,�,�V�U�%�UY�,�Z��� �
�
�-�v�6r c � � [ O Q 2 oU O UQQP Q5 v q#U O QU2 P! )z$
print('hello')
r� �invalidr� z(NameError: name 'invalid' is not definedr� )r r
r� r� s & r �test_readrc_kwarg� PdbTestCase.test_readrc_kwarg� sB � �� � � " �
�� �,�,�V�U�)�Y]�,�^��� �
�
�@�&�Ir c
�� � [ O 2 9^tt^ 2 oUO Q 2 [ O 2 9^tt^ 2 o[ Q2 9^tt^ 2 [
O O UQ2 oU[
O O m [ UQ2 9^tt^ 2 oUO Q2 PPP2 U O [ O 2 O ] * Q2 PPP2 PPP2 PPP2 P! ) % f h K`9 h ) % f h K59 h ) % f h K@9 h ) % f h P! 9 h�r zos.path.expanduserr r r� )r r r �temp_dirr
r� r. r1 �
expanduser� return_valuer r r� r� r� �rcLines)r r� r� �rc_pathr s & r �test_readrc_homedir� PdbTestCase.test_readrc_homedir� s� � �
�
*�
*�
,�
,�� �I�I�f� ��#�#�%�%��5�9M�3N�3N� �'�'�,�,�x��:��29����"�"�/��'�3�'�'�1��G�G�I�&� (�� � �����!2�!2�1�!5�y�A� 4O�%� -�
,�
(�'�� 4O�3N��%�%�� -�
,�
,�sl �/E�E �"AD3
�6D �>D3
�E �E� D0�)D0�+D3
�3E�<E�>E �E
�E
�E�E* �"E* c � � [ O 2 9^tt^ 2 o[ O O UQ 2 o[ UQ2 9^tt^ 2 oUO
Q2 PPP2 U O [ O 2 O P * Q2 PPP2 P! ) % f h KP9 h ) % f h P! 9 h)r r r� ) r �temp_cwdr� r. r1 r r r� r� r� r� )r �cwdr� r s & r �test_readrc_current_dir�#PdbTestCase.test_readrc_current_dir s� � �
�
�
�
!�
!�S��g�g�l�l�3��1�G��g�s�#�#�q���� �"� $� � � �S�W�W�Y� .� .�r� 2�I� >� "�
!�#�#�� "�
!�
!�s/ �5C�B. �&>C�.B>
�7B>
�9C�C �
C c
�� � [ O 2 9^tt^ 2 oUO Q 2 [ O 2 9^tt^ 2 o[ Q2 9^tt^ 2 [
O O UQ2 oU[
O O m [ UQ2 9^tt^ 2 oUO Q2 PPP2 U O [ O 2 O Q,2 PPP2 PPP2 PPP2 P! ) % f h KZ9 h ) % f h K59 h ) % f h K@9 h ) % f h P! 9 hr� )r r r r� r
r� r. r1 r� r� r r r� r� r� r� )r r� r� r� r s & r �test_readrc_cwd_is_home�#PdbTestCase.test_readrc_cwd_is_home s� � �
�
*�
*�
,�
,�� �I�I�f� ��#�#�%�%��e�4H�.I�.I� �'�'�,�,�s�H�5��29����"�"�/��'�3�'�'�1��G�G�I�&� (�� � �����!2�!2�Y�K�@� /J�%� -�
,�
(�'�� /J�.I��%�%�� -�
,�
,�sl �/E�E �"AD-
�6D�8D-
� E �E�D*�#D*�%D-
�-D=�6D=�8E � E
� E
� E�E$ � E$ c � � [ 2 oQ o[ 2 9^tt^ 2 oUO [ QU2 2 UO [ O [
O Q2 2 P[
O m [
O UQ5 PPP2 U O UO 2 UQ* 2 P! ) % f h K99 h)z"Nobody expects... blah, blah, blahz
sys.stdout� set_trace)�headerr� ) r r �
enter_contextr
�objectr� r� �_last_pdb_instancer� r� rN )r r� r� � resourcess & r � test_header�PdbTestCase.test_header s� � ����5��
�[�[�I� � #� #�E�,��$?� @� � #� #�E�L�L����+�$F� G� *.�C�G�G� &� �M�M�� (� �
���� � �*�F�T�M�:� �[�s �A<C
�
C �C c �� � Q oQoU O V2 v q4S O [ 9PI c* Q UO 2 2 D % f J P L P
L Q UO 2 2 2 U2 P! )zprint("SUCCESS")�/
continue
quit
c 3 �8 � S F � D oQ U7 w � J
P! 3h��SUCCESSr1 r� s & r r� �.PdbTestCase.test_run_module.<locals>.<genexpr>' � ��4G� � �4G�q�I��N�4G�r� �r r� r� r� r� s & r �test_run_module�PdbTestCase.test_run_module s] � �'�� �� �,�,�V�>��� �����H�F�4E�4E�4G�H����H�F�4E�4E�4G�H�H�&�Qr c �� � Q oQoU O V2 v q4S O [ 9PI c* Q UO 2 2 D % f J P L P
L Q UO 2 2 2 U2 P! )zQ
if __name__ == '__main__':
print("SUCCESS")
r� c 3 �8 � S F � D oQ U7 w � J
P! 3hr r1 r� s & r r� �9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>3 r r� r r� s & r �test_module_is_run_as_main�&PdbTestCase.test_module_is_run_as_main) s_ � � �� �� �,�,�V�>��� �����H�F�4E�4E�4G�H����H�F�4E�4E�4G�H�H�&�Qr c �( � Q oU O QQ,U]Q5 U O , QNU2 v q#U O QU2 U O , QNU2 v qBU O QU2 U O , QNU2 v qBU O QU2 P! ) z
continue
�calendarr� �r� zunrecognized arguments: -p�December)r� r z-p�1)r� r r )r� r z--type�text)r� rM )r r� rb r� r� s & r �test_run_module_with_args�%PdbTestCase.test_run_module_with_args5 s� � � ��
�
�
�z�4�(�(��
�J��M�M�"?��J� �� �
�
�2�F�;��M�M�"9�8�D� �� �
�
�j�&�)��M�M�"F��Q� �� �
�
�j�&�)r c �b � Q oQoU O VQQ,Q5 v q4U O QU2 P! )z@
import sys
print(sys.argv[1:])
r� z--barr< )r z['--bar', 'foo']r` r� s & r �test_run_script_with_args�%PdbTestCase.test_run_script_with_argsD s> � � �� ��
�,�,�V�G�UZ�K[�,�\��� �
�
�(�&�1r c � � Q oQoU O V2 v q4S O [ 9PI c* Q UO 2 2 D % f J P L P
L Q UO 2 2 2 U2 S O [ 9PI c* Q UO 2 2 D % c J P
L P L Q UO 2 2 2 U2 P! )z{
if __name__ == '__main__':
pass
print("SUCCESS")
pass
z*
b 3
quit
c 3 �8 � S F � D oQ U7 w � J
P! 3h)zBreakpoint 1 atr1 r� s & r r� �.PdbTestCase.test_breakpoint.<locals>.<genexpr>] � ��<O� � �<O�q� -�� 2�<O�r� c 3 �8 � S F � D oQ U7 w � J
P! 3hr r1 r� s & r r� r ^ s ��8K� � �8K�1�I�Q� .�8K�r� )r r� r� r� �allr� s & r �test_breakpoint�PdbTestCase.test_breakpointQ s� � � �� �� �,�,�V�>��� �����P�F�<M�<M�<O�P����P�F�<M�<M�<O�P�P�RX�Y� �����L��8I�8I�8K�L����L��8I�8I�8K�L�L�f�Ur c � � Q oU O QQ,U2 v q#U O [ O UO QP2 2 P! )z(
c
quit
r� r� �
)r� rM r� �_usage�replace)r r� r� r� s & r �test_run_pdb_with_pdb�!PdbTestCase.test_run_pdb_with_pdb` sB � � �� � � ��e�}�h�?��� �
�
� �J�J� �N�N�4�� $�
r c �l � Q o[ O U2 UQ* o[ O U2 [ UQ2 9^tt^ 2 PPP2 U O [ O U2 U O
QU,P]Q5 v q4U O QU2 P! ) % f h K\9 h)r r r r� r z-ImportError: No module named t_main.__main__;)r r� r� r r r� r� rM )r r r r� r� s & r �test_module_without_a_main�&PdbTestCase.test_module_without_a_maink s� � � � �����%� �.�0� �
���� �
�)�S�
!�
!� � "� ��� �(�(�+�6� � � �
�;� ��� '�
���
�
�
�E�v�N�
"�
!�s �
B#�#B3 �,B3 c � � Q oQo[ O U2 UQ* U* o[ O U2 [ UQ* Q2 9^tt^ 2 PPP2 U O [ O U2 U O
QUO QQ2 ,P]Q5 v qEU O QU2 P! ) % f h Kl9 h) �t_pkgr �/r r r� �.r z;'t_pkg.t_main' is a package and cannot be directly executed) r r� r� �makedirsr r� r� r# rM )r �pkg_namer �modpathr� r� s & r �test_package_without_a_main�'PdbTestCase.test_package_without_a_mainx s� � ��� � �����"��S�.�;�.��
� � �G� �
�'�N�*�C�
0�
0� � 1� ��� �(�(�(�3� � � �
�7�?�?�3��,� -�r�q� '�
���
�
�
� I� � �
1�
0�s � C�C � C c � � U O Q [ O ,P]Q5 v qU O Q[ O 0U2 P! )r� r z ImportError: No module named )r� r r� rM �r r� r� s & r �test_nonexistent_module�#PdbTestCase.test_nonexistent_module� sA � � � � ��i�.>�.>�'?��YZ� �[��� �
�
�5�i�6F�6F�5G�H�&�Qr c �� � [ O 2 9^tt^ 2 oU O U,P]Q5 v q#U O QU Q0U2 PPP2 P! ) % f h P! 9 h)� r zError: z is a directory)r r� r� rM )r r� r� r� s & r �test_dir_as_script� PdbTestCase.test_dir_as_script� sQ � �
�
�
�
!�
!�X� !�]�]�H�:�r�q�]� Q�N�F� �M�M�G�H�:�_�=�v� F� "�
!�
!�
!�s �.A�A( � A( c � � U O Q ,P]Q5 v qU O QUO Q2 ]* 2 U O , QNP]Q5 v qU O QUO Q2 ]* 2 P! )�-cr z8pdb: error: argument -c/--command: expected one argumentr� z*pdb: error: unrecognized arguments: --spam)z--spamr� r� )r� rM �splitr3 s & r � test_invalid_cmd_line_options�)PdbTestCase.test_invalid_cmd_line_options� ss � � � � ��v�r�q� �I��� �
�
�P�SY�S_�S_�`d�Se�fg�Sh�i� � � �'>��XY� �Z��� �
�
�B�V�\�\�RV�EW�XY�EZ�[r c �� � Q oQoU O V2 v q4S O [ 9PI c* Q UO 2 2 D % f J P L P
L Q UO 2 2 2 U2 P! )zY
#This is a comment, on line 2
print("SUCCESS")
z
quit
c 3 �8 � S F � D oQ U7 w � J
P! 3h)z__main__.py(4)<module>()r1 r� s & r r� �=PdbTestCase.test_blocks_at_first_code_line.<locals>.<genexpr>� s ��*=�� �*=�Q� 7� � !�*=�r� r r� s & r � test_blocks_at_first_code_line�*PdbTestCase.test_blocks_at_first_code_line� so � � ��
�� �,�,�V�>��� ����� ?�*0�*;�*;�*=� ?���� ?�*0�*;�*;�*=� ?� ?�@F� Hr c �~ � Q oQoU O V2 v q4U O QU2 U O QU2 P! )�$
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 editedr` r� s & r �"test_file_modified_after_execution�.PdbTestCase.test_file_modified_after_execution� s@ � � ��
�� �,�,�V�>��� �
�
�j�&�)� �
�
�l�F�+r c �~ � Q oQoU O V2 v q4U O QU2 U O QU2 P! )rE z�
filename = $_frame.f_code.co_filename
f = open(filename, "w")
f.write("print('goodbye')")
import time; time.sleep(1)
f.close()
restart
rF rG )r r� r� s & r �,test_file_modified_and_immediately_restarted�8PdbTestCase.test_file_modified_and_immediately_restarted� sD � � ��
�� �,�,�V�>��� ����V�,� ��� �v�.r c �h � Q oQoQo[ UQ2 9^tt^ 2 oUO [ O U2 2 PPP2 U O [
O U2 U O [
O Q2 [ O U,o[ O U[ O [ O [ O - [ O AQQ-AQ5 9^tt^ 2 oUO [ O# U2 2 v qxPPP2 W9% c [$ O' U2 oU O) WO* ] 2 U O- QU2 U O- Q U2 P! ) % f h CKT9 h ) % f h K�9 h)
z�
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
r r r� r� r� r� rF rG )r r r r r� r r� r� r r� r� r� r� r� r� r� r� r� r� r� r� r� rM ) r r
r� r r r� r� r� rb s & r �:test_file_modified_after_execution_with_multiple_instances�FPdbTestCase.test_file_modified_after_execution_with_multiple_instances� s9 � � �� ��
��
�(�C�
�
�A�
�G�G�H�O�O�F�+� ,� !� ��� �(�(�(�3� ��� �(�(�-�8��~�~�x�(��
�
�
��!��� �o�o�!���A����A�%7��A�
�
� � �(�(����H�)=�>�I�F�
� �0�0�E�L�L�� 0�� ���� � �!�,� �
�
�j�&�)� �
�
�l�F�+�# !�
�
��
�
�s# �&F
�='F!�
F �F �!F1 �*F1 c � � Q oQoU O V2 v q4U O QU2 U O QU2 U O QU2 P! )z�
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
�hello�worldrF r� r� s & r �/test_file_modified_after_execution_with_restart�;PdbTestCase.test_file_modified_after_execution_with_restart� sR � � �� �� �,�,�V�>��� �
�
�g�v�&� �
�
�g�v�&�
����V�,r c �Z � Q oQoU O V2 v q4U O QU2 P! )zZ
def foo():
raise ValueError("foo")
foo()
zX
continue
restart
continue
quit
�
Restartingr` r� s & r �test_post_mortem_restart�$PdbTestCase.test_post_mortem_restart
s2 � � �� �� �,�,�V�>��� �
�
�l�F�+r c �� � Q U m [ O U O 2 U O Q* oU O Q* oU O Q* oU O [ O U O 2 [ O
U O 2 [
UQ2 9^tt^ 2 oUO [ O Q2 2 PPP2 [
UQ2 9^tt^ 2 oUO [ O Q2 2 PPP2 [
UQ2 9^tt^ 2 oUO [ O Q2 2 PPP2 QoU O Q U O ,U2 v qgS O [ 9PI c* Q
UO 2 2 D % f J P L P
L Q
UO 2 2 2 U2 S O [ 9PI c* Q UO 2 2 D % f J P L P
L Q UO 2 2 2 2 S O [ 9PI c6 Q UO 2 2 D % f J P 2 P! P
2 P! Q UO 2 2 2 2 P! ) % f h CK�9 h ) % f h CK�9 h ) % f h CK�9 h)
r r r �
/module.pyr �6
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
r� c 3 �8 � S F � D oQ U7 w � J
P! 3h�zVAR from moduler1 r� s & r r� �4PdbTestCase.test_relative_imports.<locals>.<genexpr>? r r� c 3 �8 � S F � D oQ U7 w � J
P! 3h)z VAR from topr1 r� s & r r� r^ @ s ��9L� � �9L�A�N�a� /�9L�r� c 3 �8 � S F � D oQ U7 w � J
P! 3h)z
second varr1 r� s & r r� r^ A s ��7J� � �7J�!�L�A� -�7J�r� �r r r� r� r� r r r r r r� r� r� r� �r r r � module_filer r� r� rb s & r �test_relative_imports�!PdbTestCase.test_relative_imports s � �#�������)�)�*��$�$�~�5� ��$�$�~�5� ��&�&� �5� � ��� �(�(�$�*:�*:�;�
����!�!�"�
�)�S�
!�
!�Q�
�G�G�H�O�O� %� �
� "� �)�S�
!�
!�Q�
�G�G�H�O�O� %� �
� "� �+�s�
#�
#�q�
�G�G�H�O�O� %� �
� $�
�� �M�M�4��)9�)9�":�H�E� �� �����P�F�<M�<M�<O�P����P�F�<M�<M�<O�P�P�RX�Y� �����M��9J�9J�9L�M����M��9J�9J�9L�M�M�N� �����K�v�7H�7H�7J�K���L��L��K�v�7H�7H�7J�K�K�L�7 "�
!�
!�� "�
!�
!�� $�
#�
#�s6 � &J=�&K�&K%�=K �K �K" �K" �%K6 �.K6 c �l � Q U m [ O U O 2 U O Q* oU O Q* oU O Q* oU O [ O U O 2 [ O
U O 2 [
UQ2 9^tt^ 2 oUO [ O Q2 2 PPP2 [
UQ2 9^tt^ 2 oUO [ O Q2 2 PPP2 [
UQ2 9^tt^ 2 oUO [ O Q2 2 PPP2 QoU O Q U O Q
* ,U2 v qgS O [ 9PI c* Q UO 2 2 D % f J P L P
L Q UO 2 2 2 U2 P! ) % f h CK 9 h ) % f h K�9 h ) % f h K�9 h) r z /runme.pyr rZ r r[ zl
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
r� z.runmec 3 �8 � S F � D oQ U7 w � J
P! 3hr] r1 r� s & r r� �DPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr>` r r� ra rb s & r �%test_relative_imports_on_plain_module�1PdbTestCase.test_relative_imports_on_plain_moduleC s� � �#�������)�)�*��$�$�{�2� ��$�$�~�5� ��&�&� �5� � ��� �(�(�$�*:�*:�;�
����!�!�"�
�)�S�
!�
!�Q�
�G�G�H�O�O� %� �
� "� �)�S�
!�
!�Q�
�G�G�H�O�O� %� �
� "�
�+�s�
#�
#�q�
�G�G�H�O�O� %� �
� $� �� �M�M�4��)9�)9�H�)D�"E�x�P� �� �����P�F�<M�<M�<O�P����P�F�<M�<M�<O�P�P�RX�Y�) "�
!�
!�� "�
!��
$�
#�s6 � &G<�&H�&H#�<H
�H
�H �H �#H3 �,H3 c � � Q O , QN2 oU O QUQ * 2 v q#U O UO 2 Q* , QN2 P! )r� �pass�r� NN)zprint(]z debug print(zdebug doesnotexist�c)
r� zU(Pdb) *** SyntaxError: closing parenthesis ']' does not match opening parenthesis '('�!(Pdb) ENTERING RECURSIVE DEBUGGERz%*** SyntaxError: '(' was never closed�LEAVING RECURSIVE DEBUGGERro z> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedrp �(Pdb) �r1 r r� r� )r r� r� rb s & r �test_errors_in_command�"PdbTestCase.test_errors_in_commandb sR � ��9�9�
� �� �'�'���4��@� �� ����*�*�,�R�0� 3
� r c �: ` � U 1Q koU QQ2 U QQ2 P! )z.do_run handles exceptions from parsing its argc �� :� Q O QU 0Q,2 oRO QUQ * 2 v q4RO UO 2 Q* QQU QU 0Q,2 P! ) r� zrun �qrl rm r� z(Pdb) *** Cannot run z: rq rr )�bad_arg�msgr� r� rb r s && �r �check�*PdbTestCase.test_issue34266.<locals>.check} sv �� ��y�y��w�i� ��"� �H� �+�+�F�H�t�O�D�I�F� � � �V� .� .� 0�� 4��'��y��3�%�8��7�
r �\zNo escaped character�"zNo closing quotationr1 )r rz s f r �test_issue34266�PdbTestCase.test_issue34266{ s �� �
� �d�*�+�
�c�)�*r c � � [ O Q2 oQo[ O 2 9^tt^ 2 oQ[ O
O
U2 0oU O V2 v qVU O UO Q2 ]* O Q2 U2 PPP2 P! ) % f h P! 9 h)zkWhen running `python foo.py` sys.path[0] is an absolute path. `python -m pdb foo.py` should behave the same�Q
import sys
print('sys.path[0] is', sys.path[0])
�c
q�(Pdb) sys.path[0] is r� r! ) r r r r� r� r. �realpathr r� r< �rstrip)r r
r� r� r! r� r� s & r �test_issue42384�PdbTestCase.test_issue42384� s� � �� � � " �
�� ��
�
�
�
!�
!�S�.�r�w�w�/?�/?��/D�.E�F�H� !� 0� 0�� B�N�F� � � �V�\�\�$� /�� 2� 9� 9�$� ?�� J� "�
!�
!�
!�s �A-B.�.B? �7B? c � � [ O Q2 oQo[ O 2 9^tt^ 2 o[ O
O
U2 o[ O
O UQ2 o[ O
O UQ2 oQU 0o[ O U2 [ [ O
O UQ2 Q2 9^tt^ 2 oUO U2 PPP2 [ O U2 [ O [ O
O UQ2 [ O
O UQ2 2 U O [ O
O QQ2 ,U2 v q�U O UO Q2 ]* O Q 2 U2 PPP2 P! ) % f h K�9 h ) % f h P! 9 h)
ziWhen running `python foo.py` sys.path[0] resolves symlinks. `python -m pdb foo.py` should behave the samer� r� �dir_one�dir_twor� �foo.pyr r� r! )r r r r� r� r. r� r1 r r r �symlinkr� r� r< r� )
r r
r� r� r� r� r! r r� r� s
& r �test_issue42384_symlink�#PdbTestCase.test_issue42384_symlink� sT � � � � � " �
�� ��
�
�
�
!�
!�S��'�'�"�"�3�'�C��g�g�l�l�3� �2�G��g�g�l�l�3� �2�G�.�w�i�8�H� �H�H�W� ��b�g�g�l�l�7�H�5�s�;�;�q������ <� �H�H�W� � �J�J�r�w�w�|�|�G�X�6���� � �W�h�8W� X� !�]�]�B�G�G�L�L��H�,M�+N�PX� Y�N�F� � � �V�\�\�$� /�� 2� 9� 9�$� ?�� J� "�
!� <�;�� "�
!�
!�s1 �B-G.�$G �6CG.�G+
�$G+
�&G.�.G? �7G? c �@ � [ O Q2 oQo[ O 2 9^tt^ 2 oU O VQQ-Q5 v qEQ[
O O U2 0oU O Vd2 PPP2 P! ) % f h P! 9 h)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 )r� zsys.path[0] is ) r r r r� r r� r. r� r� )r r
r� r� r� rb �
unexpecteds & r �test_safe_path�PdbTestCase.test_safe_path� s� � � � � � " �
��
�� �
�
�
!�
!�S� �+�+�F�IY�[^�H_�+�`�I�F�*�2�7�7�+;�+;�C�+@�*A�B�J� � � �Z� 0� "�
!�
!�
!�s �A B � B �B c �^ � [ O 2 9^tt^ 2 o[ Q Q2 9^tt^ 2 o[ O Q2 oUO U2 PPP2 [ O O UQ2 o[ O U2 [ O [ O O UQ2 2 [ O O UQ 2 o[ UQ2 9^tt^ 2 oUO Q2 PPP2 U O Q ,Q2 v qgQoU O UO Q2 ]* O Q2 U2 PPP2 P! ) % f h CK!9 h ) % f h K|9 h ) % f h P! 9 h) r� r z�
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� r! )r r� r r r r r� r. r1 r r� r� r< r� ) r r� r �sr� �
wrong_filer� r� r! s & r �test_issue42383�PdbTestCase.test_issue42383� s$ � �
�
�
�
!�
!�S��h��$�$�� �O�O� %� �� ����
� %� �W�W�\�\�#�x�0�F� �H�H�V� � �H�H�R�W�W�\�\�&�(�3� 4���� � �f�h�7�J��j�#�&�&�!����>�?� '� "�]�]�H�:�y� A�N�F�<�H� � � �V�\�\�$� /�� 2� 9� 9�$� ?�� J�) "�
!�$�$�$�� '�&�� "�
!�
!�sN �F�(E4 � B&F�F �AF�4F
�=F
�? F�F
�F
�F�F, �$F, c � � Q o[ O Q2 oU O V2 v q4U O U2 P! )z� def func():
def inner(v): pass
inner(
42
)
func()
zj
break func
continue
next
next
jump 2
)r r r � assertFalser� s & r �test_gh_94215_crash� PdbTestCase.test_gh_94215_crash� s@ � � �� �?�?� $ �
�� �,�,�V�>��� ���� r c � � Q oQoQoQo[ QQ2 9^tt^ 2 oUO [ O U2 2 PPP2 [ QQ2 9^tt^ 2 oUO [ O U2 2 PPP2 U O [
O Q2 U O [
O Q2 V41F DQ oU O Q,U2 v qxU O QUQ2 U O Q UQ
2 U O Q UQ 2 JS P! ) % f h K�9 h ) % f h K�9 h)
za
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, "<frozen gh93696>", "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()
zz
break 20
continue
step
break 4
list
quit
z~
break 20
continue
step
break 4
longlist
quit
z
gh93696.pyr zgh93696_host.pyz"x = "Sentinel string for gh-93696"z Sentinel statement not foundz4 Bzbreakpoint not foundz-> def func():zstack entry not found) r r r r r� r r� r� rM ) r �
frozen_src� host_program�
commands_list�commands_longlistr r� r� rb s & r �test_gh_93696_frozen_list�%PdbTestCase.test_gh_93696_frozen_list� s
� � �
�
� �* �
� �� �,��
$�
$��
�G�G�H�O�O�J�/� 0� %� �#�S�
)�
)�Q�
�G�G�H�O�O�L�1� 2� *�
��� �(�(�,�7� ��� �(�(�*;�<� '�:�H� �
�
�'8�&9�8�D�I�F� �M�M�>��Hf� g� �M�M�%��)?� @� �M�M�*�F�4K� L� ;� %�
$�� *�
)�s# �&D)� &D<�)D9 �2D9 �<E �E c � � PoQoU O V2 v q4U O QU2 U O V2 v q4U O QU2 P! )r7 r� z
main.py(0)z__main__.py(0))r rM r ra s & r �test_empty_file�PdbTestCase.test_empty_file* sO � ����� �'�'��9� �� �
�
�l�F�+��'�'��9� �� �
�
�&��/r c �X � [ O O [ O O [ 2 Q 2 o[ O
U2 F DL oUO
Q2 % f J U O [ O O V2 ,Q2 JN P! )�encoded_modulesz.pyrw )r� r. r1 �dirnamern �listdir�endswithr� )r �
script_dirr s & r �test_non_utf8_encoding�"PdbTestCase.test_non_utf8_encoding4 sf � ��W�W�\�\�"�'�'�/�/�(�";�=N�O�
��
�
�:�.�H�� � ��'�'��
�
�r�w�w�|�|�J� A� B�C�H� /r c �F � [ O 2 9^tt^ 2 o[ O [ O O UQ 2 2 [ O Q2 o[ [ O O UQ Q2 Q2 9^tt^ 2 oUO U2 PPP2 [ O [ O O UQ 2 [ O O UQ2 2 U O [ O O UQ2 ,QO , QN2 2 v qEU O QU2 U O QU2 PPP2 P! ) % f h K�9 h ) % f h P! 9 h) �sourcezg
def f(x):
return x + 1
f(21 + 21)
z __main__.pyr z
zipapp.pyzr� �42z return x + 1)zb frn zp xrw )r r� r� r r. r1 r r r r �zipapp�create_archiver� rM )r r� r
r r� rb s & r � test_zipapp�PdbTestCase.test_zipapp: s � �
�
�
�
!�
!�X� �H�H�R�W�W�\�\�(�H�5� 6� �_�_���F� �b�g�g�l�l�8�X�}�E�s�K�K�q������ L� � !� !�"�'�'�,�,�x��"B�"$�'�'�,�,�x� �"F�
H� �
�
�r�w�w�|�|�H�l�'K�&L�d�i�i� Y� O� �I�F�
�M�M�$�� '� �M�M�.�&� 1�) "�
!� L�K�� "�
!�
!�s1 �A>F� E< �/CF�<F
�F
�F�F �F c �� � [ O 2 9^tt^ 2 o[ O [ O O UQ 2 2 [ O Q2 o[ O Q[ [ O O UQ2 2 Q02 o[ O [ O O UQ2 Q2 9^tt^ 2 oUO QU2 PPP2 [ [ O O UQ2 Q2 9^tt^ 2 oUO U2 PPP2 U O [ O O UQ2 ,QO , Q
N2 2 v qgU O Q U2 PPP2 P! ) % f h K�9 h ) % f h K�9 h ) % f h P! 9 h) r� zE
def bar():
pass
z0
import sys; sys.path.insert(0, z
zipmodule.zipzG)
import foo
foo.bar()
r r� z script.pyr� z break in bar)�nr� z b foo.barrn z&p f"break in {$_frame.f_code.co_name}"rw )r r� r� r r. r1 r r �repr�zipfile�ZipFile�writestrr r r� rM )r r� � zipmoduler
�zfr r� rb s & r �test_zipimport�PdbTestCase.test_zipimportQ sP � �
�
�
�
!�
!�X� �H�H�R�W�W�\�\�(�H�5� 6� �����I� �_�_�0�04�R�W�W�\�\�(�O�5\�0]�/^� _���F� � � ���� � �h��!H�#�N�N�RT�� � �H�i�0� O��b�g�g�l�l�8�[�9�3�?�?�1������ @� �
�
�r�w�w�|�|�H�k�'J�&K�T�Y�Y� X� N� �I�F�
�M�M�.�&� 1�; "�
!� O�N��?�?��% "�
!�
!�sO �C G�(F/ �;:G�5G �A G�/F?
�8F?
�:G�G
� G
�
G�G& � G& c � � Q o[ [ O QQQ5 9^tt^ 2 oUO U2 PPP2 U O Q[ O Q,Q2 v q4U O QU2 U O QQ Q[ O QQ
,Q 2 v q4U O Q U2 U O Q,Q ]Q
5 v q5U O QU2 U O QQ[ O ,Q ]Q
5 v q5U O QU2 U O [ O QQ,Q2 v q4U O QU2 [ O 2 9^tt^ 2 [ QQQQ5 9^tt^ 2 oUO U2 PPP2 U O , QNQ2 v q4U O QU2 PPP2 P! ) % f h CK�9 h ) % f h KV9 h ) % f h P! 9 h)z*import sys; print(f'ARGS: {sys.argv[1:]}')r r� )�encoding�--z-foor� zARGS: ['-foo']r; r^ r< rw zARGS: ['-c', 'foo']r z missing script or module to runz-xzunrecognized arguments: -xr� zARGS: ['--', 'arg']zmymod.py)r� �mymodr� r� )r r r� r r� rM r� )r r
r r� rb r� s & r � test_end_of_options_separator�)PdbTestCase.test_end_of_options_separatorq s� � �=��
�)�"�"�C�'�
:�
:�a�
�G�G�F�O� ;��M�M�4��)9�)9�6�"B�F�K� �� �
�
�&��/��M�M�4��T�9�;K�;K�T�SX�"Y�[^�_� �� �
�
�+�V�4� � � ��v�s�� �J��� �
�
�7��@� � � ��d�I�4D�4D�'E�s�`a� �b��� �
�
�2�F�;��M�M�9�#3�#3�T�5�"A�6�J� �� �
�
�+�V�4�
�
�
�
!�
!��j�#��8�8�A������ 9� �
�
�&B�F�K�I�F� �M�M�/�� 8� "�
!� ;�
:�
:�� 9�8�� "�
!�
!�sA �G �)G3� G �0G3� G �G � G0
�)G0
�+G3�3H �<H zCoroutine tests are skippedc �~ � Q oQoU O V2 v q4U O UQ2 U O QU2 P! )zy
import asyncio
async def main():
pass
asyncio.run(main())
zF
break main
continue
quit
z Breakpoint 1 at .*main\.py:5rl )r r� rM r� s & r �test_async_break� PdbTestCase.test_async_break� sC � � �� ��
�,�,�V�>��� ����!@�A� �
�
�f�f�%r c �Z � Q oQoU O V2 v q4U O QU2 P! )z�
def foo():
pass
class C:
def foo(self):
pass
z2
break C.foo
quit
z.The specified object 'C.foo' is not a functionr` r� s & r �test_issue_59000� PdbTestCase.test_issue_59000� s3 � � �� �� �,�,�V�>��� �
�
�F��Or c �z � [ O [ O Q Q-2 9^tt^ 2 U O [
O 2 2 PPP2 [ O [ O - P Q5 9^tt^ 2 [ O Q2 oP Um [ O QQU-2 9^tt^ 2 U O [
O 2 2 PPP2 PPP2 P! ) % f h K�9 h ) % f h K-9 h ) % f h P! 9 h)�PYTHON_BASIC_REPLr )�clearz _pyrepl.mainz sys.modules) r
�dictr� r� r� r� �_pyrepl_available�types�
ModuleType�CAN_USE_PYREPLr� )r �mods & r �test_pyrepl_available�!PdbTestCase.test_pyrepl_available� s� � �
�Z�Z��
�
�%8�#�$>�
?�
?� � � �S� 2� 2� 4� 5� @� �Z�Z��
�
�B�d�
3�
3��"�"�>�2�C�!%�C� ����M�N�C�+@�A�A����� 5� 5� 7�8� B� 4�
3� @�
?�� B�A�� 4�
3�
3�sA �%D�
?D)� %D �1D)�D � D �D&
� D&
�!D)�)D: �2D: )r �r N)r NNNF)Ur' r( r) r* r� �unittest�skipIfr �flags� safe_pathr� r r r" r' r% r& r= rC rQ rU r[ rc r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r$ r' r0 r4 r8 r= rB rH rK rN rS rW rd ri rs r~ r� r �skip_unless_symlinkr� r� r� r� r� r� r� r� r� r� �SKIP_CORO_TESTSr� r� r� r, r- r. s @r r� r� �
s� �� � �+� �_�_�S�Y�Y�(�(�>�@� �@� �4 �2 A� F�9�
� �5�
� <�
�"
�
&�'1�R=�2
M� V�*";�HG�8 G�< '�B� F� )�< +� *�"*�$,�$*� 7�$J�B�?�A� ;� R�
R�
*� 2�
V�
� O�� R�
G�
\� H�,�&/�&!,�F -�>,�"#M�J Z�> �2+�
K� �"�"�K� #�K�01�"K�.!�&:M�x0�I� 2�. 2�@9�* �_�_�_�&C�D�&� E�&�$P� 9� 9r r� c �@ ` � \ sQ sQs n Q sQ sQ sQ sQ sQs U s
P! )�ChecklineTestsi� c �2 � [ O 2 P! r )� linecache�
clearcacher s &r �setUp�ChecklineTests.setUp� s � �� � � r c �P � [ O [ O 2 P! r r� r s &r r� �ChecklineTests.tearDown� r� r c �0 � [ [ O Q 2 9^tt^ 2 oUO Q2 PPP2 [ O
2 oU O
UO [ O ]2 ]2 P! ) % f h KW9 h�r z
print(123))r r r� r r� r� r� � checkline�r r �dbs & r � test_checkline_before_debugging�.ChecklineTests.test_checkline_before_debugging� s] � �
�)�"�"�C�
(�
(�A�
�G�G�L� !� )�
�W�W�Y�� ���� � �i�&6�&6��:�A�>� )�
(�s �B�B �B c �P � [ [ O Q 2 9^tt^ 2 oUO Q2 PPP2 [ O
2 oUO
2 U O UO [ O ]2 ]2 P! ) % f h Kg9 hr� ) r r r� r r� r� �resetr� r� r� s & r �test_checkline_after_reset�)ChecklineTests.test_checkline_after_reset� sf � �
�)�"�"�C�
(�
(�A�
�G�G�L� !� )�
�W�W�Y��
���
� ���� � �i�&6�&6��:�A�>� )�
(�s �B�B% � B% c
�0 � [ O Q 2 o[ [ O Q2 9^tt^ 2 oUO U2 PPP2 [
UO 2 2 ]* o[ [ 2 2 9^tt^ 2 [ O 2 o[ U2 F D2 oU O UO [ O U2 2 J4 PPP2 P! ) % f h K�9 h ) % f h P! 9 h)z\
# Comment
""" docstring """
''' docstring '''
r )r r r r r� r �lenr� r r r� r� �ranger� r� )r r� r � num_linesr� �linenos & r � test_checkline_is_not_executable�/ChecklineTests.test_checkline_is_not_executable� s� � � �O�O� �
�� �)�"�"�C�
(�
(�A�
�G�G�A�J� )��� � ��'�!�+� �
�X�Z�
(�
(�����B� � �*��� � �� � �i�.>�.>��!G�H� +� )�
(� )�
(�� )�
(�
(�s$ �C1�AD�1D �:D �D �
D r1 ) r' r( r) r* r� r� r� r� r� r, r- r. s @r r� r� � s% �� � � �+�?� ?�I� Ir r� c � ` � \ sQ sQs n \O
\O O Q2 Q
Q k2 s Q s
Q s Q s Q s
Q sQ sU sP! ) �
PdbTestInlinei� r� c � � U O [ O Q 2 Qo[ UQ2 9^tt^ 2 oUO [
O U2 2 PPP2 U O [ O U2 [
O U2 o[ O Q,oUd [ O U* oL[ O o[ O U[ O [ O [ O - UAQQ-AQ5 9^tt^ 2 o U O [ O# U2 2 v q�PPP2 [% W
[& 2 % c [& O) U
2 LS
o
[% W [& 2 % c [& O) U 2 LS o U O+ W O, UQU
QU 02 V�1! ) % f h CK�9 h ) % f h K�9 h)r� r r r� r� r� r� r� )r� r r� r r r r r� r r� r� r� r� r� r� r� r� r� r� r� r� r� r� ) r r
r� r� r� r r r� r� r� r� r� s &&&&& r � _run_script�PdbTestInline._run_script� sv � �
��� �(�(�-�8� ��
�(�C�
�
�A�
�G�G�H�O�O�F�+� ,� !� ��� �(�(�(�3��?�?�8�,���~�~�y�)�� � ��*�*�y�(�C��*�*�C�
�
�
��!��� �o�o�!���:��:� 0�'�:�
�
� � !� -� -�c�j�j��.B� C�N�F�
� *4�F�E�)B�)B�� � �f�%���)3�F�E�)B�)B�� � �f�%��� ��� �O�O� �.�v�h�j��� I�
�
�~� �5 !�
�
��
�
�s# �&G �-'G0� G- �%G- �0H �9H c � � Q oQoU O V]Q5 v q4U O QU2 U O QU2 U O QU2 U O UP2 U O UO Q2 ]2 P! )�4
x = 1
breakpoint()
z[
quit
n
p x + 1
quit
y
r �2� Quit anywayr� )r� rM r� r� r� r� s & r � test_quit�PdbTestInline.test_quit� s� � � ��
�� �)�)�&�PQ�)�R��� �
�
�c�6�"� �
�
�m�V�,�
����v�&� �����$� ���� � �m�4�a�8r c �� � QoQoU O V]Q5 v q4U O UP2 U O UO Q2 ]2 U O QU2 P! )z�
interact command will set sys.ps1 temporarily, we need to make sure
that it's restored and pdb does not believe it's in interactive mode
after interact is done.
r zM
interact
quit()
q
y
r r �BdbQuit)r� r� r� r� r� s & r �test_quit_after_interact�&PdbTestInline.test_quit_after_interact sc � � ��
�� �)�)�&�PQ�)�R��� �����$� ���� � �m�4�a�8� ����F�+r c � � [ O Q2 oQoU O V2 v q4U O QU2 P! )aQ GH-82897
Inline set_trace() should break unconditionally. This example is a
bit oversimplified, but as `pdb.set_trace()` uses the previous Pdb
instance, it's possible that we had a previous pdb instance with
skip values when we use `pdb.set_trace()` - it would be confusing
to users when such inline breakpoints won't break immediately.
z�
import pdb
def foo():
x = 40 + 2
pdb.Pdb(skip=['__main__']).set_trace()
foo()
z'
p x
c
r� )r r r� rM ra s & r �test_set_trace_with_skip�&PdbTestInline.test_set_trace_with_skip2 s@ � � � � � " �
�� �� �$�$�V�6� �� �
�
�d�F�#r c � � [ O Q2 oPoU O V2 v q4U O QU2 U O UP2 P! )a` GH-138860
Directly or indirectly importing readline might deadlock a subprocess
if it's launched with process_group=0 or preexec_fn=setpgrp
It's also a pattern that readline is never imported with just import pdb.
This test is to ensure that readline is not imported for import pdb.
It's possible that we have a good reason to do that in the future.
z�
import sys
import pdb
if "readline" in sys.modules:
print("readline imported")
zreadline imported)r r r� r� r� r� s & r �test_readline_not_imported�(PdbTestInline.test_readline_not_importedH sQ � � � � � " �
�� �� �)�)�&�;��� ���,�f�5� �����$r c � � [ O Q 2 oPoU O V2 v q4U O QU2 U O UP2 P! )z�
import pdb
import io
input_data = io.StringIO("p 40 + 2\nc\n")
pdb.Pdb(stdin=input_data).set_trace()
r� )r r r� rM r� r� s & r �test_alternate_stdin�"PdbTestInline.test_alternate_stdin^ sL � �� � � " �
�� �� �)�)�&�;��� �
�
�d�F�#� �����$r r1 r� )r' r( r) r* r� r� r r� r� r� r r r
r
r r, r- r. s @r r� r� � sP �� � �
�_�_�S�Y�Y�(�(�>�@� �@� �B9�4,�4$�,%�, %� %r r� c � ` � \ sQ sQs n Q sQ sQ sQ s\O \
O 2 % ( Q2 Q 2 s Qs
U sP! ) �PdbTestColorizeil c �J � [ O U m Q [ m P! )c � � P ! )Tr1 )�args�kwargss *,r �<lambda>�'PdbTestColorize.setUp.<locals>.<lambda>r s � �r )� _colorize� can_colorize�_original_can_colorizer s &r r� �PdbTestColorize.setUpn s � �&/�&<�&<��#� ">� � r c �2 � U O [ m P! r )r r r r s &r r� �PdbTestColorize.tearDownt s � �!%�!<�!<� � r c �L � [ O 2 o[ O UP Q5 oUO QQ,Q5 U O QUO
2 2 [ O 2 o[ O UP
Q5 oUO QQ,Q5 U O QUO
2 2 [ O 2 o[ O UQ5 oUO QQ,Q5 U O QUO
2 2 P! )T�r� �colorize�llrn �r� �rF )rH r r� r� r� rM rN r� �r r� rO s & r �test_code_display�!PdbTestColorize.test_code_displayw s� � ���� �� �G�G�6�D� 1�� � � �d�C�[� �)� �
�
�f�f�o�o� /�0���� �� �G�G�6�E� 2�� � � �d�C�[� �)� ����� � �!2�3���� �� �G�G�6� "�� � � �d�C�[� �)� ����� � �!2�3r c �� � [ O 2 o[ O UP Q5 oUO QQ,Q5 U O QUO
2 2 P! )Tr! r rn r$ r% )rH r r� r� r� rM rN r& s & r �test_stack_entry� PdbTestColorize.test_stack_entry� sD � ���� �� �G�G�6�D� 1�� � � �c�3�Z� �(� �
�
�f�f�o�o� /�0r �pyrepl is not availablec � � [ O 2 oUO O oQ Q,1QQ,1QQ,1QQ Q
,1Q, Q N1,oSF D� v qE[ U U2 UP Q5 F Ds v ov v qxo U O UO O U2 U O UO O U2 U O UO U 2 Ju J� P! ) �longlistz !longlist�listzlist(za = 1)�strict))r � � soft_keyword)�r r �op)�r � r2 )r5 �builtin)�r� r� r4 ))r3 r2 ))rX rX r4 )r8 �number)
r� r� � pyrepl_input�
gen_colors�zipr� �span�start�end�tag)
r rO r; �
test_cases�bufferr! �
color_spanr> r? r@ s
& r �test_gen_colors� PdbTestColorize.test_gen_colors� s� � � �G�G�I���^�^�.�.�
� �2�3� 4�
�>�*� +�
�.�/� 0�
�*�N�;� <�
� �
�
�
� !+� �F�36�z�&�7I�8�\`�3a�3a�/�
� /�\�e�3�� � �� � �!6�!6��>�� � �� � �!4�!4�c�:�� � �� � ��5� 4b� !+r )r )r' r( r) r* r� r� r' r* r� r� r� r� rD r, r- r. s @r r r l sF �� � �>� =�4� 1� �_�_��.�.�0�0�2K�L�6� M�6r r c �( ` � \ sQ sQs n Q sQsU sP! )�TestREPLSessioni� c �b � ] QHGo U 2 oQoUO O [ O
U2 2 [
U2 oU O QU2 U O QU2 U O QU2 U O QU2 U O UO ] 2 P! )r )�
spawn_replz�
x = 'Spam'
import pdb
pdb.set_trace(commands=['x + "During"', 'q'])
x + 'After'
�
SpamDuringr r � SpamAfter) �test.test_replrI r r r r r rM r� r� r� )r rI rO �
user_inputr� s & r �$test_return_from_inline_mode_to_REPL�4TestREPLSession.test_return_from_inline_mode_to_REPL� s� � � .� �L�� �
�
���
�
�h�o�o�j�1�2� �Q� �� �
�
�l�F�+� ��� ��/� �
�
�i��(� �
�
�k�6�*� ���� � �q�)r r1 )r' r( r) r* rN r, r- r. s @r rG rG � s �� � �*� *r rG c �4 ` � \ sQ sQs n \Q 2 sQQ ksQ sQ sQ s Q s
Q s Q s \
O \O O# Q2 Q
2 Q 2 sQ s\
O \O O# Q2 Q
2 Q
2 sQ sQsU sP! )�PdbTestReadlinei� c �l � [ Q 2 oUO Q6X c [ O Q2 gP! )�readline�editlinez)libedit readline is not supported for pdb)r �backendr� �SkipTest)�clsrS s & r �
setUpClass�PdbTestReadline.setUpClass� s3 � � !��,�� � � �z� )��#�#�$O�P� P� *r c � � Ue [ O QQ-* o[ VUQ5 o[ O QPUO Q2 2 oU! )Nr� r �r� z\x1b\[[0-?]*[ -/]*[@-~]r� )r� r� r
�re�subr� )r r
r r� r� s &&&& r �_run_pty�PdbTestReadline._run_pty� sL � � �;� �*�*� 3�S� 9�9�C���C�0�� ���2�B��
�
�g�8N�O���
r c �. � [ O 2 ! r )r� r� r s &r r� �!PdbTestReadline._pyrepl_available� s � ��$�$�&�&r c �� � [ O Q 2 oQoU O V2 oU O QU2 U O QU2 U O QU2 U O QU2 P! )z�
import pdb; pdb.Pdb().set_trace()
# Concatenate strings so that the output doesn't appear in the source
print('hello' + '!')
s
co ntin
r� � conditionr^ zhello!�r r r^ rM �r r
r r� s & r �test_basic_completion�%PdbTestReadline.test_basic_completion� sb � �� � � " �
�� "��� � �v�-�� �
�
�j�&�)� �
�
�k�6�*� �
�
�j�&�)� �
�
�h��'r c � � [ O Q 2 oQoUQ*
oUQ*
oUQ*
oU O V2 oU O QU2 U O QU2 U O QU2 P! )�S
value = "speci"
import pdb; pdb.Pdb().set_trace()
� val + 'al'
s p val + 'es'
s $_fra
� c
�special�speciesz$_framerd re s & r �test_expression_completion�*PdbTestReadline.test_expression_completion� sr � �� � � " �
�� "��
�$�$��
� � ��
����� � �v�-�� �
�
�i��(� �
�
�i��(� �
�
�i��(r c � � [ O Q 2 oQoUQ*
oU O V2 oU O QU2 P! )ri s pri val + 'al')
rk rl rd re s & r �test_builtin_completion�'PdbTestReadline.test_builtin_completion� sC � �� � � " �
�� (�� ����� � �v�-�� �
�
�i��(r c �� � [ O Q 2 oQoUQ*
oUQ*
oU O V2 oU O QU2 U O QU2 P! )�7
import pdb; pdb.Pdb().set_trace()
s $_fram
s $_frame.f_line + 100
rk z <frame at 0x�102rd re s & r �test_convvar_completion�'PdbTestReadline.test_convvar_completion
s^ � �� � � " �
��
�� �,�,�� ����� � �v�-�� �
�
�n�f�-� �
�
�e�V�$r c � � [ O Q 2 oQoUQ*
oU O V2 oU O QU2 P! )z�
def f():
original = "I live Pythin"
import pdb; pdb.Pdb().set_trace()
f()
s orig .repl ('i', 'o')
rk z
I love Pythonrd re s & r �test_local_namespace�$PdbTestReadline.test_local_namespace sC � �� � � " �
�� -�� ����� � �v�-�� �
�
�o�v�.r zL\x08 does not remove the auto-indentation with GNU readline on this platformc � � [ O Q 2 oQoUQ*
oUQ*
oUQ*
oUQ*
oUQ*
oUQ*
oUQ*
oUQ *
oU O V2 oU O Q
U2 P! ) rt s
def f(x):
s
if x > 0:
s x += 1
s return x
s
else:
s
return -x
�
s
f(-21-21)
rk r� rd re s & r �test_multiline_auto_indent�*PdbTestReadline.test_multiline_auto_indent2 s� � � � � � " �
�� ��
� � ��
�� ��
� � ��
�+�+��
� � ��
����
� � ��
����� � �v�-�� �
�
�d�F�#r c �� � [ O Q 2 oQoUQ*
oUQ*
oUQ*
oUQ*
oU O V2 oU O QU2 P! )rt s def func():
s ret 40 + 2
r| s fun ()
rk r� rd re s & r �test_multiline_completion�)PdbTestReadline.test_multiline_completionI sa � �� � � " �
�� !�� �"�"��
����
� � ��
����� � �v�-�� �
�
�d�F�#r c �� � [ O Q 2 o[ O Q2 O 2 oU O V2 oU O QU2 U O QU2 P! )rt z� def func():
a = 1
a += 1
a += 1
a += 1
if a > 0:
a += 1
return a
func()
c
�5�Error)r r r� r^ rM r� re s & r � test_multiline_indent_completion�0PdbTestReadline.test_multiline_indent_completion[ sf � � � � � " �
�� ��� ! �
� �V�X� � � � �v�-�� �
�
�c�6�"� ����&�)r c �V � [ O Q 2 oQoUQ*
oUQ*
oUQ*
oUQ*
oUQ*
oUQ*
oUQ*
oUQ *
oU O V2 oU O Q
U2 U O Q U2 U O Q U2 P! )
ri s interact
s disp
rj � def f():
s return 42
r| s f() * 2
s exit()
rk z'disp' is not definedrl �84rd re s & r �test_interact_completion�(PdbTestReadline.test_interact_completiony s� � �� � � " �
�� ��
�� ��
�"�"��
� � ��
�!�!��
����
� � ��
�� ��
����� � �v�-�� �
�
�-�v�6� �
�
�i��(� �
�
�d�F�#r r1 r )r5 � dragonflyr* )r' r( r) r* � classmethodrX r^ r� rf rn rq rv ry r� r� r r, r- r} r� r� r� r, r- r. s @r rQ rQ � s� �� � � �Q� �Q� �'�(�$)�*)� %�&/�$ �_�_�S�\�\�,�,�-N�O�5�6�$�6�$�($�$ �_�_�S�\�\�,�,�-N�O�5�6�*�6�*�6$� $r rQ r, c �@ ` `� \ sQ sQs nU 1Q ksQ sQ sQsUsU 9s ! )�PdbTestReadlinePyREPLi� c �H :� [ RU _ V- [ O AQ 5 ! )r[ )�superr^ r� r� )r r
r � __class__s &&&�r r^ � PdbTestReadlinePyREPL._run_pty� s �� ��w� ��>�b�j�j�>� �B�Br c �~ � [ O Q 2 oQoU O V2 oU O QU2 P! )z^
import pdb
db = pdb.Pdb()
print(db.pyrepl_input)
r �PdbPyReplInputrd re s & r �test_pyrepl_used�&PdbTestReadlinePyREPL.test_pyrepl_used� s9 � �� � � " �
��
��� � �v�-�� �
�
�&��/r c �� � [ O Q 2 oQoUQ*
oUQ*
oUQ*
oUQ*
oU O V2 oU O QU2 P! )rt r� s return xs OAODODxOBOB
s
f(40 + 2)
rk r� rd re s & r � test_pyrepl_multiline_change�2PdbTestReadlinePyREPL.test_pyrepl_multiline_change� sb � �� � � " �
�� ��
�� �� �7�7��
� � ��
����� � �v�-�� �
�
�d�F�#r r1 )
r' r( r) r* r^ r� r� r, r- �
__classcell__)r� r/ s @@r r� r� � s �� � �C�0�$� $r r� c �� � ] QHGo Q oQ oUO [ O UU Q2 UQ5 2 UO [ O UU Q2 UQ5 2 U! )r )�test_pdbc � ` � U 1Q koU! )c �6 :� ] PHoUO R2 P! )r )r� �set_default_backend)�testr� rU s & �r r� �2load_tests.<locals>.setUpPdbBackend.<locals>.setUp� s �� � � � #� #�G� ,r r1 )rU r� s f r �setUpPdbBackend�#load_tests.<locals>.setUpPdbBackend� s �� � -� � r c �> � [ P2 ] PHoUO O 2 [ O
O % c> [ O
O O 2 P[ O
m [ O 2 P! r )
r �bdb�
Breakpoint�clearBreakpointsr� r� r� �
stop_trace�gc�collect)r� r� s & r r� � load_tests.<locals>.tearDown� s` � � �t�$� � ���'�'�)� �7�7� %� %� %� �G�G� &� &� 1� 1� 3�)-�C�G�G� &� �
�
� r �
monitoring)r� r� r# )r� r� �addTest�doctest� DocTestSuite)�loader�tests�patternr� r� r� s &&& r �
load_testsr� � sj � � �� �2
�M�M�� � � �!�,�/� �
��
�M�M�� � � �!�*�-� �
�� �Lr �__main__)�r r� r� rH r� r� r\ r r� rY r� r� r r� r� r� �asyncio.eventsr �
contextlibr r r r� r � test.supportr r �test.support.import_helperr �test.support.pty_helperr
r �test.support.script_helperr �
unittest.mockr
r� r� r r2 r5 r7 r9 r; r= r? rA rC rE rG rI rK rO rQ rS rU rW rY r[ r] r� �no_siter_ ra rc re rg ri rk rm ro rq rs ru rw r� r� rv �__dict__rz r| r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� �original_pdb_settracer� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� � force_not_colorized_test_class�requires_subprocess�TestCaser� r� r� �force_colorized_test_classr rG rQ r� r� r� r� r' �mainr1 r r �<module>r� s� �� � � � � �
� �
� �
� � � � �
� � 1� 1� � � 6� 4� 6� 2� ���*�6� *�"�8W�rB�H'�R �D,�\ �B'�R@�D"�H�4 �@ ��a�F'�R=�~G�RY�v�* � �y�y����2 �hY�xN�b5�pG�T"�J"�J�*b�J?�D0�f�4!�J ���'�(�� �=�s�|�|� L�,�^+�\?�
� �,=�~=�~ �� �.> �@. �`; �z7 �r< �|9�v �) �V.�` �. �`'�R1�f �B �D=�~&�T �
�
� �%�N�0�8.�`C�J(�T�2�(�"�" �>�.�6�,1�f'�R1�f)�X �'�'�� � � �i9�(�#�#� i9� � (�i9�X'"I�X�&�&� "I�J � � � �O%�H�%�%� O%� �O%�d �#�#�56�h�'�'� 56� $�56�p �'�'�� � � �*�h�'�'� *� � (�*�* �'�'�� � � �U$�h�'�'� U$� � (�U$�p
� � �S�*�*�,�,�.G�H� $�O� $� I� $�B0�f �z�� �M�M�O� r