�

��Vc�
��d�dd
lZdd
l
Z
dd
lZdd
lZdd
lZdd
lZdd
lZdd
lZdd
lZdd
l	Z	ddl
mZmZ
ddl
mZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
Gd�d	e��Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$ej%d�
�
Z&e'de&j(��
d�Z)d�Z*d�Z+d�Z,d�Z-d�Z.d�Z/d�Z0d �Z1d!�Z2d"�Z3d#�Z4d$�Z5d%�Z6d&�Z7d'�Z8d(�Z9d)�Z:d*�Z;ej<��Gd+�d,ej=����Z>Gd-�d.ej=��Z?d/�Z@eAd0krejB��
d
Sd
S)1�N)�	ExitStack�redirect_stdout)
�StringIO)
�support)
�	os_helper)
�
_FakeInput)
�patchc
�$�eZ
dZd
Zd�Zd�Zd�ZdS)�PdbTestInputz:Context manager that makes testing Pdb in doctests easier.c��|
|_dS�
N)
�input)�selfrs  �!D:\Python311\Lib\test\test_pdb.py�__init__zPdbTestInput.__init__s
����
�
�
�c
���tj
|_t|j�
�
t_
ttd
��rt
j��n
d|_dS)N�gettrace)�sys�stdin�
real_stdinrr�hasattrr�
orig_trace�
rs
 r�	__enter__zPdbTestInput.__enter__s@���)����t�z�*�*��	�,3�C��,D�,D�N�#�,�.�.�.�$����rc
�l�|jt_|jrtj|j�
�

dSdSr
)rrrr�settrace)r�excs  r�__exit__zPdbTestInput.__exit__"s7���O��	��?�
	*��L���)�)�)�)�)�
	*�
	*rN)�__name__�
__module__�__qualname__�__doc__rrr�rrrrsJ������D�D�
�
�
�O
�O
�O
�
*�*�*�*�*rrc
��d
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$rr�test_pdb_displayhookr&(����rc
��d
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$rr�test_pdb_basic_commandsr)Er'rc�@�d
dl}|j
���
dS)Nr)�bdb�
Breakpoint�clearBreakpoints)
r+s
 r�reset_Breakpointr.�s%���J�J�J��N�#�#�%�%�%�%�%rc
��d
S)azTest 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
    ...     'commands 10',  # out of range
    ...     'commands a',   # display help
    ...     'commands 4',   # already deleted
    ...     '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) commands 10
    *** cannot set commands: Breakpoint number 10 out of range
    (Pdb) commands a
    *** Usage: commands [bnum]
            ...
            end
    (Pdb) commands 4
    *** cannot set commands: Breakpoint 4 already deleted
    (Pdb) continue
    3
    4
    Nr$r$rr�test_pdb_breakpoint_commandsr0�r'rc
��d
S)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:97
    (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$rr�:test_pdb_breakpoints_preserved_across_interactive_sessionsr2S
r'rc
��d
S)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$rr�test_pdb_pp_repr_excr4�
r'rc
��dSr
r$r$rr�
do_nothingr6�
s���Drc�$�t
d
�
�

dS)N�*)
�printr$rr�do_somethingr:�
s��	�"�I�I�I�I�Irc
��d
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$rr�test_list_commandsr<�
r'rc
��d
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$rr�test_pdb_whatis_commandr>r'rc
��d
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$rr�test_post_mortemr@Ar'rc
��d
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$rr�test_pdb_skip_modulesrBr'r�module_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonec
��d
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$rr�#test_pdb_skip_modules_with_callbackrE�r'rc
��d
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$rr� test_pdb_continue_in_bottomframerG�r'rc�`�t
tjd
d���|��|
�
�

dS)zRun pdb.method(arg).TF)�nosigint�readrcN)�getattr�pdb�Pdb)�method�args  r�
pdb_invokerP�s1��9�G�C�G�T�%�0�0�0�&�9�9�#�>�>�>�>�>rc
��d
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$rr�$test_pdb_run_with_incorrect_argumentrR�r'rc
��d
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$rr�test_pdb_run_with_code_objectrTr'rc
��d
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$rr�&test_next_until_return_at_return_eventrVr'rc
��d
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$rr�#test_pdb_next_command_for_generatorrX[r'rc
��d
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$rr�#test_pdb_next_command_for_coroutinerZ�r'rc
��d
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$rr�"test_pdb_next_command_for_asyncgenr\�r'rc
��d
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$rr�%test_pdb_return_command_for_generatorr^r'rc
��d
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$rr�%test_pdb_return_command_for_coroutiner`Br'rc
��d
S)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$rr�$test_pdb_until_command_for_generatorrblr'rc
��d
S)aTesting no unwindng stack for coroutines
       for "until" command if target breakpoint is not reached

    >>> import asyncio

    >>> async def test_coro():
    ...     print(0)
    ...     await asyncio.sleep(0)
    ...     print(1)
    ...     await asyncio.sleep(0)
    ...     print(2)
    ...     await asyncio.sleep(0)
    ...     print(3)

    >>> async def test_main():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     await test_coro()

    >>> def test_function():
    ...     loop = asyncio.new_event_loop()
    ...     loop.run_until_complete(test_main())
    ...     loop.close()
    ...     asyncio.set_event_loop_policy(None)
    ...     print("finished")

    >>> with PdbTestInput(['step',
    ...                    '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$rr�$test_pdb_until_command_for_coroutinerd�r'rc
��d
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$rr�+test_pdb_next_command_in_generator_for_looprf�r'rc
��d
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$rr�!test_pdb_next_command_subiteratorrh�r'rc
��d
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

    >>> 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$rr�test_pdb_issue_20766rj r'rc
��d
S)aNecho 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$rr�test_pdb_issue_43318rl9r'rc
��d
S)a�See GH-91742

    >>> def test_function():
    ...    __author__ = "pi"
    ...    __version__ = "3.14"
    ...
    ...    def about():
    ...        '''About'''
    ...        print(f"Author: {__author__!r}",
    ...            f"Version: {__version__!r}",
    ...            sep=" ")
    ...
    ...    import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...    about()


    >>> reset_Breakpoint()
    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'step',
    ...     'next',
    ...     'next',
    ...     'jump 5',
    ...     'continue'
    ... ]):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(12)test_function()
    -> about()
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(5)about()
    -> def about():
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(7)about()
    -> print(f"Author: {__author__!r}",
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(8)about()
    -> f"Version: {__version__!r}",
    (Pdb) jump 5
    > <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(5)about()
    -> def about():
    (Pdb) continue
    Author: 'pi' Version: '3.14'
    Nr$r$rr�test_pdb_issue_gh_91742rnVr'rc
��d
S)a
See GH-94215

    Check that frame_setlineno() does not leak references.

    >>> def test_function():
    ...    def func():
    ...        def inner(v): pass
    ...        inner(
    ...             42
    ...        )
    ...
    ...    import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...    func()

    >>> reset_Breakpoint()
    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'step',
    ...     'next',
    ...     'next',
    ...     'jump 3',
    ...     'next',
    ...     'next',
    ...     'jump 3',
    ...     'next',
    ...     'next',
    ...     'jump 3',
    ...     'continue'
    ... ]):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(9)test_function()
    -> func()
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(2)func()
    -> def func():
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
    -> def inner(v): pass
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
    -> inner(
    (Pdb) jump 3
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
    -> def inner(v): pass
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
    -> inner(
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(5)func()
    -> 42
    (Pdb) jump 3
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
    -> def inner(v): pass
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
    -> inner(
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(5)func()
    -> 42
    (Pdb) jump 3
    > <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
    -> def inner(v): pass
    (Pdb) continue
    Nr$r$rr�test_pdb_issue_gh_94215rp�r'rc�@
�eZ
dZd
�Zejejjd��d'd�
��Z	d'd�
Z
d�Zd�Zd�Z
d	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$d �Z%d!�Z&d"�Z'e(j)d#���Z*d$�Z+d%�Z,d&S)(�PdbTestCasec
�B�t
j
tj�
�

dSr
�r�unlink�TESTFNrs
 r�tearDownzPdbTestCase.tearDown�������)�*�*�*�*�*rz'PYTHONSAFEPATH changes default sys.pathrc	�@�|�tjd
��
tjddg|
z}tj|t
jt
jt
jitj
�
ddi
�
���5}|�t�
|�
�
�
�
\}}ddd��
n#1swxYw

Y

|ot�|�
�
}|ot�|�
�
}|�|j|d|�d|����
||fS)	N�__pycache__�-mrL�PYTHONIOENCODING�utf-8��stdoutr�stderr�envzUnexpected return code
stdout: z	
stderr: )�
addCleanupr�rmtreer�
executable�
subprocess�Popen�PIPE�STDOUT�os�environ�communicate�str�encode�bytes�decode�assertEqual�
returncode)r�pdb_args�commands�expected_returncode�cmd�procrr�s        r�_run_pdbzPdbTestCase._run_pdb�sc
��	
���	�(�-�8�8�8��~�t�U�+�h�6��
�
��!�� �o�!�(�A���A�%7��A�A�
�
�
�	D
��!�-�-�c�j�j��.B�.B�C�C�N�F�F�	D
�	D
�	D
�	D
�	D
�	D
�	D
�	D
�	D
�	D
�	D
����	D
�	D
�	D
�	D
��0�E�L�L��0�0���0�E�L�L��0�0������O��I�v�I�I��I�I�	
�	
�	
�
�v�~�s�:1B7�7B;�>
B;c�
�d
}t
|d��5}|�
tj|
�
�
�
�

ddd��
n#1swxYw

Y

|�t
j|��
|�|g
||��S)z3Run 'script' lines with pdb and the pdb 'commands'.�main.py�
wN)�open�write�textwrap�dedentr�rrur�)r�scriptr�r��filename�
fs      r�run_pdb_scriptzPdbTestCase.run_pdb_script�s�����
�(�C�
 �
 �
	-�A�
�G�G�H�O�F�+�+�,�,�,�
	-�
	-�
	-�
	-�
	-�
	-�
	-�
	-�
	-�
	-�
	-����
	-�
	-�
	-�
	-����	�(�(�3�3�3��}�}�h�Z��3F�G�G�Gs�(A�A�
Ac��d
|_tj|j�
�

|jdz}|jdz}tj|j�
�

t|d��5}	ddd��
n#1swxYw

Y

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

ddd��
n#1swxYw

Y

|�	tj|j��
|�
d|jg|��S)z(Runs the script code as part of a module�t_main�/__main__.py�/__init__.pyr�Nr{)�module_namerr�r��mkdirr�r�r�r�r�r�)rr�r��	main_file�	init_filer�s      r�run_pdb_modulezPdbTestCase.run_pdb_module�sd
��#������)�*�*�*��$�~�5�	��$�~�5�	�
���!�"�"�"�
�)�S�
!�
!�
	�Q��
	�
	�
	�
	�
	�
	�
	�
	�
	�
	�
	����
	�
	�
	�
	�
�)�S�
!�
!�
	-�Q�
�G�G�H�O�F�+�+�,�,�,�
	-�
	-�
	-�
	-�
	-�
	-�
	-�
	-�
	-�
	-�
	-����
	-�
	-�
	-�
	-����	�(�$�*:�;�;�;��}�}�d�D�$4�5�x�@�@�@s$�
A,�,A0�3
A0�(B;�;B?�
B?c�8
�t
tjd
��5}|�|
�
�

ddd��
n#1swxYw

Y

|sdn|dtj|df}|�|tj|tj����
dS)N�wbr�
)r�rrvr�r�rL�
find_function)r�file_content�	func_name�expectedr�s     r�_assert_find_functionz!PdbTestCase._assert_find_function�s���
�)�"�D�
)�
)�
	"�Q�
�G�G�L�!�!�!�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"����
	"�
	"�
	"�
	"� (�
8�4�4��Q�K��)�8�A�;�
.8������c�'�	�9�3C�D�D�
	F
�
	F
�
	F
�
	F
�
	F
��=�A
�
A
c
�4�|�d
dd��
dS)Nr�foo)
r�rs
 r�test_find_function_empty_filez)PdbTestCase.test_find_function_empty_files ���"�"�3��t�4�4�4�4�4rc
�X�|�d
�
��dd��
dS)Nu@def foo():
    pass

def bœr():
    pass

def quux():
    pass
�bœr)r���r�r�rs
 r�test_find_function_foundz$PdbTestCase.test_find_function_founds:���"�"�	
��F�H�H���
	
�
	
�
	
�
	
�
	
rc
�Z�|�d
�
d�
�
dd��
dS)NuV# coding: iso-8859-15
def foo():
    pass

def bœr():
    pass

def quux():
    pass
ziso-8859-15r�)r��r�rs
 r�-test_find_function_found_with_encoding_cookiez9PdbTestCase.test_find_function_found_with_encoding_cookies>���"�"�

��F�=�����	
�	
�	
�	
�	
rc
�r�|�tjd
���zdd��
dS)Nudef bœr():
    pass
r�)r�r�)r��codecs�BOM_UTF8r�rs
 r�!test_find_function_found_with_bomz-PdbTestCase.test_find_function_found_with_bom$sF���"�"��O���F�H�H�

�
��
	
�	
�	
�	
�	
rc
��
�t
tjd
��5}
|
�d�
�

ddd��
n#1swxYw

Y

tjddtjg}t
j|tjtjtj	���}|�
|jj�
�

|�
d�
�
\}}|�d|d��
dS)	Nr�sprint("testing my pdb")
r{rL�rrr�squit
sSyntaxErrorz0Got a syntax error running test script under PDB)r�rrvr�rr�r�r�r�r�r�r�closer��assertNotIn�rr�r�r�rr�s      r�test_issue7964zPdbTestCase.test_issue7964.s
��
�)�"�D�
)�
)�
	4�Q�
�G�G�2�3�3�3�
	4�
	4�
	4�
	4�
	4�
	4�
	4�
	4�
	4�
	4�
	4����
	4�
	4�
	4�
	4��~�t�U�I�,<�=������?��/��$�����
	
�����)�*�*�*��)�)�)�4�4���������K�
	M
�
	M
�
	M
�
	M
�
	M
r�c
��d
}
d}|�|
|��\}}|p
d|p
dz}|�
d|d��
|�d|d��
dS)Nz�
            def do_testcmdwithnodocs(self, arg):
                pass

            import pdb
            pdb.Pdb.do_testcmdwithnodocs = do_testcmdwithnodocs
        zA
            continue
            help testcmdwithnodocs
        ��AttributeErrorzCCalling help on a command with no docs should be handled gracefullyz;*** No help for 'testcmdwithnodocs'; __doc__ string missingz<Calling help on a command with no docs should print an error)r�r��assertIn)rr�r�rr��outputs      r�test_issue46434zPdbTestCase.test_issue46434=s��������,�,�V�X�>�>�����,�B�6�<�R�0�����)�6�^�
	`
�
	`
�
	`
��
�
�S�U[�T�
	V
�
	V
�
	V
�
	V
�
	V
rc
�
�d
}
d}d}t
dd��5}|�
tj|�
�
�
�

ddd��
n#1swxYw

Y

|�t
jd��
|�|
|��\}}|�td�|�
��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
3�K
�|]}
d|
vV�

�	d
S)zmain.py(5)foo()->NoneNr$��.0�
ls  r�	<genexpr>z.PdbTestCase.test_issue13183.<locals>.<genexpr>ss(����J�J��'�1�,�J�J�J�J�J�Jrz+Fail to step into the caller after a return)r�r�r�r�r�rrur��
assertTrue�any�
splitlines)rr�r��barr�rr�s       r�test_issue13183zPdbTestCase.test_issue13183Rs
���������(�C�
 �
 �
	*�A�
�G�G�H�O�C�(�(�)�)�)�
	*�
	*�
	*�
	*�
	*�
	*�
	*�
	*�
	*�
	*�
	*����
	*�
	*�
	*�
	*����	�(�(�3�3�3��,�,�V�X�>�>��������J�J�f�6G�6G�6I�6I�J�J�J�J�J�9�	;�	;�	;�	;�	;s�(A�A�
Ac
	�:�t
tjd
��5}
|
�t	jd�
�
�d�
�
�
�

ddd��
n#1swxYw

Y

tjdtjg}tj
|tjtjtjitj�
ddi
�
���}|�|jj�
�

|�d�
�
\}}|�d	|d
��
dS)Nr�a

                import threading
                import pdb

                def start_pdb():
                    pdb.Pdb(readrc=False).set_trace()
                    x = 1
                    y = 1

                t = threading.Thread(target=start_pdb)
                t.start()�ascii�-ur|r}r~scont
�Error�*Got an error running test script under PDB�r�rrvr�r�r�r�rr�r�r�r�r�r�r�r�rr�r�r�r�s      r�test_issue13120zPdbTestCase.test_issue13120vsN
���)�"�D�
)�
)�	/�Q�
�G�G�H�O�
%�
�
�%�f�W�o�o�

/�

/�

/�	/�	/�	/�	/�	/�	/�	/�	/�	/�	/�	/����	/�	/�	/�	/��~�t�Y�%5�6������?��/��$�;�2�:�;�1�7�;�;�	����	
�����)�*�*�*��)�)�)�4�4��������6�E�
	G
�
	G
�
	G
�
	G
�
	G
��;A"�"A&�)
A&c
	�:�t
tjd
��5}
|
�t	jd�
�
�d�
�
�
�

ddd��
n#1swxYw

Y

tjdtjg}tj
|tjtjtjitj�
ddi
�
���}|�|jj�
�

|�d�
�
\}}|�d	|d
��
dS)Nr�a�

                import threading
                import pdb

                evt = threading.Event()

                def start_pdb():
                    evt.wait()
                    pdb.Pdb(readrc=False).set_trace()

                t = threading.Thread(target=start_pdb)
                t.start()
                pdb.Pdb(readrc=False).set_trace()
                evt.set()
                t.join()r�r�r|r}r~s
cont
cont
r�r�r�r�s      r�test_issue36250zPdbTestCase.test_issue36250�sL
��
�)�"�D�
)�
)�	.�Q�
�G�G�H�O�%���$�V�G�_�_�
.�
.�
.�	.�	.�	.�	.�	.�	.�	.�	.�	.�	.�	.����	.�	.�	.�	.� �~�t�Y�%5�6������?��/��$�=�R�Z�=�!3�W�=�=�	����	
�����)�*�*�*��)�)�/�:�:��������6�E�
	G
�
	G
�
	G
�
	G
�
	G
r�c
��d
}
d}d}|�|
|d���\}}|�
||d�||����
dS)Nzdef f: pass
r�zSyntaxError:r��
r�zE

Expected:
{}
Got:
{}
Fail to handle a syntax error in the debuggee.)r�r��format)rr�r�r�rr�s      r�test_issue16180zPdbTestCase.test_issue16180�sp�� ����!���,�,��H�!�-�
�
����	
�
�
�h��

=�
�V�H�f�
%�
%�	'�	'�	'�	'�	'rc
��d
}
d}|�|
|��\}}d�
d�|���D���
�
}|�|d��
|�|d��
dS)Nzprint('hello')z[
            continue
            run a b c
            run d e f
            quit
        �

c
�6�g|]}
|
�����Sr$)
�strip)r��
xs  r�
<listcomp>z/PdbTestCase.test_issue26053.<locals>.<listcomp>�s ��@�@�@�q������@�@�@rz#Restarting .* with arguments:
a b cz#Restarting .* with arguments:
d e f)r��joinr��assertRegex)rr�r�rr��ress      r�test_issue26053zPdbTestCase.test_issue26053�s���!�����,�,�V�X�>�>�����i�i�@�@�F�,=�,=�,?�,?�@�@�@�A�A������D�E�E�E�����D�E�E�E�E�Erc
�$�t
j
d
�
�
}
tj�dd��}	tj��5
tdd��5}|�d�
�

ddd��
n#1swxYw

Y

tdd��5}|�|
�
�

ddd��
n#1swxYw

Y

tj
dg}tj|tj
tj
tj
���}|5
|�d�
�
\}}|�d	|��
ddd��
n#1swxYw

Y

ddd��
n#1swxYw

Y

|�|tjd<dSdS#|�|tjd<wxYw
)
Nz_
            import pdb; pdb.Pdb(readrc=False).set_trace()

            print('hello')
        �HOME�.pdbrcr�zinvalid
r�r�sq
s(NameError: name 'invalid' is not defined)r�r�r�r��popr�temp_cwdr�r�rr�r�r�r�r�r�)rr��	save_homer�r�r�rr�s        r�test_readrc_kwargzPdbTestCase.test_readrc_kwarg�s�����"�
�
���J�N�N�6�4�0�0�	�	/��#�%�%�
*�
*��(�C�(�(�
)�A��G�G�K�(�(�(�
)�
)�
)�
)�
)�
)�
)�
)�
)�
)�
)����
)�
)�
)�
)��)�S�)�)�
$�Q��G�G�F�O�O�O�
$�
$�
$�
$�
$�
$�
$�
$�
$�
$�
$����
$�
$�
$�
$��~�y�1��!�'��%�?�$�/�%�?�	�����*�*�%)�%5�%5�f�%=�%=�N�F�F��$�$�%P�"(�
*�
*�
*�*�*�*�*�*�*�*�*�*�*�*����*�*�*�*�
*�
*�
*�
*�
*�
*�
*�
*�
*�
*�
*����
*�
*�
*�
*�(�

/�%.��
�6�"�"�"�

/�

/��y�

/�%.��
�6�"�.�.�.�.s��E<�	E�A<�0E�<B	�E�
B	�E�B9�-E�9B=	�=E�
B=	�
A	E�
/E�9E�E		�	E�
E		�
E�E<�E � E<�#
E �$E<�<Fc
��tj
�d
d��}
tj��5}td�
�
5
tj�|d��}|tjj_		t|d��5}|�d�
�

ddd��
n#1swxYw

Y

|�tj��jdd��
|
�|
tj
d
<n#|
�|
tj
d
<wxYw
ddd��
n#1swxYw

Y

ddd��
dS#1swxYw

Y

dS)Nr�zos.path.expanduserr�r��invalidr)r�r�r�r�temp_dirr	�pathr��
expanduser�return_valuer�r�r�rLrM�rcLines)rr�r��rc_pathr�s     r�test_readrc_homedirzPdbTestCase.test_readrc_homedir�s�
���J�N�N�6�4�0�0�	�
�
�
!�
!�		3�X�u�5I�/J�/J�		3�		3��g�l�l�8�X�6�6�G�.5�B�G��+�
3��'�3�'�'�
'�1��G�G�I�&�&�&�
'�
'�
'�
'�
'�
'�
'�
'�
'�
'�
'����
'�
'�
'�
'�� � �����!2�1�!5�y�A�A�A��
3�)2�B�J�v�&����
3�)2�B�J�v�&�2�2�2�2�		3�		3�		3�		3�		3�		3�		3�		3�		3�		3�		3����		3�		3�		3�		3�		3�		3�		3�		3�		3�		3�		3�		3�		3�		3�		3�		3����		3�		3�		3�		3�		3�		3sq�D7�7D�<C=�B.�"C=�.B2�2C=�5
B2�65C=�+D�=D�D�D7�D#	�#D7�&
D#	�'D7�7D;�>
D;c
	�|�t
j
d
�
�
}
tj�dd��}	tj��5
tddd���5}|�d�
�

ddd��
n#1swxYw

Y

tddd���5}|�|
�
�

ddd��
n#1swxYw

Y

tj
dg}d	d
i
}tjdkrd|d
<tj
|tjtjtjitj�
|�
���}|5
|�d�
�
\}}|�d|��
ddd��
n#1swxYw

Y

ddd��
n#1swxYw

Y

|�|tjd<dSdS#|�|tjd<wxYw
)NzR
            import pdb; pdb.Pdb().set_trace()
            print('hello')
        r�r�r�r})
�encodingu	Françaisr�r|r��win32znon-empty-string�PYTHONLEGACYWINDOWSSTDIOr~sc
siUnicodeEncodeError: 'ascii' codec can't encode character '\xe7' in position 21: ordinal not in range(128))r�r�r�r�r�rr�r�r�rr��platformr�r�r�r�r�)	rr�r�r�r�r�r�rr�s	         r�#test_read_pdbrc_with_ascii_encodingz/PdbTestCase.test_read_pdbrc_with_ascii_encoding�s�����"�
�
���J�N�N�6�4�0�0�	�	/��#�%�%�
b
�
b
��(�C�'�:�:�:�
-�a��G�G�O�,�,�,�
-�
-�
-�
-�
-�
-�
-�
-�
-�
-�
-����
-�
-�
-�
-��)�S�7�;�;�;�
$�q��G�G�F�O�O�O�
$�
$�
$�
$�
$�
$�
$�
$�
$�
$�
$����
$�
$�
$�
$��~�y�1��)�7�3���<�7�*�
I
�6H�C�2�3�!�'��%�?�$�/�%�?�-�2�:�-��-������b
�b
�%)�%5�%5�f�%=�%=�N�F�F��M�M�
#Y
�Z`�
b
�
b
�
b
�b
�b
�b
�b
�b
�b
�b
�b
�b
�b
�b
����b
�b
�b
�b
�%
b
�
b
�
b
�
b
�
b
�
b
�
b
�
b
�
b
�
b
�
b
����
b
�
b
�
b
�
b
�0�

/�%.��
�6�"�"�"�

/�

/��y�

/�%.��
�6�"�.�.�.�.s��F(�	F�A>�2F�>B	�F�
B	�F�B=�1F�=C
	�
F�
C
	�A1F�6/E1�%F�1E5	�5F�8
E5	�9F�<F(�F�F(�
F�F(�(F;c
�
�t
��}
d
}t��5}|�td|
���
�

|�tjt
jd���
�

tj|��
�

ddd��
n#1swxYw

Y

|�|
�	��|dz��
dS)Nz"Nobody expects... blah, blah, blahz
sys.stdout�	set_trace)
�headerr�)
rr�
enter_contextr	�objectrLrMr

r��getvalue)rrr
�	resourcess    r�test_headerzPdbTestCase.test_headers�������5��
�[�[�	)�I��#�#�E�,��$?�$?�@�@�@��#�#�E�L���+�$F�$F�G�G�G��M��(�(�(�(�	)�	)�	)�	)�	)�	)�	)�	)�	)�	)�	)����	)�	)�	)�	)�	
������*�*�F�T�M�:�:�:�:�:s�A+B�B�
Bc
��d
}
d}|�|
|��\}}|�
td�|���D���
�
|��
dS)Nzprint("SUCCESS")�/
            continue
            quit
        c
3�K
�|]}
d|
vV�

�	d
S��SUCCESSNr$r�s  rr�z.PdbTestCase.test_run_module.<locals>.<genexpr>*�&����H�H�q�I��N�H�H�H�H�H�Hr�r�r�r�r��rr�r�rr�s     r�test_run_modulezPdbTestCase.test_run_module#sf��'�����,�,�V�X�>�>��������H�H�F�4E�4E�4G�4G�H�H�H�H�H�&�Q�Q�Q�Q�Qrc
��d
}
d}|�|
|��\}}|�
td�|���D���
�
|��
dS)NzQ
            if __name__ == '__main__':
                print("SUCCESS")
        r
c
3�K
�|]}
d|
vV�

�	d
Sr
r$r�s  rr�z9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>6r
rr
r
s     r�test_module_is_run_as_mainz&PdbTestCase.test_module_is_run_as_main,sh�������,�,�V�X�>�>��������H�H�F�4E�4E�4G�4G�H�H�H�H�H�&�Q�Q�Q�Q�Qrc
�<
�d
}
d}|�|
|��\}}|�
td�|���D���
�
|��
|�
t	d�|���D���
�
|��
dS)Nz{
            if __name__ == '__main__':
                pass
                print("SUCCESS")
                pass
        z*
            b 3
            quit
        c
3�K
�|]}
d|
vV�

�	d
S)zBreakpoint 1 atNr$r�s  rr�z.PdbTestCase.test_breakpoint.<locals>.<genexpr>D�(����P�P�q�-��2�P�P�P�P�P�Prc
3�K
�|]}
d|
v
V�

�	d
Sr
r$r�s  rr�z.PdbTestCase.test_breakpoint.<locals>.<genexpr>Es'����L�L�1�I�Q�.�L�L�L�L�L�Lr)r�r�r�r��allr
s     r�test_breakpointzPdbTestCase.test_breakpoint8s��������,�,�V�X�>�>��������P�P�F�<M�<M�<O�<O�P�P�P�P�P�RX�Y�Y�Y�����L�L��8I�8I�8K�8K�L�L�L�L�L�f�U�U�U�U�Urc
��d
}
|�ddg|
��\}}|�
tj|�dd����
dS)Nz(
            c
            quit
        r{rL�

r�)r�r�rL�_usage�replace)rr�rr�s    r�test_run_pdb_with_pdbz!PdbTestCase.test_run_pdb_with_pdbGs\��������e�}�h�?�?�����
�
��J��N�N�4��$�$�	
�	
�	
�	
�	
rc
�
�d
}
t
j
|
�
�

|
dz}tj|
�
�

t	|d��5
	ddd��
n#1swxYw

Y

|�tj
|
��
|�d|
gdd���\}}|�d|�����
dS)	Nr�r�r�r{r�r�r�z,ImportError: No module named t_main.__main__)	rr�r�r�r�r�r�r�r�)rr�r�rr�s     r�test_module_without_a_mainz&PdbTestCase.test_module_without_a_mainRs

�������%�%�%��.�0�	�
������
�)�S�
!�
!�
	�
	��
	�
	�
	�
	�
	�
	�
	�
	�
	�
	�
	����
	�
	�
	�
	����	�(�+�6�6�6����
�;����'�
�
����	
�
�
�D��'�'�)�)�
	+�
	+�
	+�
	+�
	+s�
A�A�
Ac
�
�d
}
d}t
j
|
�
�

|
dz|z}tj|�
�

t	|dzd��5
	ddd��
n#1swxYw

Y

|�tj
|
��
|�d|�dd��gdd	�
��\}}|�d|��
dS)N�t_pkgr��
/r�r�r{�
.r�r�r�z;'t_pkg.t_main' is a package and cannot be directly executed)	rr�r��makedirsr�r�r�r&
r�)r�pkg_namer��modpathrr�s      r�test_package_without_a_mainz'PdbTestCase.test_package_without_a_main`s
���������"�"�"��S�.�;�.��
��G����
�'�N�*�C�
0�
0�
	�
	��
	�
	�
	�
	�
	�
	�
	�
	�
	�
	�
	����
	�
	�
	�
	����	�(�(�3�3�3����
�7�?�?�3��,�,�-�r�q�'�
�
����	
�
�
�I��	�	�	�	�	s�
A�A�
Ac
��d
}
d}|�|
|��\}}|�
td�|���D���
�
|��
dS)NzY
                #This is a comment, on line 2

                print("SUCCESS")
        z
            quit
        c
3�K
�|]}
d|
vV�

�	d
S)z__main__.py(4)<module>()Nr$r�s  rr�z=PdbTestCase.test_blocks_at_first_code_line.<locals>.<genexpr>zs>����
?�
?�%&�7� �
!�
?�
?�
?�
?�
?�
?rr
r
s     r�test_blocks_at_first_code_linez*PdbTestCase.test_blocks_at_first_code_lineps�����
���,�,�V�X�>�>��������
?�
?�*0�*;�*;�*=�*=�
?�
?�
?�
?�
?�@F�
	H
�
	H
�
	H
�
	H
�
	H
rc
��d
|_tj|j�
�

|jdz}
|jdz}|jdz}|�tj|j��
t	j|j�
�

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

ddd��
n#1swxYw

Y

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

ddd��
n#1swxYw

Y

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

ddd��
n#1swxYw

Y

d	}|�
d
|jg|��\}}|�td�|�
��D���
�
|��
|�td�|�
��D���
�
�
�

|�td
�|�
��D���
�
�
�

dS)Nr�r�r��
/module.pyr��6
                top_var = "VAR from top"
            z�
                from . import top_var
                from .module import var
                from . import module
                pass # We'll stop here and print the vars
            zY
                var = "VAR from module"
                var2 = "second var"
            zz
            b 5
            c
            p top_var
            p var
            p module.var2
            quit
        r{c
3�K
�|]}
d|
vV�

�	d
S�zVAR from moduleNr$r�s  rr�z4PdbTestCase.test_relative_imports.<locals>.<genexpr>�r
rc
3�K
�|]}
d|
vV�

�	d
S)zVAR from topNr$r�s  rr�z4PdbTestCase.test_relative_imports.<locals>.<genexpr>�s'����M�M�A�N�a�/�M�M�M�M�M�Mrc
3�K
�|]}
d|
vV�

�	d
S)z
second varNr$r�s  rr�z4PdbTestCase.test_relative_imports.<locals>.<genexpr>�s'����K�K�!�L�A�-�K�K�K�K�K�Kr�r�rr�r�r�r�r�r�r�r�r�r�r�r��rr�r��module_filer�r�r�
_s        r�test_relative_importsz!PdbTestCase.test_relative_imports}s���#������)�*�*�*��$�~�5�	��$�~�5�	��&��5�����	�(�$�*:�;�;�;�
���!�"�"�"�
�)�S�
!�
!�	�Q�
�G�G�H�O�%���
�
�
�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	��)�S�
!�
!�	�Q�
�G�G�H�O�%���
�
�
�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	��+�s�
#�
#�	�q�
�G�G�H�O�%���
�
�
�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	�
���M�M�4��)9�":�H�E�E�	��
�����P�P�F�<M�<M�<O�<O�P�P�P�P�P�RX�Y�Y�Y�����M�M��9J�9J�9L�9L�M�M�M�M�M�N�N�N�����K�K�v�7H�7H�7J�7J�K�K�K�K�K�L�L�L�L�L�6�
(C
�
C�
C�(D�D�
D�+(E�E#�&
E#c
��d
|_tj|j�
�

|jdz}
|jdz}|jdz}|�tj|j��
t	j|j�
�

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

ddd��
n#1swxYw

Y

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

ddd��
n#1swxYw

Y

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

ddd��
n#1swxYw

Y

d	}|�
d
|jdzg|��\}}|�td�|�
��D���
�
|��
dS)
Nr�z	/runme.pyr�r6
r�r7
zl
                from . import module
                pass # We'll stop here and print the vars
            z5
                var = "VAR from module"
            zQ
            b 3
            c
            p module.var
            quit
        r{z.runmec
3�K
�|]}
d|
vV�

�	d
Sr9
r$r�s  rr�zDPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr>�r
rr<
r=
s        r�%test_relative_imports_on_plain_modulez1PdbTestCase.test_relative_imports_on_plain_module�s���#������)�*�*�*��$�{�2�	��$�~�5�	��&��5�����	�(�$�*:�;�;�;�
���!�"�"�"�
�)�S�
!�
!�	�Q�
�G�G�H�O�%���
�
�
�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	��)�S�
!�
!�	�Q�
�G�G�H�O�%���
�
�
�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	�
�+�s�
#�
#�	�q�
�G�G�H�O�%���
�
�
�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	����M�M�4��)9�H�)D�"E�x�P�P�	��
�����P�P�F�<M�<M�<O�<O�P�P�P�P�P�RX�Y�Y�Y�Y�YrA
c
���d
�gd�
�
�
}
|�
d|
d
z��\}}|�|���dd�gd�
��
dS)Nr�)zprint(zdebug print(zdebug doesnotexist�
c�passr�)
�-> passz+(Pdb) *** SyntaxError: '(' was never closed�!(Pdb) ENTERING RECURSIVE DEBUGGERz%*** SyntaxError: '(' was never closed�LEAVING RECURSIVE DEBUGGERrI
z> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedrJ
�(Pdb) �r�r�r�r�)rr�rr?
s    r�test_errors_in_commandz"PdbTestCase.test_errors_in_command�s����9�9�
�
�
�����'�'���4��@�@�	��
�����*�*�,�,�Q�R�R�0�
3
�
3
�
3
�
	�
	�
	�
	�
	rc
�B���f
d
�}
|
dd��
|
dd��
dS)z.do_run handles exceptions from parsing its argc���
�d
�d|��dg�
�
}��
d|d
z��\}}��|���dd�dd|�d|
��d	g��
dS)
Nr�zrun �
qrG
r�rH
z(Pdb) *** Cannot run z: rK
rL
)�bad_arg�msgr�rr?
rs     �r�checkz*PdbTestCase.test_issue34266.<locals>.check�s�����y�y� �w� � ��"���H��+�+�F�H�t�O�D�D�I�F�A����V�.�.�0�0����4��8��8�8�3�8�8��7�
�
�
�
�
r�
\zNo escaped character�
"zNo closing quotationNr$)rrS
s` r�test_issue34266zPdbTestCase.test_issue34266�sJ���
	�
	�
	�
	�
	�	��d�*�+�+�+�
��c�)�*�*�*�*�*rc
�
�t
j
d
�
�
}
d}tj��5}dtj�|�
�
��}|�|
|��\}}|�|�	d�
�
d�
d�
�
|��
ddd��
dS#1swxYw

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)r�r�rr�r�r��realpathr�r��split�rstrip)rr�r��cwdr�rr�s       r�test_issue42384zPdbTestCase.test_issue42384�s

����"�
�
����
�
�
!�
!�	K
�S�F�r�w�/?�/?��/D�/D�F�F�H�!�0�0���B�B�N�F�F����V�\�\�$�/�/�
�2�9�9�$�?�?��J�J�J�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
����	K
�	K
�	K
�	K
�	K
�	K
s�A>B5�5B9�<
B9c
���t
j
d
�
�
}
d}tj��5}tj�|�
�
}tj�|d��}tj�|d��}d|��}t	j|�
�

ttj�|d��d��5}|�
|
�
�

ddd��
n#1swxYw

Y

t	j|�
�

t	jtj�|d��tj�|d����
|�tj�dd��g
|��\}}	|�
|�d	�
�
d
�d�
�
|��
ddd��
dS#1swxYw

Y

dS)ziWhen running `python foo.py` sys.path[0] resolves symlinks. `python -m pdb foo.py` should behave the samerX
rY
�dir_one�dir_tworZ
�foo.pyr�Nr�r[
r$
)r�r�rr�r�r�r\
r�r�r�r��symlinkr�r�r]
r^
)
rr�r�r_
rb
rc
r�r�rr�s
          r�test_issue42384_symlinkz#PdbTestCase.test_issue42384_symlink�s#����"�
�
����
�
�
!�
!�	K
�S��'�"�"�3�'�'�C��g�l�l�3�	�2�2�G��g�l�l�3�	�2�2�G�8�w�8�8�H��H�W�����b�g�l�l�7�H�5�5�s�;�;�

 �q��������

 �

 �

 �

 �

 �

 �

 �

 �

 �

 �

 ����

 �

 �

 �

 ��H�W�����J�r�w�|�|�G�X�6�6�����W�h�8W�8W�X�X�X�!�]�]�B�G�L�L��H�,M�,M�+N�PX�Y�Y�N�F�F����V�\�\�$�/�/�
�2�9�9�$�?�?��J�J�J�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
����	K
�	K
�	K
�	K
�	K
�	K
s7�B'G*�C3�'G*�3C7	�7G*�:
C7	�;C"G*�*G.�1
G.c
�B�t
j
��5}
td
d��5}tjd�
�
}|�|�
�

ddd��
n#1swxYw

Y

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

t
j	tj�|d���
�

tj�|d
��}t|d��5}|�d�
�

ddd��
n#1swxYw

Y

|�
d
g
d��\}}d}|�|�d�
�
d	�
d
�
�
|��
ddd��
dS#1swxYw

Y

dS)Nrd
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�r�r�r�r�r�r�r]
r^
)	rr_
r��
srh
�
wrong_filerr�r�s	         r�test_issue42383zPdbTestCase.test_issue42383sD��
�
�
!�
!�	K
�S��h��$�$�
�
��O�%���
����
�
�
�
�
�
�
�
�
�
�
�
�
�
�
����
�
�
�
��W�\�\�#�x�0�0�F��H�V�����H�R�W�\�\�&�(�3�3�4�4�4�����f�h�7�7�J��j�#�&�&�

@
�!����>�?�?�?�

@
�

@
�

@
�

@
�

@
�

@
�

@
�

@
�

@
�

@
�

@
����

@
�

@
�

@
�

@
�"�]�]�H�:�y�A�A�N�F�F�<�H����V�\�\�$�/�/�
�2�9�9�$�?�?��J�J�J�)	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
�	K
����	K
�	K
�	K
�	K
�	K
�	K
sZ�F�*A�F�A	�F�"
A	�#BF�<D�F�D"	�"F�%
D"	�&A!F�F�
Fc
��d
}
t
j
d�
�
}|�|
|��\}}|�|�
�

dS)Nz�            def func():
                def inner(v): pass
                inner(
                    42
                )
            func()
        zj
            break func
            continue
            next
            next
            jump 2
        )r�r�r��assertFalser
s     r�test_gh_94215_crashzPdbTestCase.test_gh_94215_crash(sV�����?�$�
�
���,�,�V�X�>�>�������� � � � � rN)
r)-r r!r"rw�unittest�skipIfr�flags�	safe_pathr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r
r
r
r
r
r"
r'
r)
r1
r4
r@
rD
rM
rV
r`
r�skip_unless_symlinkrf
rl
ro
r$rrrrrr�s�������
+�
+�
+��X�_�S�Y�(�>�
@
�
@
����
@
�
@
��(H
�H
�H
�H
�A
�A
�A
�F
�F
�F
�
5�
5�
5�
�
�
� 
�
�
�"
�
�
�
M
�
M
�
M
�V
�V
�V
�*";�";�";�H
G
�G
�G
�8G
�G
�G
�<'�'�'�F
�F
�F
�/�/�/�@
3�3�3� /� /� /�D
;�;�;�R
�R
�R
�
R
�
R
�
R
�
V
�
V
�
V
�	
�	
�	
�+�+�+���� H
�H
�H
�#M
�#M
�#M
�J
Z
�Z
�Z
�>���0+�+�+� 
K
�
K
�
K
��"�K
�K
�#�"�K
�0K
�K
�K
�.!�!�!�!�!rrrc
�,�eZ
dZd
�Zd�Zd�Zd�Zd�ZdS)�ChecklineTestsc
�,�t
j
��
dSr
)�	linecache�
clearcachers
 r�setUpzChecklineTests.setUp<s��������rc
�B�t
j
tj�
�

dSr
rtrs
 rrwzChecklineTests.tearDown?rxrc
�"
�t
tjd
��5}
|
�d�
�

ddd��
n#1swxYw

Y

t	j��}|�|�tjd��d��
dS�Nr�z
print(123)r�)r�rrvr�rLrMr��	checkline�rr��dbs   r�test_checkline_before_debuggingz.ChecklineTests.test_checkline_before_debuggingBs���
�)�"�C�
(�
(�
	"�A�
�G�G�L�!�!�!�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"����
	"�
	"�
	"�
	"�
�W�Y�Y��������i�&6�
�:�:�A�>�>�>�>�>r�c
�J
�t
tjd
��5}
|
�d�
�

ddd��
n#1swxYw

Y

t	j��}|���
|�|�tjd��d��
dSr}
)	r�rrvr�rLrM�resetr�r~
r
s   r�test_checkline_after_resetz)ChecklineTests.test_checkline_after_resetHs���
�)�"�C�
(�
(�
	"�A�
�G�G�L�!�!�!�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"�
	"����
	"�
	"�
	"�
	"�
�W�Y�Y��
���
�
�
�������i�&6�
�:�:�A�>�>�>�>�>r�c
��t
j
d
�
�
}
ttjd��5}|�|
�
�

ddd��
n#1swxYw

Y

t
|
����
�
dz}tt���
�
5
tj��}t|�
�
D]5}|�
|�tj|���
�

�6	ddd��
dS#1swxYw

Y

dS)Nz\
            # Comment
            """ docstring """
            ''' docstring '''

        r�r[
)r�r�r�rrvr��lenr�rrrLrM�rangern
r~
)rrj
r��	num_linesr�
�linenos      r� test_checkline_is_not_executablez/ChecklineTests.test_checkline_is_not_executableOs�
���O��

�

�
��)�"�C�
(�
(�
	�A�
�G�G�A�J�J�J�
	�
	�
	�
	�
	�
	�
	�
	�
	�
	�
	����
	�
	�
	�
	��
�����'�'�!�+�	�
�X�Z�Z�
(�
(�	I
�	I
�����B��	�*�*�

I
�

I
��� � ����i�.>��!G�!G�H�H�H�H�

I
�	I
�	I
�	I
�	I
�	I
�	I
�	I
�	I
�	I
�	I
�	I
�	I
����	I
�	I
�	I
�	I
�	I
�	I
s$�A�A�
A�AD�D�	
DN)r r!r"rz
rwr�
r�
r�
r$rrrv
rv
;sd������
�
�
�
+�
+�
+�?�?�?�?�?�?�I
�I
�I
�I
�I
rrv
c�`�d
dlm
}
|
�tj|�
�
�
�

|
S)Nr)
�test_pdb)�testr�
�addTest�doctest�DocTestSuite)�loader�tests�patternr�
s    r�
load_testsr�
`s6��������	�M�M�'�&�x�0�0�1�1�1��Lr�__main__)Cr�
r�rLr�typesr�rp
r�r�rx
�
contextlibrr�iorr�
r�test.supportr�test.test_doctestr�
unittest.mockr	r

rr&r)r.r0r2r4r6r:r<r>r@rB�
ModuleType�mod�exec�__dict__rErGrPrRrTrVrXrZr\r^r`rbrdrfrhrjrlrnrp�requires_subprocess�TestCaserrrv
r�
r �mainr$rr�<module>r�

s��


�
����	�	�	�	�
�
�
�
�
�
�
�
�����
�
�
�
�����������������1�1�1�1�1�1�1�1�������������"�"�"�"�"�"�(�(�(�(�(�(�������
*�
*�
*�
*�
*�6�
*�
*�
*�"
�
�
�:S
�S
�S
�j
&�
&�
&�s

�s

�s

�jA

�A

�A

�F
�
�
�8

	�

	�

	�

�

�

�]

�]

�]

�~(
�(
�(
�T
;
�;
�;
�|

�
�
�0�e��'�(�(����=�s�|�L�L�L�(
�(
�(
�V
'
�'
�'
�T

?�
?�
?�


�

�

� 
�
�
�,>
�>
�>
�@9
�9
�9
�v
6
�6
�6
�p
;
�;
�;
�z
5
�5
�5
�n
(
�(
�(
�T
*
�*
�*
�X
-
�-
�-
�^
(
�(
�(
�T
-
�-
�-
�^

�
�
�2
�
�
�:+
�+
�+
�Z
@

�@

�@

�F��
�
�
�r	
!�r	
!�r	
!�r	
!�r	
!�(�#�r	
!�r	
!��
�r	
!�h"
I
�"
I
�"
I
�"
I
�"
I
�X�&�"
I
�"
I
�"
I
�J

�
�
��z��

��H�M�O�O�O�O�O�

�

r