| 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 : /Python313/Lib/test/__pycache__/ |
Upload File : |
�
��i�& � � � S SK r S SKrS SKrS SKrS SKrS SKrS SKrS SKrS SKrS SK r S SK
r
S SK J r J
r
S SKJr S SKJr S SKJrJr S SKJr S SKJrJr S SKJr \R8 ( + r " S S
\ 5 r S r S r!S
r"S r#S r$S r%S r&S r'S r(S r)S r*S r+S r,S r-S r.S r/\R` Rb ( d S r2S r3S r4S r5S r6S r7S! r8S" r9S# r:S$ r;S% r<S& r=S' r>\R~ " S(5 r@\A" S)\@R� 5 S* rCS+ rDS, rES- rFS. rGS/ rHS0 rI\ ( d S1 rJS2 rKS3 rL\ ( d S4 rMS5 rN\ ( d S6 rOS7 rPS8 rQS9 rRS: rSS; rTS< rUS= rVS> rWS? rXS@ rYSA rZSB r[SC r\SD r]SE r^SF r_SG r`SH raSI rbSJ rcSK rd\R� " 5 " SL SM\R� 5 5 rg " SN SO\R� 5 rh\R� " 5 " SP SQ\R� 5 5 riSR rj\kSS:X a \R� " 5 gg)T� N)� ExitStack�redirect_stdout)�StringIO)�support)�force_not_colorized� os_helper)�
import_module)�run_pty� FakeInput)�patchc �* � \ rS rSrSrS rS rS rSrg)� PdbTestInput� z:Context manager that makes testing Pdb in doctests easier.c � � Xl g �N)�input)�selfr s �"C:\Python313\\Lib\test\test_pdb.py�__init__�PdbTestInput.__init__ s � ��
� c �� � [ R U l [ U R 5 [ l [ [ S5 ( a [ R " 5 U l g S U l g )N�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 R [ l U R ( a! [ R " U R 5 g g r )r r r r �settrace)r �excs r �__exit__�PdbTestInput.__exit__& s) � ��O�O�� � �?�?� �L�L�� � � )� r )r r r N) �__name__�
__module__� __qualname__�__firstlineno__�__doc__r r r% �__static_attributes__� r r r r s � �D��O�
*r r c � � g)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
Nr- r- r r �test_pdb_displayhookr/ , � � r c � � g)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
Nr- r- r r �test_pdb_basic_commandsr2 H r0 r c �@ � SS K n U R R 5 g )Nr )�bdb�
Breakpoint�clearBreakpoints)r4 s r �reset_Breakpointr7 � s � ���N�N�#�#�%r c � � g)a] Test basic commands related to breakpoints.
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... print(1)
... print(2)
... print(3)
... print(4)
First, need to clear bdb state that might be left over from previous tests.
Otherwise, the new breakpoints might get assigned different numbers.
>>> reset_Breakpoint()
Now test the breakpoint commands. NORMALIZE_WHITESPACE is needed because
the breakpoint list outputs a tab for the "stop only" and "ignore next"
lines, which we don't want to put in here.
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'break 3',
... 'break 4, +',
... 'disable 1',
... 'ignore 1 10',
... 'condition 1 1 < 2',
... 'condition 1 1 <',
... 'break 4',
... 'break 4',
... 'break',
... 'clear 3',
... 'break',
... 'condition 1',
... 'enable 1',
... 'clear 1',
... 'commands 2',
... 'p "42"',
... 'print("42", 7*6)', # Issue 18764 (not about breakpoints)
... 'end',
... 'continue', # will stop at breakpoint 2 (line 4)
... 'clear', # clear all!
... 'y',
... 'tbreak 5',
... 'continue', # will stop at temporary breakpoint
... 'break', # make sure breakpoint is gone
... 'commands 10', # out of range
... 'commands a', # display help
... 'commands 4', # already deleted
... 'break 6, undefined', # condition causing `NameError` during evaluation
... 'continue', # will stop, ignoring runtime error
... 'continue',
... ]):
... test_function()
> <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) 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
Nr- r- r r � test_pdb_breakpoint_commandsr9 � r0 r c � � g)a� Test breakpoints on function definitions with annotation.
>>> def foo[T]():
... return 0
>>> def bar() -> int:
... return 0
>>> def foobar[T]() -> int:
... return 0
>>> reset_Breakpoint()
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... pass
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'break foo',
... 'break bar',
... 'break foobar',
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[4]>(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
Nr- r- r r �-test_pdb_breakpoint_on_annotated_function_defr; i r0 r c � � g)aD 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()
... # Be a good citizen and clean up the mess
... reset_Breakpoint()
First, need to clear bdb state that might be left over from previous tests.
Otherwise, the new breakpoints might get assigned different numbers.
>>> reset_Breakpoint()
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
... 'break test.test_inspect.inspect_fodder2:90',
... 'continue', # will stop at func88
... 'break test/test_inspect/inspect_fodder2.py:115',
... 'continue', # will stop at func114
... 'continue',
... ]):
... test_function()
> <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
Nr- r- r r �!test_pdb_breakpoint_with_filenamer= � r0 r c � � g)aH Breakpoints are remembered between interactive sessions
>>> reset_Breakpoint()
>>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
... 'import test.test_pdb',
... 'break test.test_pdb.do_something',
... 'break test.test_pdb.do_nothing',
... 'break',
... 'continue',
... ]):
... pdb.run('print()')
> <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
Nr- r- r r �:test_pdb_breakpoints_preserved_across_interactive_sessionsr? � r0 r c � � g)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
Nr- r- r r �test_pdb_pp_repr_excrA � r0 r c � � g)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
Nr- r- r r �test_pdb_empty_linerC r0 r c � � g r r- r- r r �
do_nothingrE 2 s � �r c � � [ S5 g )N�* )�printr- r r � do_somethingrI 5 s � � �"�Ir c � � g)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
Nr- r- r r �test_list_commandsrK 8 r0 r c � � g)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
Nr- r- r r �test_pdb_whatis_commandrM � r0 r c � � g)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
Nr- r- r r �test_pdb_display_commandrO � r0 r c � � g)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
Nr- r- r r �test_pdb_alias_commandrQ r0 r c � � g)aS 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',
... 'u',
... 'w',
... '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]>(8)<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]>(8)<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) u
> <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g();
(Pdb) w
...
<doctest test.test_pdb.test_pdb_where_command[3]>(8)<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
Nr- r- r r �test_pdb_where_commandrS L r0 r c � � g)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
Nr- r- r r �test_pdb_interact_commandrU � r0 r c � � g)a'
Test convenience variables
>>> def util_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... try:
... raise Exception('test')
... except:
... pass
... return 1
>>> def test_function():
... util_function()
>>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
... 'step', # Step to try statement
... '$_frame.f_lineno', # Check frame convenience variable
... '$ _frame', # This should be a syntax error
... '$a = 10', # Set a convenience variable
... '$a', # Print its value
... 'p "$a"', # Print the string $a
... 'p $a + 2', # Do some calculation
... 'p f"$a = {$a}"', # Make sure $ in string is not converted and f-string works
... 'u', # Switch frame
... '$_frame.f_lineno', # Make sure the frame changed
... '$a', # Make sure the value persists
... 'd', # Go back to the original frame
... 'next',
... '$a', # The value should be gone
... 'next',
... '$_exception', # Check exception convenience variable
... 'next',
... '$_exception', # Exception should be gone
... 'return',
... '$_retval', # Check return convenience variable
... 'continue',
... ]):
... test_function()
> <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:
(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
Nr- r- r r �test_convenience_variablesrW � r0 r c � � g)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
Nr- r- r r �test_post_mortem_chainedrY r0 r c � � g)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) exitNr- r- r r �!test_post_mortem_cause_no_contextr[ k r0 r c � � g)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
Nr- r- r r �%test_post_mortem_context_of_the_causer] � r0 r c � � g)a� Test post mortem traceback debugging of chained exception
In particular that cause from None (which sets __supress_context__ to True)
does not show context.
>>> def main():
... try:
... raise TypeError('Context of the cause')
... except Exception as e1:
... raise ValueError("With Cause, and cause has context") from None
>>> def test_function():
... import pdb;
... instance = pdb.Pdb(nosigint=True, readrc=False)
... try:
... main()
... except Exception as e:
... pdb._post_mortem(e, instance)
>>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
... 'exceptions',
... 'exit',
... ]):
... try:
... test_function()
... except ValueError:
... print('Correctly reraised.')
> <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
Nr- r- r r �test_post_mortem_from_noner_ � r0 r c � � g)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
Nr- r- r r � test_post_mortem_from_no_stackra r0 r c � � g)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
Nr- r- r r � test_post_mortem_single_no_stackrc 7 r0 r c � � g)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
Nr- r- r r �test_post_mortem_complexre L r0 r c � � g)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.
Nr- r- r r �test_post_mortemrg � r0 r c � � g)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())
>>> reset_Breakpoint()
>>> 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
Nr- r- r r �!test_pdb_return_to_different_fileri � r0 r c � � g)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
Nr- r- r r �test_pdb_skip_modulesrk ' r0 r c � � g)aV This tests pdb commands that have invalid arguments
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
>>> with PdbTestInput([
... 'a = 3',
... 'll 4',
... 'step 1',
... 'continue'
... ]):
... test_function()
> <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) continue
Nr- r- r r �test_pdb_invalid_argrm A r0 r �module_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonec � � g)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
Nr- r- r r �#test_pdb_skip_modules_with_callbackrp b r0 r c � � g)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
Nr- r- r r � test_pdb_continue_in_bottomframerr � r0 r c �N � [ [ R " SSS9U 5 " U5 g)zRun pdb.method(arg).TF)�nosigint�readrcN)�getattr�pdb�Pdb)�method�args r �
pdb_invoker{ � s � � �C�G�G�T�%� 0�&�9�#�>r c � � g)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
Nr- r- r r �$test_pdb_run_with_incorrect_argumentr} � r0 r c � � g)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
Nr- r- r r � test_pdb_run_with_code_objectr � r0 r c � � g)a1 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
>>> reset_Breakpoint()
>>> 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
Nr- r- r r �&test_next_until_return_at_return_eventr� � r0 r c � � g)aA Testing skip unwindng stack on yield for generators for "next" command
>>> def test_gen():
... yield 0
... return 1
... yield 2
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... it = test_gen()
... try:
... if next(it) != 0:
... raise AssertionError
... next(it)
... except StopIteration as ex:
... if ex.value != 1:
... raise AssertionError
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'step',
... 'step',
... 'next',
... 'next',
... 'step',
... 'step',
... 'continue']):
... test_function()
> <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
Nr- r- r r �#test_pdb_next_command_for_generatorr� * r0 r c � � g)a% Testing skip unwindng stack on yield for coroutines for "next" command
>>> import asyncio
>>> async def test_coro():
... await asyncio.sleep(0)
... await asyncio.sleep(0)
... await asyncio.sleep(0)
>>> async def test_main():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... await test_coro()
>>> def test_function():
... loop = asyncio.new_event_loop()
... loop.run_until_complete(test_main())
... loop.close()
... asyncio.set_event_loop_policy(None)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'step',
... 'next',
... 'next',
... 'next',
... 'step',
... 'continue']):
... test_function()
> <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 asyncio.sleep(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(3)test_coro()
-> await asyncio.sleep(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(4)test_coro()
-> await asyncio.sleep(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
Nr- r- r r �#test_pdb_next_command_for_coroutiner� j r0 r c � � g)a Testing skip unwindng stack on yield for coroutines for "next" command
>>> import asyncio
>>> async def agen():
... yield 1
... await asyncio.sleep(0)
... yield 2
>>> async def test_coro():
... async for x in agen():
... print(x)
>>> async def test_main():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... await test_coro()
>>> def test_function():
... loop = asyncio.new_event_loop()
... loop.run_until_complete(test_main())
... loop.close()
... asyncio.set_event_loop_policy(None)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'step',
... 'next',
... 'next',
... 'step',
... 'next',
... 'continue']):
... test_function()
> <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 asyncio.sleep(0)
(Pdb) continue
2
finished
Nr- r- r r �"test_pdb_next_command_for_asyncgenr� � r0 r c � � g)a� Testing no unwindng stack on yield for generators
for "return" command
>>> def test_gen():
... yield 0
... return 1
... yield 2
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... it = test_gen()
... try:
... if next(it) != 0:
... raise AssertionError
... next(it)
... except StopIteration as ex:
... if ex.value != 1:
... raise AssertionError
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'step',
... 'step',
... 'return',
... 'step',
... 'step',
... 'continue']):
... test_function()
> <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
Nr- r- r r �%test_pdb_return_command_for_generatorr� � r0 r c � � g)aX Testing no unwindng stack on yield for coroutines for "return" command
>>> import asyncio
>>> async def test_coro():
... await asyncio.sleep(0)
... await asyncio.sleep(0)
... await asyncio.sleep(0)
>>> async def test_main():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... await test_coro()
>>> def test_function():
... loop = asyncio.new_event_loop()
... loop.run_until_complete(test_main())
... loop.close()
... asyncio.set_event_loop_policy(None)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'step',
... 'next',
... 'continue']):
... test_function()
> <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 asyncio.sleep(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(3)test_coro()
-> await asyncio.sleep(0)
(Pdb) continue
finished
Nr- r- r r �%test_pdb_return_command_for_coroutiner� # r0 r c � � g)a Testing no unwindng stack on yield for generators
for "until" command if target breakpoint is not reached
>>> def test_gen():
... yield 0
... yield 1
... yield 2
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... for i in test_gen():
... print(i)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'until 4',
... 'step',
... 'step',
... 'continue']):
... test_function()
> <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
Nr- r- r r �$test_pdb_until_command_for_generatorr� Q r0 r c � � g)a Testing no unwindng stack for coroutines
for "until" command if target breakpoint is not reached
>>> import asyncio
>>> async def test_coro():
... print(0)
... await asyncio.sleep(0)
... print(1)
... await asyncio.sleep(0)
... print(2)
... await asyncio.sleep(0)
... print(3)
>>> async def test_main():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... await test_coro()
>>> def test_function():
... loop = asyncio.new_event_loop()
... loop.run_until_complete(test_main())
... loop.close()
... asyncio.set_event_loop_policy(None)
... print("finished")
>>> with PdbTestInput(['step',
... 'step',
... 'until 8',
... 'continue']):
... test_function()
> <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
Nr- r- r r �$test_pdb_until_command_for_coroutiner� � r0 r c � � g)a- The next command on returning from a generator controlled by a for loop.
>>> def test_gen():
... yield 0
... return 1
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... for i in test_gen():
... print('value', i)
... x = 123
>>> reset_Breakpoint()
>>> with PdbTestInput(['break test_gen',
... 'continue',
... 'next',
... 'next',
... 'next',
... 'continue']):
... test_function()
> <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
Nr- r- r r �+test_pdb_next_command_in_generator_for_loopr� � r0 r c � � g)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
Nr- r- r r �!test_pdb_next_command_subiteratorr� � r0 r c � � g)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
Nr- r- r r � test_pdb_multiline_statementr� r0 r c � � g)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
Nr- r- r r �test_pdb_closurer� 4 r0 r c � � g)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
Nr- r- r r � test_pdb_show_attribute_and_itemr� s r0 r c � � g)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
>>> reset_Breakpoint()
>>> 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>
Nr- r- r r �test_pdb_issue_20766r� � r0 r c � � g)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)
>>> reset_Breakpoint()
>>> 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
Nr- r- r r �test_pdb_issue_43318r� � r0 r c � � g)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()
>>> reset_Breakpoint()
>>> 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'
Nr- r- r r �test_pdb_issue_gh_91742r� � r0 r c � � g)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()
>>> reset_Breakpoint()
>>> 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
Nr- r- r r �test_pdb_issue_gh_94215r�
r0 r c � � g)a� See GH-101673
Make sure ll won't revert local variable assignment
>>> def test_function():
... a = 1
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... '!a = 2',
... 'll',
... 'p a',
... 'continue'
... ]):
... test_function()
> <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) continue
Nr- r- r r �test_pdb_issue_gh_101673r� H
r0 r c � � g)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
Nr- r- r r �test_pdb_issue_gh_103225r� d
r0 r c � � g)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
Nr- r- r r �test_pdb_issue_gh_101517r� }
r0 r c � � g)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
Nr- r- r r �test_pdb_issue_gh_108976r� �
r0 r c � � g)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
Nr- r- r r �test_pdb_issue_gh_127321r� �
r0 r c � � g)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
Nr- r- r r �test_pdb_issue_gh_136057r� �
r0 r c � � g)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
Nr- r- r r �test_pdb_issue_gh_80731r� �
r0 r c � � g)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
Nr- r- r r � test_pdb_ambiguous_statementsr� �
r0 r c � � g)a� GH-80675
pdb should work even if f_trace_lines is set to False on some frames.
>>> reset_Breakpoint()
>>> def test_function():
... import sys
... frame = sys._getframe()
... frame.f_trace_lines = False
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... if frame.f_trace_lines != False:
... print("f_trace_lines is not reset after continue!")
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
... 'continue'
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_f_trace_lines[1]>(5)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
Nr- r- r r �test_pdb_f_trace_linesr� r0 r c � � g)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
Nr- r- r r �test_pdb_frame_refleakr� r0 r c � � g)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
Nr- r- r r �test_pdb_function_breakr� O r0 r c � � g)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
Nr- r- r r �test_pdb_issue_gh_65052r� x r0 r c �* � \ rS rSrS r\R " \R R S5 SDS j5 r
SES jr S r S r
S rS
rS rS rS
rS rS rS rS rS rS rS rS rS rS r \ S 5 r \ S 5 r S r S r!S r"S r#S r$S r%S r&S! r'S" r(S# r)S$ r*S% r+S& r,S' r-S( r.S) r/S* r0S+ r1S, r2S- r3S. r4S/ r5S0 r6S1 r7S2 r8S3 r9S4 r:S5 r;S6 r<S7 r=S8 r>S9 r?\@R� S: 5 rBS; rCS< rDS= rES> rFS? rGS@ rHSA rISB rJSCrKg)F� PdbTestCasei� c �L � [ R " [ R 5 g r �r �unlink�TESTFNr s r �tearDown�PdbTestCase.tearDown� � � �����)�)�*r z'PYTHONSAFEPATH changes default sys.pathNc �� � U R [ R S5 [ R SS/U- nUb [
R U- nO[
R n[ R " U[ R [ R [ R 0 UESS0ES9 nUR [ R U5 5 u p�S S S 5 [ W[ 5 ( a [ R U5 OUn[ W [ 5 ( a [ R U 5 OU n U R! WR" USU SU 35 X�4$ ! , ( d f N�= f) N� __pycache__�-mrw �PYTHONIOENCODING�utf-8��stdoutr �stderr�envz Unexpected return code
stdout: z
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!c � � Sn[ US5 n U R [ R " U5 5 SSS5 UbZ [ SS5 n U R [ R " U5 5 SSS5 U R [
R S5 U R [
R U5 Sn
U( a [ R R SS5 n
Uc / nU R U/U- X#U5 u p�U
b U
[ R S' X�4$ ! , ( d f N�= f! , ( d f N�= f! U
b U
[ R S' f f = f)z3Run 'script' lines with pdb and the pdb 'commands'.�main.py�wN�.pdbrc�HOME) �open�write�textwrap�dedentr� r r� r� r� �popr� )
r �scriptr� r� r� � script_args�pdbrc� remove_home�filename�f�homesaver� 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��� ��z�z�~�~�f�d�3�H� .��"� � � !�]�]�H�:� �+C�X�dm� n�N�F��#�%-��
�
�6�"��~� �' !�
�� %�$�� �#�%-��
�
�6�"� $�s# �&D� &D,�$ D= �
D)�,
D:�=Ec �@ � SU l [ R " U R 5 U R S- nU R S- n[ R " U R 5 [ US5 n SSS5 [ US5 nUR
[ R " U5 5 SSS5 U R [ R U R 5 U R SU R /U5 $ ! , ( d f N�= f! , ( d f Ng= f)z(Runs the script code as part of a module�t_main� /__main__.py� /__init__.pyr� Nr� ) � 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 �2C>�&D�>
D �
D c �< � [ [ R S5 nUR U5 S S S 5 U( d S OUS [ R US 4nU R U[
R " U[ R 5 5 g ! , ( d f Nf= f)N�wbr � )r� r r� r� r� rw �
find_function)r � file_content� func_name�expectedr� s r �_assert_find_function�!PdbTestCase._assert_find_function� sx � �
�)�"�"�D�
)�Q�
�G�G�L� !� *� (�4� �Q�K��)�)�8�A�;�.8�� ��� �c�'�'� �9�3C�3C�D� F� *�
)�s �B
�
Bc �P � U R 5 =( d U R 5 $ )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�d�&6�&6�&8�8r c �" � [ R R S5 ( a gSn[ R R U5 ( aD [ R R
[ R R US5 5 ( a U$ g)z9Return /proc-backed fd dir when it can be used for pipes.�sunosNz
/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 �� � Sn[ R R U5 ( a� [ R R [ R R US5 5 ( am [
R R S5 ( aG [ R " S5 R [ R " U5 R :X a g U$ U$ g! [ a gf = f)z&Return /dev-backed fd dir when usable.z/dev/fdr �freebsdz/devN) r� r r r r 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 �* � U R SSS 5 g )Nr �foo)r r s r � test_find_function_empty_file�)PdbTestCase.test_find_function_empty_file s � � �"�"�3��t�4r c �F � U R SR 5 SS5 g )Nu@ 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_found! s$ � � �"�"�
� �F�H� � �
r c �H � U R SR S5 SS5 g )NuV # coding: iso-8859-15
def foo():
pass
def bœr():
pass
def quux():
pass
z iso-8859-15r& )r& � r( r s r �-test_find_function_found_with_encoding_cookie�9PdbTestCase.test_find_function_found_with_encoding_cookie1 s' � � �"�"�
� �F�=�� � �
r c �h � U R [ R SR 5 - SS5 g )Nu 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_bomB s2 � � �"�"� �O�O� � �F�H�
�
� �
r c �V � SnSnU R X5 u p4U R SU5 g )NzJ
import __main__
print(__main__.__spec__)
�continue�None�r� �assertIn�r r� r� r� �_s r � test_spec�PdbTestCase.test_specL s0 � � ��
���'�'��9� �� �
�
�f�f�%r c �x � U R 5 nUc U R S5 [ R " 5 u p#S nU R XB5 U R XC5 [ R
R
U[ U5 5 n[ R
R U5 ( d U R S5 Sn[ R " X6R S5 5 [ R " U5 [ R
S nU R [ R
R SU5 [ R " U5 nUR n UR" n
[% X�5 U R' U
S S 5 U R' U
S
UR( 5 U R+ U
S 5 g) z=
_ScriptTarget doesn't fail on an anonymous pipe.
GH-142315
Nz7anonymous pipe targets require /proc/self/fd or /dev/fdc �R � [ R " U 5 g ! [ a g f = fr )r� �close�OSError)�fds r �
safe_close�APdbTestCase.test_script_target_anonymous_pipe.<locals>.safe_closed s$ � �
����� ���
��
�s � �
&�&z,fd directory does not expose anonymous pipeszmarker = "via_pipe"
r� r �marker�via_pipe�__file__�__spec__)r
�skipTestr� �piper� r r r� r r� r� r@ r � __setitem__rw �
_ScriptTarget�code� namespace�execr� r� � assertIsNone) r �fd_dir�read_fd�write_fdrC � pipe_path�
script_source�original_path0�target� code_textrN s r �!test_script_target_anonymous_pipe�-PdbTestCase.test_script_target_anonymous_pipeX 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 �� � [ R " S5 R 5 nU R USS5 U R USS5 U R USS5 U R USS 5 g )
Na� def foo(): pass
def bar():
pass # line 4
def baz():
# comment
pass # line 8
def mul():
# code on multiple lines
code = compile( # line 12
'def f()',
'<string>',
'exec',
)
r" )r" r �bar)r\ � �baz)r^ � �mul)r` � )r� r� r� r )r rM s r �(test_find_function_first_executable_line�4PdbTestCase.test_find_function_first_executable_line� sk � ���� �
�" �V�X�#
�&
�"�"�4��
�;� �"�"�4��
�;� �"�"�4��
�;� �"�"�4�� �<r c �� � [ [ R S5 nUR S5 S S S 5 [ R
SS[ R /n[ R " U[ R [ R [ R S9nU R UR R 5 UR S5 u pEU R SUS5 g ! , ( d f N�= f) Nr s print("testing my pdb")
r� rw )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� r@ 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 �C$�$
C2c � � SnSnU R X5 u p4U=( d SU=( d S- nU R SUS5 U R SUS5 g )Nz�
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� re r9 )r r� r� r� r� �outputs r �test_issue46434�PdbTestCase.test_issue46434� sc � � �� �� �,�,�V�>����,�B�6�<�R�0�� ���)�6�^� `� �
�
�S�U[�T� Vr c �l � SnSnSn[ SS5 nUR [ R " U5 5 S S S 5 U R [
R S5 U R X5 u pVU R [ S UR 5 5 5 S5 g ! , ( d f Nr= f)Nz�
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 �, # � U H
nS U; v � M g7f)zmain.py(5)foo()->NoneNr- ��.0�ls r � <genexpr>�.PdbTestCase.test_issue13183.<locals>.<genexpr>� s � � �J�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�>��� ��� �J�f�6G�6G�6I�J� J� 9� ;� !�
�s �&B%�%
B3c �X � [ [ R S5 nUR [ R
" S5 R
S5 5 S S S 5 [ R S[ R /n[ R " U[ R [ R [ R 0 [ R ESS0ES9nU R UR R 5 UR# S5 u pEU R% S US
5 g ! , ( d f N�= f) Nr 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� r@ r� re rf 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�
D)c �X � [ [ R S5 nUR [ R
" S5 R
S5 5 S S S 5 [ R S[ R /n[ R " U[ R [ R [ R 0 [ R ESS0ES9nU R UR R 5 UR# S5 u pEU R% S US
5 g ! , ( d f N�= f) Nr 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� rf 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 �x � SnSnSnU R X5 u pEU R X5SR X55 5 g )Nz def f: pass
rj z SyntaxError:zE
Expected:
{}
Got:
{}
Fail to handle a syntax error in the debuggee.)r� r9 �format)r r� r� r r� r� s r �test_issue16180�PdbTestCase.test_issue16180
sG � � !����!�� �,�,� �
���
�
�
�h�
=�
�V�H�
%� 'r c � � SnSnU R X5 u p4U R UR S5 S5 U R UR S5 S5 g )Nz!import ast; ast.literal_eval('')
zA
continue
where
quit
zast.literal_eval('')r0 r )r� r� �count�r r� r� r� r� s r �test_issue84583�PdbTestCase.test_issue84583*
sZ � � 6�� ��
�,�,�V�>���
���� � �&<�=�q�A� ���� � �&<�=�q�Ar c � � SnSnU R X5 u p4SR UR 5 Vs/ s H oUR 5 PM sn5 nU R US5 U R US5 g s snf )Nzprint('hello')z[
continue
run a b c
run d e f
quit
�
z#Restarting .* with arguments:
a b cz#Restarting .* with arguments:
d e f)r� r rz �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 �t � SnSnSn[ SS5 nUR [ R " U5 5 S S S 5 U R [
R S5 U R X5 u pVUR 5 nU R SU5 U R SU5 g ! , ( d f Nv= f)Nz~
import bar
def foo():
ret = bar.bar()
pass
foo()
zv
b bar.bar
c
b main.py:5
c
p ret
quit
z:
def bar():
return 42
rp r� �-> passz(Pdb) 42)
r� r� r� r� r� r r� r� rz r9 )r r� r� r\ r� r� r� �liness r �test_issue58956�PdbTestCase.test_issue58956I
s� � � �� �� �� �(�C�
�A�
�G�G�H�O�O�C�(� )� !� ��� �(�(�(�3� �,�,�V�>����!�!�#�� �
�
�i��'� �
�
�j�%�(�
!�
�s �&B)�)
B7c �z � SnSnU R X5 u p4U R SU5 U R SU5 g )Nzx = 1zM
step
step
step
quit
zThe program finishedzbdb.py�r� r9 re r: s r �test_step_into_botframe�#PdbTestCase.test_step_into_botframeg
sC � � �� �� �'�'��9� �� �
�
�,�f�5� ����6�*r c �� � [ R " S5 n[ R " S5 nU R USUSS9u p4U R SU5 U R SU5 g )Nz-
a = 1
b = 2
zU
# Comments should be fine
n
p f"{a+8=}"
�q
T�r� r� � SyntaxErrorza+8=9)r� r� r� re r9 �r r� r� r� r� s r �test_pdbrc_basic� PdbTestCase.test_pdbrc_basicu
sf � �� � � " �
��
��� ! �
�� �,�,�V�U�%�UY�,�Z��� ��� ��/� �
�
�g�v�&r c �� � [ R " S5 n[ R " S5 nU R USUSS9u p4U R SU5 U R SU5 g) z,Test that empty lines in .pdbrc are ignored.z?
a = 1
b = 2
c = 3
z
n
r� Tr� zb = 2zc = 3N)r� r� r� r9 re r� s r �test_pdbrc_empty_line�!PdbTestCase.test_pdbrc_empty_line�
sh � � � � � " �
�� ��� ! �
��
�,�,�V�U�%�UY�,�Z��� �
�
�g�v�&� ����&�)r c � � [ R " S5 n[ R " S5 nU R USUSS9u p4U R SU5 g )N��
class A:
def __init__(self):
self.attr = 1
a = A()
b = 2
z�
alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")
until 6
pi a
r� Tr� z
a.attr = 1�r� r� r� r9 r� s r �test_pdbrc_alias� PdbTestCase.test_pdbrc_alias�
sV � �� � � " �
�� ��� ! �
�� �,�,�V�U�%�UY�,�Z��� �
�
�l�F�+r c � � [ R " S5 n[ R " S5 nU R USUSS9u p4U R SU5 g )Nr� z
b 5;;c;;n
r� Tr� z-> b = 2r� r� s r �test_pdbrc_semicolon� PdbTestCase.test_pdbrc_semicolon�
sV � �� � � " �
�� ��� ! �
�� �,�,�V�U�%�UY�,�Z��� �
�
�j�&�)r c � � [ R " S5 n[ R " S5 nU R USUSS9u p4U R SU5 g )Nr� zK
b 6
commands 1 ;; p a;; end
c
r� Tr� z<__main__.A object atr� r� s r �test_pdbrc_commands� PdbTestCase.test_pdbrc_commands�
sW � �� � � " �
�� ��� ! �
�� �,�,�V�U�%�UY�,�Z��� �
�
�-�v�6r c �| � [ R " S5 nU R USSSS9u p#U R SU5 g )Nz$
print('hello')
r� �invalidTr� 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 � � [ R R SS 5 n[ R " 5 n[ S5 [ R R US5 nU[ R R l [ US5 nUR S5 S S S 5 U R [ R " 5 R S S5 Ub U[ R S' S S S 5 S S S 5 g ! , ( d f Ng= f! Ub U[ R S' f f = f! , ( d f ND= f! , ( d f g = f)Nr� zos.path.expanduserr� r� r� r )r� r� r� r �temp_dirr r r �
expanduser� return_valuer� r� r� rw rx �rcLines)r � save_homer� �rc_pathr� s r �test_readrc_homedir� PdbTestCase.test_readrc_homedir�
s� � ��J�J�N�N�6�4�0� �
�
�
�
!�X�u�5I�/J��g�g�l�l�8�X�6�G�.5�B�G�G� � � +�
3��'�3�'�1��G�G�I�&� (�� � �����!2�!2�1�!5�y�A� �(�)2�B�J�J�v�&� 0K�
!�
!� (�'�� �(�)2�B�J�J�v�&� )�� 0K�/J��
!�
!�sT � E �A D/� D�D�!:D�D/�1E �
D � D�D,�,D/�/
D= �9E �
Ec �p � [ 5 nSn[ 5 nUR [ SU5 5 UR [ R " [
R S5 5 [
R " US9 S S S 5 U R UR 5 US- 5 g ! , ( d f N2= f)Nz"Nobody expects... blah, blah, blahz
sys.stdout� set_trace)�headerr� )
r r �
enter_contextr �objectrw rx r� r� �getvalue)r r� r� � resourcess r � test_header�PdbTestCase.test_header�
s} � ����5��
�[�I� � #� #�E�,��$?� @� � #� #�E�L�L����+�$F� G� �M�M�� (� �
���� � �*�F�T�M�:� �[�s �A$B'�'
B5c � � SnSnU R X5 u p4U R [ S UR 5 5 5 U5 g )Nzprint("SUCCESS")�/
continue
quit
c 3 �, # � U H
nS U; v � M g7f��SUCCESSNr- rr s r ru �.PdbTestCase.test_run_module.<locals>.<genexpr>�
� � � �H�4G�q�I��N�4G�rw �r� rx ry rz r� s r �test_run_module�PdbTestCase.test_run_module�
sD � �'�� �� �,�,�V�>��� ����H�F�4E�4E�4G�H�H�&�Qr c � � SnSnU R X5 u p4U R [ S UR 5 5 5 U5 g )NzQ
if __name__ == '__main__':
print("SUCCESS")
r� c 3 �, # � U H
nS U; v � M g7fr� r- rr s r ru �9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>�
r� rw r� r� s r �test_module_is_run_as_main�&PdbTestCase.test_module_is_run_as_main�
sF � � �� �� �,�,�V�>��� ����H�F�4E�4E�4G�H�H�&�Qr c �� � SnU R SS/USS9 U R / SQU5 u p#U R SU5 U R / SQU5 u p#U R SU5 g ) Nz
continue
�calendarr� r0 �r� )r� r� �1�December)r� r� z--type�text)r� r9 �r r� r� r; s r �test_run_module_with_args�%PdbTestCase.test_run_module_with_args�
sd � � ��
�
�
�z�4�(�(��
�J��M�M�"9�8�D� �� �
�
�j�&�)��M�M�"F��Q� �� �
�
�j�&�)r c �X � SnSnU R XSS/S9u p4U R SU5 g )Nz@
import sys
print(sys.argv[1:])
r� z--barr" )r� z['--bar', 'foo']r8 r� s r �test_run_script_with_args�%PdbTestCase.test_run_script_with_args
s> � � �� ��
�,�,�V�G�UZ�K[�,�\��� �
�
�(�&�1r c �� � SnSnU R X5 u p4U R [ S UR 5 5 5 U5 U R [ S UR 5 5 5 U5 g )Nz{
if __name__ == '__main__':
pass
print("SUCCESS")
pass
z*
b 3
quit
c 3 �, # � U H
nS U; v � M g7f)zBreakpoint 1 atNr- rr s r ru �.PdbTestCase.test_breakpoint.<locals>.<genexpr># � � � �P�<O�q� -�� 2�<O�rw c 3 �, # � U H
nS U; v � M g7fr� r- rr s r ru r� $ s � � �L�8K�1�I�Q� .�8K�rw )r� rx ry rz �allr� s r �test_breakpoint�PdbTestCase.test_breakpoint si � � �� �� �,�,�V�>��� ����P�F�<M�<M�<O�P�P�RX�Y� ����L��8I�8I�8K�L�L�f�Ur c � � SnU R SS/U5 u p#U R [ R UR SS5 5 g )Nz(
c
quit
r� rw �
rj )r� r9 rw �_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 �F � Sn[ R " U5 US- n[ R " U5 [ US5 S S S 5 U R [ R U5 U R
SU/SSS9u p4U R SU5 g ! , ( d f NV= f) Nr� r� r� r� rj r r� z-ImportError: No module named t_main.__main__;)r r� r� r� r� r� r� r9 )r r� r� r� r� s r �test_module_without_a_main�&PdbTestCase.test_module_without_a_main1 s� � � � �����%� �.�0� �
���� �
�)�S�
!� � "� ��� �(�(�+�6� � � �
�;� ��� '�
���
�
�
�E�v�N�
"�
!�s � B�
B c �v � SnSn[ R " U5 US- U- n[ R " U5 [ US- S5 S S S 5 U R [ R U5 U R
SUR SS5 /SS S
9u pEU R S U5 g ! , ( d f Nf= f) N�t_pkgr� �/r� r� r� �.rj r r� z;'t_pkg.t_main' is a package and cannot be directly executed) r r� r� �makedirsr� r� r� r� r9 )r �pkg_namer� �modpathr� r� s r �test_package_without_a_main�'PdbTestCase.test_package_without_a_main> s� � ��� � �����"��S�.�;�.��
� � �G� �
�'�N�*�C�
0� � 1� ��� �(�(�(�3� � � �
�7�?�?�3��,� -�r�q� '�
���
�
�
� I� � �
1�
0�s �B*�*
B8c � � [ R R [ R 5 ( a eU R S[ R /SSS9u pU R
S[ R 3U5 g )Nr� rj r r� z ImportError: No module named )r� r r r r� r� r9 �r r� r� s r �test_nonexistent_module�#PdbTestCase.test_nonexistent_moduleN s` � ��7�7�>�>�)�"2�"2�3�3�3�3� � � ��i�.>�.>�'?��YZ� �[��� �
�
�5�i�6F�6F�5G�H�&�Qr c � � [ R " 5 nU R U/SSS9u p#U R SU S3U5 S S S 5 g ! , ( d f g = f)Nrj r r� zError: z is a directory)r r� r� r9 )r r� r� r� s r �test_dir_as_script� PdbTestCase.test_dir_as_scriptS sK � �
�
�
�
!�X� !�]�]�H�:�r�q�]� Q�N�F� �M�M�G�H�:�_�=�v� F� "�
!�
!�s �+A
�
Ac �� � U R S/SSS9u pU R SUR S5 S 5 U R / SQSSS9u pU R S UR S5 S 5 g )
Nz-crj r0 r� z8pdb: error: argument -c/--command: expected one argumentr� r )z--spamr� rw z*pdb: error: unrecognized arguments: --spam)r� r9 �splitr s r � test_invalid_cmd_line_options�)PdbTestCase.test_invalid_cmd_line_optionsX ss � � � � ��v�r�q� �I��� �
�
�P�SY�S_�S_�`d�Se�fg�Sh�i� � � �'>��XY� �Z��� �
�
�B�V�\�\�RV�EW�XY�EZ�[r c � � SnSnU R X5 u p4U R [ S UR 5 5 5 U5 g )NzY
#This is a comment, on line 2
print("SUCCESS")
z
quit
c 3 �, # � U H
nS U; v � M g7f)z__main__.py(4)<module>()Nr- rr s r ru �=PdbTestCase.test_blocks_at_first_code_line.<locals>.<genexpr>h s � � � ?�*=�Q� 7� � !�*=�rw r� r� s r � test_blocks_at_first_code_line�*PdbTestCase.test_blocks_at_first_code_line^ sQ � � ��
�� �,�,�V�>��� ���� ?�*0�*;�*;�*=� ?� ?�@F� Hr c �z � SnSnU R X5 u p4U R SU5 U R SU5 g )Nz$
print("hello")
z�
filename = $_frame.f_code.co_filename
f = open(filename, "w")
f.write("print('goodbye')")
import time; time.sleep(1)
f.close()
ll
�WARNING:�
was editedr8 r� s r �"test_file_modified_after_execution�.PdbTestCase.test_file_modified_after_executionk s@ � � ��
�� �,�,�V�>��� �
�
�j�&�)� �
�
�l�F�+r c �4 � SnSnSn[ US5 nUR [ R " U5 5 S S S 5 U R [
R U5 U R [
R S5 [ R U/n[ R " U[ R [ R [ R 0 [ R ESS0ES9 nUR [ R# U5 5 u pxS S S 5 W=( a [$ R' U5 nU R) WR* S 5 U R- S
U5 U R- S U5 g ! , ( d f GNE= f! , ( d f N= f) Nz�
import pdb; pdb.Pdb().set_trace()
with open(__file__, "w") as f:
f.write("print('goodbye')\n" * 5)
import time; time.sleep(1)
import pdb; pdb.Pdb().set_trace()
z3
continue
continue
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� r9 ) r r� r� r� r� r� r� r� r; s r �:test_file_modified_after_execution_with_multiple_instances�FPdbTestCase.test_file_modified_after_execution_with_multiple_instances~ s+ � � �� ��
��
�(�C�
�A�
�G�G�H�O�O�F�+� ,� !� ��� �(�(�(�3� ��� �(�(�-�8��~�~�x�(��
�
�
��!��� �o�o�!���A����A�%7��A�
� � �(�(����H�)=�>�I�F�
� �0�E�L�L�� 0�� ���� � �!�,� �
�
�j�&�)� �
�
�l�F�+�# !�
��
�
�s �&E7�)'F �7
F�
Fc � � SnSnU R X5 u p4U R SU5 U R SU5 U R SU5 g )Nz�
import random
# Any code with a source to step into so this script is not checked
# for changes when it's being changed
random.randint(1, 4)
print("hello")
aL
ll
n
s
filename = $_frame.f_back.f_code.co_filename
def change_file(content, filename):
with open(filename, "w") as f:
f.write(f"print({content})")
change_file('world', filename)
restart
ll
�hello�worldr 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 �V � SnSnU R X5 u p4U R SU5 g )NzZ
def foo():
raise ValueError("foo")
foo()
zX
continue
restart
continue
quit
�
Restartingr8 r� s r �test_post_mortem_restart�$PdbTestCase.test_post_mortem_restart� s2 � � �� �� �,�,�V�>��� �
�
�l�F�+r c �f � SU l [ R " U R 5 U R S- nU R S- nU R S- nU R [ R U R 5 [ R
" U R 5 [
US5 nUR [ R " S5 5 S S S 5 [
US5 nUR [ R " S5 5 S S S 5 [
US5 nUR [ R " S5 5 S S S 5 S nU R S
U R /U5 u pgU R [ S UR 5 5 5 U5 U R [ S UR 5 5 5 5 U R [ S
UR 5 5 5 5 g ! , ( d f GN4= f! , ( d f GN = f! , ( d f N�= f)Nr� 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 �, # � U H
nS U; v � M g7f�zVAR from moduleNr- rr s r ru �4PdbTestCase.test_relative_imports.<locals>.<genexpr>� r� rw c 3 �, # � U H
nS U; v � M g7f)z VAR from topNr- rr s r ru r) � s � � �M�9L�A�N�a� /�9L�rw c 3 �, # � U H
nS U; v � M g7f)z
second varNr- rr s r ru r) � s � � �K�7J�!�L�A� -�7J�rw �r� r r� r� r� r� r� r� r� r� r� rx ry rz �r r� r� � module_filer� r� r� r; 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�RX�Y� ����M��9J�9J�9L�M�M�N� ����K�v�7H�7H�7J�K�K�L�7 "�
!�� "�
!�� $�
#�s$ �+&G>�%&H� &H"�>
H
�
H �"
H0c � � SU l [ R " U R 5 U R S- nU R S- nU R S- nU R [ R U R 5 [ R
" U R 5 [
US5 nUR [ R " S5 5 S S S 5 [
US5 nUR [ R " S5 5 S S S 5 [
US5 nUR [ R " S5 5 S S S 5 S nU R S
U R S - /U5 u pgU R [ S UR 5 5 5 U5 g ! , ( d f N�= f! , ( d f N�= f! , ( d f N�= f)
Nr� z /runme.pyr� r% 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 �, # � U H
nS U; v � M g7fr( r- rr s r ru �DPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr> r� rw r, r- s r �%test_relative_imports_on_plain_module�1PdbTestCase.test_relative_imports_on_plain_module� sn � �#�������)�)�*��$�$�{�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�RX�Y�) "�
!�� "�
!��
$�
#�s$ �+&F#�%&F4� &G�#
F1�4
G�
Gc � � SR / SQ5 nU R SUS- 5 u p#U R UR 5 SS / SQ5 g )Nr� )zprint(]z debug print(zdebug doesnotexist�c�passr )
r� zU(Pdb) *** SyntaxError: closing parenthesis ']' does not match opening parenthesis '('�!(Pdb) ENTERING RECURSIVE DEBUGGERz%*** SyntaxError: '(' was never closed�LEAVING RECURSIVE DEBUGGERr9 z> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedr: �(Pdb) �r r� r� rz r� s r �test_errors_in_command�"PdbTestCase.test_errors_in_command sT � ��9�9�
� �� �'�'���4��@� �� ����*�*�,�Q�R�0� 3
� r c �6 ^ � U 4S jnU" SS5 U" SS5 g)z.do_run handles exceptions from parsing its argc � >� SR SU 3S/5 nTR SUS- 5 u p4TR UR 5 SS SSU SU 3S /5 g )
Nr� zrun �qr8 r r� z(Pdb) *** Cannot run z: r; r< )�bad_arg�msgr� r� r; r s �r �check�*PdbTestCase.test_issue34266.<locals>.check0 sx �� ��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 quotationNr- )r rD s ` r �test_issue34266�PdbTestCase.test_issue34266. s �� �
� �d�*�+�
�c�)�*r c �b � [ R " S5 nSn[ R " 5 nS[ R
R
U5 3nU R X5 u pVU R UR S5 S R S5 U5 SSS5 g! , ( d f g= f)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� r0 r� N) r� r� r �temp_cwdr� r �realpathr� r� r �rstrip)r r� r� �cwdr 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.c �� � [ R " S5 nSn[ R " 5 n[ R
R
U5 n[ R
R US5 n[ R
R US5 nSU 3n[ R " U5 [ [ R
R US5 S5 nUR U5 SSS5 [ R " U5 [ R " [ R
R US5 [ R
R US5 5 U R [ R
R SS5 /U5 u p�U R UR S 5 S
R S 5 U5 SSS5 g! , ( d f N�= f! , ( d f g= f) ziWhen running `python foo.py` sys.path[0] resolves symlinks. `python -m pdb foo.py` should behave the samerK rL �dir_one�dir_tworM �foo.pyr� Nr� r0 r� )r� r� r rN r� r rO r r� r� r� �symlinkr� r� r rP )
r r� r� rQ rU rV r r� r� r� s
r �test_issue42384_symlink�#PdbTestCase.test_issue42384_symlinkM sK � � � � � " �
�� ��
�
�
�
!�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� "�
!� <�;�� "�
!�s% �B%G�G�%CG�
G �G�
G$c � � [ R " S5 nSn[ R " 5 nU R XSS0S9u pES[
R R U5 3nU R Xd5 SSS5 g! , ( d f g= f)z5With safe_path set, pdb should not mangle sys.path[0]zk
import sys
import random
print('sys.path[0] is', sys.path[0])
zc
�PYTHONSAFEPATHr� )r� zsys.path[0] is N) r� r� r rN r� r� r rO re )r r� r� rQ r� r; �
unexpecteds r �test_safe_path�PdbTestCase.test_safe_pathf s� � � � � � " �
��
�� �
�
�
!�S� �+�+�F�IY�[^�H_�+�`�I�F�*�2�7�7�+;�+;�C�+@�*A�B�J� � � �Z� 0� "�
!�
!�s �AA?�?
B
c � � [ R " 5 n[ SS5 n[ R " S5 nUR U5 S S S 5 [ R R US5 n[ R " U5 [ R " [ R R US5 5 [ R R US5 n[ US5 nUR S5 S S S 5 U R S/S5 u pgSnU R UR S5 S R S
5 U5 S S S 5 g ! , ( d f GN= f! , ( d f Ns= f! , ( d f g = f) NrW 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 rN r� r� r� r� r� r r r� r� r� r rP ) r rQ r� �sra �
wrong_filer� r� r s r �test_issue42383�PdbTestCase.test_issue42383w 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�) "�
!�$�$�� '�&�� "�
!�s< �
E9�(E� B E9�)E(�;AE9�
E% � E9�(
E6 �2E9�9
Fc �| � Sn[ R " S5 nU R X5 u p4U R U5 g )Nz� 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 � � SnSnSn[ SS5 nUR [ R " U5 5 S S S 5 [ SS5 nUR [ R " U5 5 S S S 5 U R [
R S5 U R [
R S5 U R S/U5 u pVU R SUS5 g ! , ( d f N�= f! , ( d f N�= f) Nza
def func():
x = "Sentinel string for gh-93696"
print(x)
aL
import os
import sys
def _create_fake_frozen_module():
with open('gh93696.py') as f:
src = f.read()
# this function has a co_filename as if it were in a frozen module
dummy_mod = compile(src, "<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()
zf
break 20
continue
step
list
quit
z
gh93696.pyr� zgh93696_host.pyz"x = "Sentinel string for gh-93696"z Sentinel statement not found) r� r� r� r� r� r r� r� r9 )r �
frozen_src� host_programr� r� r� r� 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� ��� �(�(�*;�<� � � �(9�':�H�E��� �
�
�:�F�Db�c� %�
$�� *�
)�s �&C$�
&C5�$
C2�5
Dc � � SnSnU R X5 u p4U R SU5 U R X5 u p4U R SU5 g )Nrj r� z
main.py(0)z__main__.py(0))r� r9 r� r: s r �test_empty_file�PdbTestCase.test_empty_file� sO � ����� �'�'��9� �� �
�
�l�F�+��'�'��9� �� �
�
�&��/r c �P � [ R R [ R R [ 5 S5 n[ R
" U5 HK nUR
S5 ( d M U R [ R R X5 /S5 MM g )N�encoded_modulesz.pyrA )r� r r �dirnamerG �listdir�endswithr� )r �
script_dirr� s r �test_non_utf8_encoding�"PdbTestCase.test_non_utf8_encoding� sf � ��W�W�\�\�"�'�'�/�/�(�";�=N�O�
��
�
�:�.�H�� � ��'�'��
�
�r�w�w�|�|�J� A� B�C�H� /r c � � [ R " 5 n[ R " [ R R US5 5 [ R " S5 n[ [ R R USS5 S5 nUR U5 S S S 5 [ R " [ R R US5 [ R R US5 5 U R [ R R US5 /SR / SQ5 5 u pEU R SU5 U R S U5 S S S 5 g ! , ( d f N�= f! , ( d f g = f)
N�sourcezg
def f(x):
return x + 1
f(21 + 21)
z __main__.pyr� z
zipapp.pyzr� )zb fr7 zp xrA �42z return x + 1)r r� r� r� r r r� r� r� r� �zipapp�create_archiver� r9 )r r� r� r� r� r; 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�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�� "�
!�s% �A6E;� E*� CE;�*
E8 �4E;�;
F c �V � SnSnU R X5 u p4U R SU5 g )Nz�
def foo():
pass
class C:
def foo(self):
pass
z2
break C.foo
quit
z.The specified object 'C.foo' is not a functionr8 r� s r �test_issue_59000� PdbTestCase.test_issue_59000� s3 � � �� �� �,�,�V�>��� �
�
�F��Or )r� )r N)r NNNF)Lr' r( r) r* r� �unittest�skipIfr �flags� safe_pathr� r� r� r r
r r r# r) r- r3 r< rY rb rg rm 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/ r4 r= rH rR r �skip_unless_symlinkrY r^ rd rh rm rp rx r r� r, r- r r r� r� � s� � �+� �_�_�S�Y�Y�(�(�>�@� &'� � �@� �6 ,-�!%�#'� !�#(� �: A� F�9�
� �5�
�
�"
�
&�'1�R=�2
M� V�*";�HG�8 G�< � '� � '� �B� �B� F� )�< +� '� *�$,�$*� 7�$J� 3�;�R�
R�
*� 2�
V�
� O�� R�
G�
\� H�,�&!,�F -�>,�"#M�J Z�> �2+�
K� �"�"�K� #�K�01�"K�.!�&,d�\0�I� 2�.Pr r� c �2 � \ rS rSrS rS rS rS rS rSr g) �ChecklineTestsi c �. � [ R " 5 g r )� linecache�
clearcacher s r �setUp�ChecklineTests.setUp s � �� � � r c �L � [ R " [ R 5 g r r� r s r r� �ChecklineTests.tearDown r� r c � � [ [ R S5 nUR S5 S S S 5 [ R
" 5 nU R
UR [ R S5 S5 g ! , ( d f NT= f�Nr� z
print(123)r )r� r r� r� rw rx r� � checkline�r r� �dbs r � test_checkline_before_debugging�.ChecklineTests.test_checkline_before_debugging sZ � �
�)�"�"�C�
(�A�
�G�G�L� !� )�
�W�W�Y�� ���� � �i�&6�&6��:�A�>� )�
(�s �A;�;
B c �8 � [ [ R S5 nUR S5 S S S 5 [ R
" 5 nUR
5 U R UR [ R S5 S5 g ! , ( d f Nd= fr� ) r� r r� r� rw rx �resetr� r� r� s r �test_checkline_after_reset�)ChecklineTests.test_checkline_after_reset sc � �
�)�"�"�C�
(�A�
�G�G�L� !� )�
�W�W�Y��
���
� ���� � �i�&6�&6��:�A�>� )�
(�s �B �
Bc � � [ R " S5 n[ [ R S5 nUR U5 S S S 5 [
UR 5 5 S- n[ [ 5 5 [ R " 5 n[ U5 H2 nU R UR [ R U5 5 M4 S S S 5 g ! , ( d f N�= f! , ( d f g = f)Nz\
# Comment
""" docstring """
''' docstring '''
r� r0 )r� r� r� r r� r� �lenrz r r rw rx �rangerg r� )r rb 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 �C�:AC+�
C(�+
C9r- N)
r' r( r) r* r� r� r� r� r� r, r- r r r� r� s � � �+�?� ?�Ir r� c �B � \ rS rSr\S 5 rS rS rS rS r S r
Sr g )
�PdbTestReadlinei, c �f � [ S5 nUR S:X a [ R " S5 eg )N�readline�editlinez)libedit readline is not supported for pdb)r �backendr� �SkipTest)�clsr� s r �
setUpClass�PdbTestReadline.setUpClass/ s3 � � !��,�� � � �z� )��#�#�$O�P� P� *r c �� � [ R " S5 nSn[ X5 nU R SU5 U R SU5 U R SU5 U R SU5 g )Nz�
import pdb; pdb.Pdb().set_trace()
# Concatenate strings so that the output doesn't appear in the source
print('hello' + '!')
s
co ntin
s commandss conditions continues hello!�r� r� r
r9 �r r� r rl s r �test_basic_completion�%PdbTestReadline.test_basic_completion7 s^ � �� � � " �
�� "����'�� �
�
�k�6�*� �
�
�l�F�+� �
�
�k�6�*� �
�
�i��(r c �� � [ R " S5 nSnUS-
nUS-
nUS-
n[ X5 nU R SU5 U R SU5 U R SU5 g ) N�S
value = "speci"
import pdb; pdb.Pdb().set_trace()
s val + 'al'
s p val + 'es'
s $_fra
� c
� specials speciess $_framer� r� s r �test_expression_completion�*PdbTestReadline.test_expression_completionI sn � �� � � " �
�� "��
�$�$��
� � ��
������'�� �
�
�j�&�)� �
�
�j�&�)� �
�
�j�&�)r c �x � [ R " S5 nSnUS-
n[ X5 nU R SU5 g )Nr� s pri val + 'al')
r� r� r� r� s r �test_builtin_completion�'PdbTestReadline.test_builtin_completion^ s? � �� � � " �
�� (�� ������'�� �
�
�j�&�)r c �x � [ R " S5 nSnUS-
n[ X5 nU R SU5 g )Nz�
def f():
original = "I live Pythin"
import pdb; pdb.Pdb().set_trace()
f()
s orig .repl ('i', 'o')
r� s
I love Pythonr� r� s r �test_local_namespace�$PdbTestReadline.test_local_namespacen s@ � �� � � " �
�� -�� ������'�� �
�
�&��/r c � � [ R " S5 nSnUS-
nUS-
nUS-
nUS-
n[ X5 nU R SU5 g )Nz7
import pdb; pdb.Pdb().set_trace()
s def func():
s
ret 40 + 2
�
s fun ()
r� s 42r� r� s r �test_multiline_completion�)PdbTestReadline.test_multiline_completion� s[ � �� � � " �
�� !��
�$�$��
����
� � ��
������'�� �
�
�e�V�$r r- N) r' r( r) r* � classmethodr� r� r� r� r� r� r, r- r r r� r� , s1 � � �Q� �Q�)�$*�**� 0�$%r r� c �\ � SSK Jn UR [ R " U5 5 U$ )Nr )�test_pdb)�testr� �addTest�doctest� DocTestSuite)�loader�tests�patternr� s r �
load_testsr� � s! � � � �M�M�'�&�&�x�0�1� �Lr �__main__)mr� r� rw r �typesr1 r� r� r� r� r} �
contextlibr r �ior r� r � test.supportr r �test.support.import_helperr �test.support.pty_helperr
r �
unittest.mockr �has_socket_support�SKIP_ASYNCIO_TESTSr� r r/ r2 r7 r9 r; r= r? rA rC rE rI rK rM rO rQ rS r� �no_siterU rW rY r[ r] r_ ra rc re rg ri rk rm �
ModuleType�modrO �__dict__rp rr 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� �requires_subprocess�TestCaser� r� r� r� r' �mainr- r r �<module>r� s� �� � �
�
� �
� � � � �
� 1� � � 7� 4� 6� � "�4�4�4� �*�6� *�"�8W�r&�B�H"�H&�PA�F�4 �@ ��a�F'�R=�~G�R8�z �y�y���2 �hY�xN�b5�pG�T"�J"�J�*b�J?�D1�h�4�: ���'�(�� �=�s�|�|� L�,�^+�\?�
� �,>�@=�~ �: �x? �B9�v �, �\.�` �1 �f(�T1�f �D=�~&�P�2�:/�bD�L�8�2�(�"�" �>�.�6�01�f'�R1�h � � � �WP�(�#�#� WP� �WP�t""I�X�&�&� "I�J � � � �b%�h�'�'� b%� �b%�J� �z�� �M�M�O� r