✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

U

i�fp��@s�
dd
lZdd
l
Z
dd
lZdd
lZdd
lZdd
lZdd
lZdd
lZdd
lZddl	m
Z

ddlmZ
ddl
mZ
ddlmZ
ddlmZ
ddlmZ
dd	�ZGd
d�de�Zdd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Z e�!d�
Z"e#de"j$�
d d!�Z%d"d#�Z&d$d%�Z'd&d'�Z(d(d)�Z)d*d+�Z*d,d-�Z+d.d/�Z,d0d1�Z-d2d3�Z.d4d5�Z/d6d7�Z0d8d9�Z1d:d;�Z2d<d=�Z3d>d?�Z4Gd@dA�dAej5�Z6dBdC�Z7e8dDk�
r�e�9�
d
S)E�N)
�	ExitStack)
�StringIO)
�support)
�
_FakeInput)
�patch)
�
BreakpointcCsd
t_
it_dg
t_dS)N�
)r�nextZbplistZ
bpbynumber�r
r
�2/opt/alt/python38/lib64/python3.8/test/test_pdb.py�reset_Breakpoints


rc@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	�PdbTestInputz:Context manager that makes testing Pdb in doctests easier.cCs
|
|_dS�
N)
�input)�selfrr
r
r�__init__s
zPdbTestInput.__init__c

Cs0tj
|_t|j�
t_
ttd
�r&t��nd|_dS)N�gettrace)�sys�stdin�
real_stdinrr�hasattrr�
orig_trace�
rr
r
r�	__enter__"s


zPdbTestInput.__enter__c
Gs|jt
_|jrt
�|j�

dSr)rrrr�settrace)r�excr
r
r�__exit__'s


zPdbTestInput.__exit__N)�__name__�
__module__�__qualname__�__doc__rrrr
r
r
rr
s
r
c
Csd
S)a1This 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-s
r!c
Csd
S)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_commandsJs
r"c
Csd
S)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�s
r#c
CsdSrr
r
r
r
r�
do_nothingK
s
r$cCstd
�

dS)N�*)
�printr
r
r
r�do_somethingN
s
r'c
Csd
S)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_commandsQ
s
r(c
Csd
S)aITest 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�
s
r)c
Csd
S)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_mortem�
s
r*c
Csd
S)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+Zmodule_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonec
Csd
S)aAThis 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_callback4s
r,c
Csd
S)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_s
r-cCstt
jd
dd�|�|
�

dS)zRun pdb.method(arg).TF)ZnosigintZreadrcN)�getattr�pdb�Pdb)�method�argr
r
r�
pdb_invoke�sr3c
Csd
S)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�s
r4c
Csd
S)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�s
r5c
Csd
S)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�s
r6c
Csd
S)aXTesting 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_generator�s
r7c
Csd
S)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/s
r8c
Csd
S)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_asyncgengs
r9c
Csd
S)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�s
r:c
Csd
S)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_coroutine�s
r;c
Csd
S)a�Testing no unwindng stack on yield for generators
       for "until" command if target breakpoing 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_generators
r<c
Csd
S)aTesting no unwindng stack for coroutines
       for "until" command if target breakpoing 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_coroutine1s
r=c
Csd
S)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`s
r>c
Csd
S)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�s
r?c
Csd
S)a(Test for reference leaks when the SIGINT handler is set.

    >>> def test_function():
    ...     i = 1
    ...     while i <= 2:
    ...         sess = pdb.Pdb()
    ...         sess.set_trace(sys._getframe())
    ...         print('pdb %d: %s' % (i, sess._previous_sigint_handler))
    ...         i += 1

    >>> with PdbTestInput(['continue',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_issue_20766[0]>(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]>(5)test_function()
    -> sess.set_trace(sys._getframe())
    (Pdb) continue
    pdb 2: <built-in function default_int_handler>
    Nr
r
r
r
r�test_pdb_issue_20766�s
r@c@s
eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zej d9d:��
Z!d;d<�Z"d=S)>�PdbTestCasec

Cst�
tj�

dSr)r�unlink�TESTFNrr
r
r�tearDown�s
zPdbTestCase.tearDownc	Csz|�t
jd
�
tjddg|
}tj|tjtjtjd��}|�	t
�|�
�
\}}W5QRX|obt�
|�
}|opt�
|�
}||fS)N�__pycache__�-mr/��stdoutr�stderr)�
addCleanupr�rmtreer�
executable�
subprocess�Popen�PIPE�STDOUT�communicate�str�encode�bytes�decode)rZpdb_args�commands�cmd�procrHrIr
r
r�_run_pdb�s






�



zPdbTestCase._run_pdbc	CsFd
}t|d��}|�
t�|
�
�

W5QRX|�tj|�
|�|g
|�S)z3Run 'script' lines with pdb and the pdb 'commands'.�main.py�
w)�open�write�textwrap�dedentrJrrBrY)r�scriptrV�filename�
fr
r
r�run_pdb_script�s




zPdbTestCase.run_pdb_scriptc	Cs�d
|_t
�|j�

|jd}|jd}t�|j�

t|d��}W5QRXt|d��}|�t�|
�
�

W5QRX|�	t
j|j�
|�
d|jg|�S)z(Runs the script code as part of a module�t_main�/__main__.py�/__init__.pyr[rF)�module_namerrK�os�mkdirr\r]r^r_rJrY)rr`rV�	main_file�	init_filerbr
r
r�run_pdb_module�s












zPdbTestCase.run_pdb_modulec	CsXtt
jd
��}|�|
�

W5QRX|s*dn|dt
j|df}|�|t�|t
j��
dS)N�wbr
r)r\rrCr]�assertEqualr/Z
find_function)rZfile_contentZ	func_name�expectedrbr
r
r�_assert_find_function�s


�
�z!PdbTestCase._assert_find_functionc

Cs|�d
dd�
dS)N�Zfoo)
rprr
r
r�test_find_function_empty_files
z)PdbTestCase.test_find_function_empty_filec

Cs|�d
�
�dd�
dS)Nu@def foo():
    pass

def bœr():
    pass

def quux():
    pass
�bœr)rs��rprSrr
r
r�test_find_function_founds




�z$PdbTestCase.test_find_function_foundc

Cs|�d
�
d�
dd�
dS)NuV# coding: iso-8859-15
def foo():
    pass

def bœr():
    pass

def quux():
    pass
ziso-8859-15rs)rs�rurr
r
r�-test_find_function_found_with_encoding_cookies


�
�z9PdbTestCase.test_find_function_found_with_encoding_cookiec

Cs|�t
jd
��dd�
dS)Nudef bœr():
    pass
rs)rsr)rp�codecs�BOM_UTF8rSrr
r
r�!test_find_function_found_with_bom's



�z-PdbTestCase.test_find_function_found_with_bomc
	Csxtt
jd
��}
|
�d�

W5QRXtjddt
jg}tj|tjtjtj	d�}|�
|jj�

|�
d�
\}}|�d|d�
dS)	Nrmsprint("testing my pdb")
rFr/rGsquit
sSyntaxErrorz0Got a syntax error running test script under PDB)r\rrCr]rrLrMrNrOrPrJrH�closerQ�assertNotIn�rrbrWrXrHrIr
r
r�test_issue79641s





�


�zPdbTestCase.test_issue7964c
	Csrd
}
d}d}tdd��}|�
t�|�
�

W5QRX|�tjd�
|�|
|�\}}|�t	dd�|�
�D�
�
d�
dS)	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.pyr[c
ss|]}
d|
kV
qd
S)zmain.py(5)foo()->NoneNr
��.0�
lr
r
r�	<genexpr>asz.PdbTestCase.test_issue13183.<locals>.<genexpr>z+Fail to step into the caller after a return)r\r]r^r_rJrrBrc�
assertTrue�any�
splitlines)rr`rVZbarrbrHrIr
r
r�test_issue13183@s






�zPdbTestCase.test_issue13183c
	Cs�tt
jd
��}
|
�t�d�
�d�
�

W5QRXtjdt
jg}t	j
|t	jt	jt	jd�}|�
|jj�

|�d�
\}}|�d|��d�
dS)	Nrma

                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�-urGscont
�Error�*Got an error running test script under PDB�r\rrCr]r^r_rSrrLrMrNrOrPrJrHr|rQr}rUr~r
r
r�test_issue13120ds

�



�


�zPdbTestCase.test_issue13120c
	Cs�tt
jd
��}
|
�t�d�
�d�
�

W5QRXtjdt
jg}t	j
|t	jt	jt	jd�}|�
|jj�

|�d�
\}}|�d|��d�
dS)	Nrma�

                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�rGs
cont
cont
r�r�r�r~r
r
r�test_issue36250s
�



�


�zPdbTestCase.test_issue36250c
Cs6d
}
d}d}|�|
|�\}}|�
||d�||��
dS)Nzdef f: pass
�zSyntaxError:zE

Expected:
{}
Got:
{}
Fail to handle a syntax error in the debuggee.)rc�assertIn�format)rr`rVrorHrIr
r
r�test_issue16180�s




��zPdbTestCase.test_issue16180c
CsLd
}
d}|�|
|�\}}d�
dd�|��D�
�
}|�|d�
|�|d�
dS)Nzprint('hello')z[
            continue
            run a b c
            run d e f
            quit
        �

c
Ssg|]}
|
���qSr
)
�strip)r��
xr
r
r�
<listcomp>�sz/PdbTestCase.test_issue26053.<locals>.<listcomp>z#Restarting .* with arguments:
a b cz#Restarting .* with arguments:
d e f)rc�joinr�ZassertRegex)rr`rVrHrI�resr
r
r�test_issue26053�s



zPdbTestCase.test_issue26053c

Cs�t�
d
�
}
tj�dd�}z�t����
tdd��}|�d�

W5QRXtdd��}|�|
�

W5QRXt	j
dg}tj|tj
tj
tj
d�}|�$
|�d�
\}}|�d	|���
W5QRXW5QRXW5|dk	r�|tjd<XdS)
Nz_
            import pdb; pdb.Pdb(readrc=False).set_trace()

            print('hello')
        �HOME�.pdbrcr[zinvalid
rZrGsq
z(NameError: name 'invalid' is not defined)r^r_rh�environ�popr�temp_cwdr\r]rrLrMrNrOrQr}rU)rr`�	save_homerbrWrXrHrIr
r
r�test_readrc_kwarg�s,













�


�
zPdbTestCase.test_readrc_kwargc
Cs�tj
�d
d�}
t����}td�
�n
tj�|d�}|tjj_	z:t
|d��}|�d�

W5QRX|�t
��jdd�
W5|
dk	r�|
tj
d
<XW5QRXW5QRXdS)Nr�zos.path.expanduserr�r[Zinvalidr
)rhr�r�r�temp_dirr�pathr��
expanduserZreturn_valuer\r]rnr/r0ZrcLines)rr�r�Zrc_pathrbr
r
r�test_readrc_homedir�s









zPdbTestCase.test_readrc_homedirc
	Csdt�}
d
}t
��6}|�td|
��

|�t�tjd��

tj|d�

W5QRX|�|
�	�|d�
dS)Nz"Nobody expects... blah, blah, blahz
sys.stdout�	set_trace)
�headerr�)
rr�
enter_contextr�objectr/r0r�rn�getvalue)rrHr�Z	resourcesr
r
r�test_header�s






zPdbTestCase.test_headerc
Cs:d
}
d}|�|
|�\}}|�
tdd�|��D�
�
|�
dS)Nzprint("SUCCESS")�/
            continue
            quit
        c
ss|]}
d|
kV
qd
S��SUCCESSNr
r�r
r
rr��sz.PdbTestCase.test_run_module.<locals>.<genexpr>�rlr�r�r��rr`rVrHrIr
r
r�test_run_module�s


zPdbTestCase.test_run_modulec
Cs:d
}
d}|�|
|�\}}|�
tdd�|��D�
�
|�
dS)NzQ
            if __name__ == '__main__':
                print("SUCCESS")
        r�c
ss|]}
d|
kV
qd
Sr�r
r�r
r
rr��sz9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>r�r�r
r
r�test_module_is_run_as_main�s

z&PdbTestCase.test_module_is_run_as_mainc
CsXd
}
d}|�|
|�\}}|�
tdd�|��D�
�
|�
|�
tdd�|��D�
�
|�
dS)Nz{
            if __name__ == '__main__':
                pass
                print("SUCCESS")
                pass
        z*
            b 3
            quit
        c
ss|]}
d|
kV
qd
S)zBreakpoint 1 atNr
r�r
r
rr�sz.PdbTestCase.test_breakpoint.<locals>.<genexpr>c
ss|]}
d|
kV
qd
Sr�r
r�r
r
rr�
s)rlr�r�r��allr�r
r
r�test_breakpoints



zPdbTestCase.test_breakpointc
Cs2d
}
|�ddg|
�\}}|�
tj|�dd��
dS)Nz(
            c
            quit
        rFr/�

r�)rYr�r/Z_usage�replace)rrVrHrIr
r
r�test_run_pdb_with_pdbs




�z!PdbTestCase.test_run_pdb_with_pdbc
	Csld
}
t�
|
�

|
d}t�|
�

t|d��}W5QRX|�tj
|
�
|�d|
gd�\}}|�d|���
dS)Nrdrfr[rFr�z,ImportError: No module named t_main.__main__)	rrKrhrir\rJrYr�r�)rrgrkrbrHrIr
r
r�test_module_without_a_mains












�z&PdbTestCase.test_module_without_a_mainc
Cs:d
}
d}|�|
|�\}}|�
tdd�|��D�
�
|�
dS)NzY
                #This is a comment, on line 2

                print("SUCCESS")
        z
            quit
        c
ss|]}
d|
kV
qd
S)z__main__.py(4)<module>()Nr
r�r
r
rr�0s
�
�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
	Cs2
d
|_t
�|j�

|jd}
|jd}|jd}|�t
j|j�
t�|j�

t|d��}|�t�	d�
�

W5QRXt|
d��}|�t�	d�
�

W5QRXt|d��}|�t�	d�
�

W5QRXd	}|�
d
|jg|�\}}|�tdd�|�
�D�
�
|�
|�td
d�|�
�D�
�
�

|�tdd�|�
�D�
�
�

dS)Nrdrerf�
/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
        rFc
ss|]}
d|
kV
qd
S�zVAR from moduleNr
r�r
r
rr�Tsz4PdbTestCase.test_relative_imports.<locals>.<genexpr>c
ss|]}
d|
kV
qd
S)zVAR from topNr
r�r
r
rr�Usc
ss|]}
d|
kV
qd
S)z
second varNr
r�r
r
rr�Vs�rgrrKrJrhrir\r]r^r_rYr�r�r��rrjrkZmodule_filerbrVrH�
_r
r
r�test_relative_imports3s$
















z!PdbTestCase.test_relative_importsc
	Cs�d
|_t
�|j�

|jd}
|jd}|jd}|�t
j|j�
t�|j�

t|d��}|�t�	d�
�

W5QRXt|
d��}|�t�	d�
�

W5QRXt|d��}|�t�	d�
�

W5QRXd	}|�
d
|jdg|�\}}|�tdd
�|�
�D�
�
|�
dS)Nrdz	/runme.pyrfr�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
        rFz.runmec
ss|]}
d|
kV
qd
Sr�r
r�r
r
rr�uszDPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr>r�r�r
r
r�%test_relative_imports_on_plain_moduleXs 













z1PdbTestCase.test_relative_imports_on_plain_modulec
CsTd
�ddddg�
}
|�
d|
d
�\}}|�|��dd�dd	d
dd	dd
ddg	�
dS)Nr�zprint(zdebug print(zdebug doesnotexist�
cr�rz3(Pdb) *** SyntaxError: unexpected EOF while parsingz!(Pdb) ENTERING RECURSIVE DEBUGGERz-*** SyntaxError: unexpected EOF while parsingzLEAVING RECURSIVE DEBUGGERz> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedz(Pdb) )r�rcrnr�)rrVrHr�r
r
r�test_errors_in_commandws$




�






�z"PdbTestCase.test_errors_in_commandc
	Csdt�
d
�
}
d}t���D}dtj�|�
��}|�|
|�\}}|�|�	d�
d�
d�
|�
W5QRXdS)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)r^r_rr�rhr��realpathrcrn�split�rstrip)rr`rV�cwdrorHrIr
r
r�test_issue42384�s


zPdbTestCase.test_issue42384c


Cs�t�
d
�
}
d}t����}tj�|�
}tj�|d�}tj�|d�}d|��}t�|�

t	tj�|d�d��}|�
|
�

W5QRXt�|�

t�tj�|d�tj�|d��
|�tj�dd�g
|�\}}	|�
|�d�
d	�d
�
|�
W5QRXdS)ziWhen running `python foo.py` sys.path[0] resolves symlinks. `python -m pdb foo.py` should behave the samer�r��dir_one�dir_twor��foo.pyr[r�r�r�N)r^r_rr�rhr�r�r�rir\r]�symlinkrYrnr�r�)
rr`rVr�r�r�rorbrHrIr
r
r�test_issue42384_symlink�s












 z#PdbTestCase.test_issue42384_symlinkc
	
Cs�t�
���}
td
d��}t�d�
}|�|�

W5QRXtj�|
d�}t�	|�

t�	tj�|d��

tj�|d
�}t|d��}|�d�

W5QRX|�
d
g
d�\}}d}|�|�d�
d	�
d
�
|�
W5QRXdS)Nr�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�)rr�r\r^r_r]rhr�r�rirYrnr�r�)	rr�rb�
sr�Z
wrong_filerHrIror
r
r�test_issue42383�s











zPdbTestCase.test_issue42383N)#rrrrDrYrcrlrprrrvrxr{rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rZskip_unless_symlinkr�r�r
r
r
rrA�s>
	
$ 
		
%

rAcGs*d
dlm
}

t�t�
t�|
�
g}t�|�
S)Nr
)
�test_pdb)�testr��unittestZ	makeSuiterA�doctestZDocTestSuiteZ	TestSuite)�argsr�Zsuitesr
r
r�
load_tests�s


�r��__main__):r�rhr/r�typesryr�rMr^�
contextlibr�iorr�rZtest.test_doctestrZ
unittest.mockrZbdbrrr�r
r!r"r#r$r'r(r)r*r+�
ModuleType�mod�exec�__dict__r,r-r3r4r5r6r7r8r9r:r;r<r=r>r?r@ZTestCaserAr�r�mainr
r
r
r�<module>sh










k_*>

+*@;8=7*,/*/