shell bypass 403
o
a b�� � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
m Z m Z d dl
mZ d dlmZ d dlmZ d dlmZ G dd� de�Zd d
� Zd d � Zd
d� Zdd� Zdd� Zdd� Z dd� Z dd� Z dd� Z dd � Z d d � Z!d d � Z"e�#d!�Z$e%d"e$j&� d#d$� Z'd%d&� Z(d'd(� Z)d)d*� Z*d+d,� Z+d-d.� Z,d/d0� Z-d1d2� Z.d3d4� Z/d5d6� Z0d7d8� Z1d9d:� Z2d;d<� Z3d=d>� Z4d?d@� Z5dAdB� Z6dCdD� Z7G dEdF� dFej8�Z9G dGdH� dHej8�Z:dIdJ� Z;e<dKkr�e�=� dS dS )L� N)� ExitStack�redirect_stdout)�StringIO)� os_helper)�
_FakeInput)�patchc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � PdbTestInputz:Context manager that makes testing Pdb in doctests easier.c C s
|| _ d S �N)�input)�selfr
� r �6/usr/local/python-3.10/lib/python3.10/test/test_pdb.py�__init__ s
zPdbTestInput.__init__c C s6 t j| _t| j�t _tt d�rt �� | _d S d | _d S )N�gettrace)�sys�stdin�
real_stdinr r
�hasattrr �
orig_trace�r r r r
� __enter__ s "zPdbTestInput.__enter__c G s" | j t_| jrt�| j� d S d S r )r r r r �settrace)r �excr r r
�__exit__! s �zPdbTestInput.__exit__N)�__name__�
__module__� __qualname__�__doc__r r r r r r r
r s
r c C � dS )a1 This tests the custom displayhook for pdb.
>>> def test_function(foo, bar):
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... pass
>>> with PdbTestInput([
... 'foo',
... 'bar',
... 'for i in range(5): print(i)',
... 'continue',
... ]):
... test_function(1, None)
> <doctest test.test_pdb.test_pdb_displayhook[0]>(3)test_function()
-> pass
(Pdb) foo
1
(Pdb) bar
(Pdb) for i in range(5): print(i)
0
1
2
3
4
(Pdb) continue
Nr r r r r
�test_pdb_displayhook' � r c C r )a� 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', # 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]>(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]>(25)<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 r
�test_pdb_basic_commandsD r r! c C s dd l } | j�� d S )Nr )�bdbZ
BreakpointZclearBreakpoints)r" r r r
�reset_Breakpoint� s r# c C r )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',
... 'disable 1',
... 'ignore 1 10',
... 'condition 1 1 < 2',
... '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
... 'continue',
... ]):
... test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(3)test_function()
-> print(1)
(Pdb) break 3
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
(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) 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) continue
3
4
Nr r r r r
� test_pdb_breakpoint_commands� r r$ c C r )a; 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:94
(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 r
�:test_pdb_breakpoints_preserved_across_interactive_sessionsG r r% c C r )a� 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()
--Return--
> <doctest test.test_pdb.test_pdb_pp_repr_exc[2]>(2)test_function()->None
-> 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 r
�test_pdb_pp_repr_exc� r r& c C s d S r r r r r r
�
do_nothing� s r' c C s t d� d S )N�* )�printr r r r
� do_something� � r* c C r )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
... '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]>(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 r
�test_list_commands� r r, c C r )aI 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()
--Return--
> <doctest test.test_pdb.test_pdb_whatis_command[3]>(2)test_function()->None
-> 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 r
�test_pdb_whatis_command r r- c C r )a� 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
... '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]>(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]>(10)<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 r
�test_post_mortem5 r r. c C r )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',
... 'continue',
... ]):
... skip_module()
> <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 r
�test_pdb_skip_moduless r r/ Zmodule_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonec C r )aA 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',
... 'continue',
... ]):
... skip_module()
... pass # provides something to "step" to
> <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]>(10)<module>()
-> pass # provides something to "step" to
(Pdb) continue
Nr r r r r
�#test_pdb_skip_modules_with_callback� r r0 c C r )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
... 'next',
... 'break 7',
... 'continue',
... 'next',
... 'continue',
... 'continue',
... ]):
... test_function()
> <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 r
� test_pdb_continue_in_bottomframe� r r1 c C s t tjddd�| �|� dS )zRun pdb.method(arg).TF)ZnosigintZreadrcN)�getattr�pdb�Pdb)�method�argr r r
�
pdb_invoke� s r7 c C r )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 r
�$test_pdb_run_with_incorrect_argument� r r8 c C r )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 r
� test_pdb_run_with_code_object� r r9 c C r )a� Test that pdb stops after a next/until/return issued at a return debug event.
>>> def test_function_2():
... x = 1
... x = 2
>>> def test_function():
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
... test_function_2()
... test_function_2()
... test_function_2()
... end = 1
>>> 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]>(3)test_function()
-> test_function_2()
(Pdb) break test_function_2
Breakpoint 1 at <doctest test.test_pdb.test_next_until_return_at_return_event[0]>:1
(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 r
�&test_next_until_return_at_return_event r r: c C r )aX 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',
... 'next',
... 'next',
... 'step',
... 'step',
... 'continue']):
... test_function()
> <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 r
�#test_pdb_next_command_for_generatorO r r; c C r )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',
... 'next',
... 'next',
... 'next',
... 'step',
... 'continue']):
... test_function()
> <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 r
�#test_pdb_next_command_for_coroutine� r r< c C r )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',
... 'next',
... 'next',
... 'step',
... 'next',
... 'continue']):
... test_function()
> <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 r
�"test_pdb_next_command_for_asyncgen� r r= c C r )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',
... 'return',
... 'step',
... 'step',
... 'continue']):
... test_function()
> <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 r
�%test_pdb_return_command_for_generator� r r> c C r )a% 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',
... 'next',
... 'continue']):
... test_function()
> <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 r
�%test_pdb_return_command_for_coroutine6 r r? c C r )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',
... 'until 4',
... 'step',
... 'step',
... 'continue']):
... test_function()
> <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 r
�$test_pdb_until_command_for_generator` r r@ c C r )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',
... 'until 8',
... 'continue']):
... test_function()
> <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 r
�$test_pdb_until_command_for_coroutine� r rA c C r )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]>(3)test_function()
-> for i in test_gen():
(Pdb) break test_gen
Breakpoint 1 at <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>:1
(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 r
�+test_pdb_next_command_in_generator_for_loop� r rB c C r )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',
... 'next',
... 'next',
... 'next',
... 'continue']):
... test_function()
> <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 r
�!test_pdb_next_command_subiterator� r rC c C r )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]>(6)test_function()
-> print('pdb %d: %s' % (i, sess._previous_sigint_handler))
(Pdb) continue
pdb 1: <built-in function default_int_handler>
> <doctest test.test_pdb.test_pdb_issue_20766[0]>(6)test_function()
-> print('pdb %d: %s' % (i, sess._previous_sigint_handler))
(Pdb) continue
pdb 2: <built-in function default_int_handler>
Nr r r r r
�test_pdb_issue_20766 r rD c C r )aN 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]>(3)test_function()
-> print(1)
(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 r
�test_pdb_issue_43318- r rE c @ s e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z e!j"d=d>� �Z#d?d@� Z$dAS )B� PdbTestCasec C � t �t j� d S r �r �unlink�TESTFNr r r r
�tearDownL � zPdbTestCase.tearDownc C s� | � tjd� tjddg| }tj|tjtjtji t j
�ddi�d��}|� t �
|��\}}W d � n1 s8w Y |oCt�|�}|oJt�|�}||fS )N� __pycache__�-mr3 �PYTHONIOENCODING�utf-8��stdoutr �stderr�env)�
addCleanupr �rmtreer �
executable�
subprocess�Popen�PIPE�STDOUT�os�environ� communicate�str�encode�bytes�decode)r Zpdb_args�commands�cmd�procrR rS r r r
�_run_pdbO s � �zPdbTestCase._run_pdbc C sZ d}t |d��}|�t�|�� W d � n1 sw Y | �tj|� | �|g|�S )z3Run 'script' lines with pdb and the pdb 'commands'.�main.py�wN)�open�write�textwrap�dedentrU r rI rf )r �scriptrc �filename�fr r r
�run_pdb_script^ s �zPdbTestCase.run_pdb_scriptc C s� d| _ t�| j � | j d }| j d }t�| j � t|d��}W d � n1 s)w Y t|d��}|�t�|�� W d � n1 sFw Y | � tj| j � | �
d| j g|�S )z(Runs the script code as part of a module�t_main� /__main__.py� /__init__.pyrh NrN ) � module_namer rV r\ �mkdirri rj rk rl rU rf )r rm rc � main_file� init_filero r r r
�run_pdb_modulef s
� �zPdbTestCase.run_pdb_modulec C sl t tjd��
}|�|� W d � n1 sw Y |s d n |d tj|d f}| �|t�|tj�� d S )N�wbr � )ri r rJ rj � assertEqualr3 Z
find_function)r Z file_content� func_name�expectedro r r r
�_assert_find_functiont s ���z!PdbTestCase._assert_find_functionc C s | � ddd � d S )N� Zfoo)r~ r r r r
� test_find_function_empty_file} s z)PdbTestCase.test_find_function_empty_filec C s | � d�� dd� d S )Nu@ def foo():
pass
def bœr():
pass
def quux():
pass
� bœr)r� � �r~ r` r r r r
�test_find_function_found� s �z$PdbTestCase.test_find_function_foundc C s | � d�d�dd� d S )NuV # coding: iso-8859-15
def foo():
pass
def bœr():
pass
def quux():
pass
z iso-8859-15r� )r� � r� r r r r
�-test_find_function_found_with_encoding_cookie� s
�z9PdbTestCase.test_find_function_found_with_encoding_cookiec C s | � tjd�� dd� d S )Nu def bœr():
pass
r� )r� rz )r~ �codecs�BOM_UTF8r` r r r r
�!test_find_function_found_with_bom� s ��z-PdbTestCase.test_find_function_found_with_bomc C s� t tjd��
}|�d� W d � n1 sw Y tjddtjg}tj|tjtjtj d�}| �
|j j � |�
d�\}}| �d|d� d S ) Nry s print("testing my pdb")
rN r3 �rR r rS s quit
s SyntaxErrorz0Got a syntax error running test script under PDB)ri r rJ rj r rW rX rY rZ r[ rU rR �closer^ � assertNotIn�r ro rd re rR rS r r r
�test_issue7964� s ���zPdbTestCase.test_issue7964c C s� d}d}d}t dd��}|�t�|�� W d � n1 s w Y | �tjd� | �||�\}}| �t dd� |�
� D ��d� d S ) 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
zbar.pyrh c s � � | ]}d |v V qdS )zmain.py(5)foo()->NoneNr ��.0�lr r r
� <genexpr>� � � z.PdbTestCase.test_issue13183.<locals>.<genexpr>z+Fail to step into the caller after a return) ri rj rk rl rU r rI rp �
assertTrue�any�
splitlines)r rm rc Zbarro rR rS r r r
�test_issue13183� s ��zPdbTestCase.test_issue13183c C � t tjd��}|�t�d��d�� W d � n1 s w Y tjdtjg}t j
|t j t j t j i t
j�ddi�d�}| �|jj� |�d�\}}| �d |d
� d S ) Nry 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�-urO rP rQ s cont
� Error�*Got an error running test script under PDB�ri r rJ rj rk rl r` r rW rX rY rZ r[ r\ r] rU rR r� r^ r� r� r r r
�test_issue13120� s"
� � ��zPdbTestCase.test_issue13120c C r� ) Nry 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� rO rP rQ s
cont
cont
r� r� r� r� r r r
�test_issue36250� s" � ���zPdbTestCase.test_issue36250c C s6 d}d}d}| � ||�\}}| �||d�||�� d S )Nz def f: pass
� z SyntaxError:zE
Expected:
{}
Got:
{}
Fail to handle a syntax error in the debuggee.)rp �assertIn�format)r rm rc r} rR rS r r r
�test_issue16180 s �zPdbTestCase.test_issue16180c C sL d}d}| � ||�\}}d�dd� |�� D ��}| �|d� | �|d� d S )Nzprint('hello')z[
continue
run a b c
run d e f
quit
�
c S s g | ]}|� � �qS r )�strip)r� �xr r r
�
<listcomp>- s z/PdbTestCase.test_issue26053.<locals>.<listcomp>z#Restarting .* with arguments:
a b cz#Restarting .* with arguments:
d e f)rp �joinr� Z assertRegex)r rm rc rR rS �resr r r
�test_issue26053# s zPdbTestCase.test_issue26053c C s: t �d�}tj�dd �}z�t�� �l tdd��
}|�d� W d � n1 s'w Y tdd��
}|�|� W d � n1 sAw Y t j
dg}t j |t j
t j
t j
d�}|� |�d�\}}| �d |� W d � n1 sqw Y W d � n1 s�w Y W |d ur�|tjd< d S d S |d ur�|tjd< w )
Nz_
import pdb; pdb.Pdb(readrc=False).set_trace()
print('hello')
�HOME�.pdbrcrh zinvalid
rg r� s q
s( NameError: name 'invalid' is not defined)rk rl r\ r] �popr �temp_cwdri rj r rW rX rY rZ r^ r� )r rm � save_homero rd re rR rS r r r
�test_readrc_kwarg1 s<
� �
�� �� �� � z PdbTestCase.test_readrc_kwargc C s t j�dd �}t�� �l}td��O t j�|d�}|t jj_ z0t
|d��
}|� d� W d � n1 s3w Y | � t
�� jd d� W |d urM|t jd< n
|d urW|t jd< w W d � n1 sbw Y W d � d S W d � d S 1 szw Y d S )Nr� zos.path.expanduserr� rh �invalidr )r\ r] r� r �temp_dirr �pathr� �
expanduserZ return_valueri rj r{ r3 r4 ZrcLines)r r� r� Zrc_pathro r r r
�test_readrc_homedirQ s
�
�� �P�z PdbTestCase.test_readrc_homedirc C sx t � }d}t� � }|�td|�� |�t�tjd�� tj|d� W d � n1 s+w Y | �|� � |d � d S )Nz"Nobody expects... blah, blah, blahz
sys.stdout� set_trace)�headerr� )
r r �
enter_contextr �objectr3 r4 r� r{ �getvalue)r rR r� Z resourcesr r r
� test_header^ s �zPdbTestCase.test_headerc C �: d}d}| � ||�\}}| �tdd� |�� D ��|� d S )Nzprint("SUCCESS")�/
continue
quit
c s r� ��SUCCESSNr r� r r r
r� n r� z.PdbTestCase.test_run_module.<locals>.<genexpr>�rx r� r� r� �r rm rc rR rS r r r
�test_run_moduleg s "zPdbTestCase.test_run_modulec C r� )NzQ
if __name__ == '__main__':
print("SUCCESS")
r� c s r� r� r r� r r r
r� z r� z9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>r� r� r r r
�test_module_is_run_as_mainp s "z&PdbTestCase.test_module_is_run_as_mainc C sX d}d}| � ||�\}}| �tdd� |�� D ��|� | �tdd� |�� D ��|� d S )Nz{
if __name__ == '__main__':
pass
print("SUCCESS")
pass
z*
b 3
quit
c s r� )zBreakpoint 1 atNr r� r r r
r� � r� z.PdbTestCase.test_breakpoint.<locals>.<genexpr>c s s � | ]}d |vV qdS r� r r� r r r
r� � r� )rx r� r� r� �allr� r r r
�test_breakpoint| s
"zPdbTestCase.test_breakpointc C s2 d}| � ddg|�\}}| �tj|�dd�� d S )Nz(
c
quit
rN r3 �
r� )rf r� r3 Z_usage�replace)r rc rR rS r r r
�test_run_pdb_with_pdb� s
�z!PdbTestCase.test_run_pdb_with_pdbc C s� d}t �|� |d }t�|� t|d�� W d � n1 s w Y | �t j|� | �d|gd�\}}| �d|�� � d S )Nrq rs rh rN r� z,ImportError: No module named t_main.__main__) r rV r\ ru ri rU rf r� r� )r rt rw rR rS r r r
�test_module_without_a_main� s
��z&PdbTestCase.test_module_without_a_mainc C s� d}d}t �|� |d | }t�|� t|d d�� W d � n1 s&w Y | �t j|� | �d|�dd�gd�\}}| �d |� d S )
NZt_pkgrq �/rs rh rN �.r� z;'t_pkg.t_main' is a package and cannot be directly executed) r rV r\ �makedirsri rU rf r� r� )r Zpkg_namert �modpathrR rS r r r
�test_package_without_a_main� s
� �z'PdbTestCase.test_package_without_a_mainc C r� )NzY
#This is a comment, on line 2
print("SUCCESS")
z
quit
c s r� )z__main__.py(4)<module>()Nr r� r r r
r� � s � � �z=PdbTestCase.test_blocks_at_first_code_line.<locals>.<genexpr>r� r� r r r
� test_blocks_at_first_code_line� s ��z*PdbTestCase.test_blocks_at_first_code_linec C sn d| _ t�| j � | j d }| j d }| j d }| �tj| j � t�| j � t|d��}|�t� d�� W d � n1 s>w Y t|d��}|�t� d�� W d � n1 s[w Y t|d��}|�t� d�� W d � n1 sxw Y d }| �
d
| j g|�\}}| � t d d � |�
� D ��|� | � t d
d � |�
� D ��� | � t dd � |�
� D ��� d S )Nrq rr rs �
/module.pyrh �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
rN c s r� �zVAR from moduleNr r� r r r
r� � r� z4PdbTestCase.test_relative_imports.<locals>.<genexpr>c s r� )z VAR from topNr r� r r r
r� � r� c s r� )z
second varNr r� r r r
r� � r� �rt r rV rU r\ ru ri rj rk rl rf r� r� r� �r rv rw Z module_filero rc rR �_r r r
�test_relative_imports� s*
� � � z!PdbTestCase.test_relative_importsc C s: d| _ t�| j � | j d }| j d }| j d }| �tj| j � t�| j � t|d��}|�t� d�� W d � n1 s>w Y t|d��}|�t� d�� W d � n1 s[w Y t|d��}|�t� d�� W d � n1 sxw Y d }| �
d
| j d g|�\}}| � t d d
� |�
� D ��|� d S )Nrq z /runme.pyrs r� rh 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
rN z.runmec s r� r� r r� r r r
r� � r� zDPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr>r� r� r r r
�%test_relative_imports_on_plain_module� s&
� � �"z1PdbTestCase.test_relative_imports_on_plain_modulec C sB d� g d��}| �d|d �\}}| �|�� dd � g d�� d S )Nr� )zprint(z debug print(zdebug doesnotexist�c�passrz )
�-> passz+(Pdb) *** SyntaxError: '(' was never closed�!(Pdb) ENTERING RECURSIVE DEBUGGERz%*** SyntaxError: '(' was never closed�LEAVING RECURSIVE DEBUGGERr� z> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedr� �(Pdb) �r� rp r{ r� )r rc rR r� r r r
�test_errors_in_command s z"PdbTestCase.test_errors_in_commandc s$ � fdd�}|dd� |dd� dS )z.do_run handles exceptions from parsing its argc sV d� d| � �dg�}� �d|d �\}}� �|�� dd � dd| � d|� �d g� d S )
Nr� zrun �qr� rz r� z(Pdb) *** Cannot run z: r� r� )Zbad_arg�msgrc rR r� r r r
�check s �
�z*PdbTestCase.test_issue34266.<locals>.check�\zNo escaped character�"zNo closing quotationNr )r r� r r r
�test_issue34266 s
zPdbTestCase.test_issue34266c C sz t �d�}d}t�� �(}dtj�|�� �}| �||�\}}| �|� d�d �
d�|� W d � dS 1 s6w Y dS )zkWhen running `python foo.py` sys.path[0] is an absolute path. `python -m pdb foo.py` should behave the same�Q
import sys
print('sys.path[0] is', sys.path[0])
�c
q�(Pdb) sys.path[0] is r� � r� N) rk rl r r� r\ r� �realpathrp r{ �split�rstrip)r rm rc �cwdr} rR rS r r r
�test_issue42384) s
"�zPdbTestCase.test_issue42384c
C s t �d�}d}t�� �w}tj�|�}tj�|d�}tj�|d�}d|� �}t�|� t tj�|d�d��
}|�
|� W d � n1 sDw Y t�|� t� tj�|d�tj�|d�� | � tj�dd�g|�\}} | �
|�d �d
�d �|� W d � dS 1 s�w Y dS ) ziWhen running `python foo.py` sys.path[0] resolves symlinks. `python -m pdb foo.py` should behave the samer� r� �dir_one�dir_twor� �foo.pyrh Nr� r� r� )rk rl r r� r\ r� r� r� ru ri rj �symlinkrf r{ r� r� )
r rm rc r� r� r� r} ro rR rS r r r
�test_issue42384_symlink8 s
�
"�z#PdbTestCase.test_issue42384_symlinkc C s t �� �x}tdd��}t�d�}|�|� W d � n1 s w Y tj�|d�}t� |� t� tj�|d�� tj�|d�}t|d��
}|�d� W d � n1 sVw Y | �
dgd�\}}d}| � |� d�d �
d
�|� W d � d S 1 sw Y d S ) Nr� rh 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� ri rk rl rj r\ r� r� ru rf r{ r� r� ) r r� ro �sr� Z
wrong_filerR rS r} r r r
�test_issue42383Q s
�
� "�zPdbTestCase.test_issue42383N)%r r r rK rf rp rx 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 Zskip_unless_symlinkr� r� r r r r
rF K sD
$
%
rF c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d
� Zd S ) �ChecklineTestsc C s t �� d S r )� linecache�
clearcacher r r r
�setUpj r+ zChecklineTests.setUpc C rG r rH r r r r
rK m rL zChecklineTests.tearDownc C sX t tjd��
}|�d� W d � n1 sw Y t�� }| �|�tjd�d� d S �Nrh z
print(123)rz )ri r rJ rj r3 r4 r{ � checkline�r ro �dbr r r
� test_checkline_before_debuggingp s
�z.ChecklineTests.test_checkline_before_debuggingc C s` t tjd��
}|�d� W d � n1 sw Y t�� }|�� | �|�tjd�d� d S r� ) ri r rJ rj r3 r4 �resetr{ r� r� r r r
�test_checkline_after_resetv s �z)ChecklineTests.test_checkline_after_resetc C s� t �d�}ttjd��
}|�|� W d � n1 sw Y t|�� �d }tt � �� t
� � }t |�D ] }| �
|�tj|�� q6W d � d S 1 sNw Y d S )Nz\
# Comment
""" docstring """
''' docstring '''
rh r� )rk rl ri r rJ rj �lenr� r r r3 r4 �rangeZ assertFalser� )r r� ro Z num_linesr �linenor r r
� test_checkline_is_not_executable} s
� �"�z/ChecklineTests.test_checkline_is_not_executableN)r r r r� rK r r r r r r r
r� i s r� c G s2 ddl m} t�t�t�t�t�|�g}t�|�S )Nr )�test_pdb) �testr �unittestZ makeSuiterF r� �doctestZ DocTestSuiteZ TestSuite)�argsr Zsuitesr r r
�
load_tests� s �
r
�__main__)>r r\ r3 r �typesr� r
rX rk r� �
contextlibr r �ior Z test.supportr Ztest.test_doctestr Z
unittest.mockr r� r r r! r# r$ r% r& r' r* r, r- r. r/ �
ModuleType�mod�exec�__dict__r0 r1 r7 r8 r9 r: r; r< r= r> r? r@ rA rB rC rD rE ZTestCaserF r� r
r �mainr r r r
�<module> st jC _*>
+*@;8=7*,/*/ "%
�