✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

�

�#�j�s
��F�dd
lZdd
l
Z
dd
lZdd
lZdd
lZdd
lZdd
lZdd
lZdd
lZdd
l	Z	ddl
mZmZ
ddl
mZ
ddlmZ
ddlmZ
ddlmZ
ddlmZmZ
ddlmZ
ej4ZGd	�d
e�Zd�Zd�Zd
�Z d�Z!d�Z"d�Z#d�Z$d�Z%d�Z&d�Z'd�Z(d�Z)d�Z*d�Z+d�Z,d�Z-d�Z.d�Z/d�Z0ejbd�
Z2e3de2jh�
d �Z5d!�Z6d"�Z7d#�Z8d$�Z9d%�Z:d&�Z;esd'�Z<d(�Z=d)�Z>esd*�Z?d+�Z@esd,�ZAd-�ZBd.�ZCd/�ZDd0�ZEd1�ZFd2�ZGd3�ZHd4�ZId5�ZJd6�ZKd7�ZLd8�ZMd9�ZNej��Gd:�d;ej���ZQGd<�d=ej��ZRej��Gd>�d?ej���ZSd@�ZTeUdAk(rej��
y
y
)B�N)�	ExitStack�redirect_stdout)
�StringIO)
�support)
�	os_helper)
�
import_module)�run_pty�	FakeInput)
�patchc
�"�eZ
dZd
Zd�Zd�Zd�Zy)�PdbTestInputz:Context manager that makes testing Pdb in doctests easier.c��|
|_y�
N)
�input)�selfrs  �4/opt/alt/python312/lib64/python3.12/test/test_pdb.py�__init__zPdbTestInput.__init__s	����
�c
���tj|_t|j�
t_
ttd
�rt
j�|_yd|_y)N�gettrace)�sys�stdin�
real_stdinr
r�hasattrr�
orig_trace�
rs
 r�	__enter__zPdbTestInput.__enter__ s9���)�)����d�j�j�)��	�,3�C��,D�#�,�,�.���$��rc
��|jt_|jr tj|j�

yyr)rrrr�settrace)r�excs  r�__exit__zPdbTestInput.__exit__%s)���O�O��	��?�?��L�L����)�rN)�__name__�
__module__�__qualname__�__doc__rrr!�rrr
r
s��D�
�O
�
*rr
c��y
)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��y
)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+Hr)rc�@�d
dl}|jj�
y)Nr)�bdb�
Breakpoint�clearBreakpoints)
r-s
 r�reset_Breakpointr0�s����N�N�#�#�%rc��y
)a�Test basic commands related to breakpoints.

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     print(1)
    ...     print(2)
    ...     print(3)
    ...     print(4)

    First, need to clear bdb state that might be left over from previous tests.
    Otherwise, the new breakpoints might get assigned different numbers.

    >>> reset_Breakpoint()

    Now test the breakpoint commands.  NORMALIZE_WHITESPACE is needed because
    the breakpoint list outputs a tab for the "stop only" and "ignore next"
    lines, which we don't want to put in here.

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'break 3',
    ...     'break 4, +',
    ...     'disable 1',
    ...     'ignore 1 10',
    ...     'condition 1 1 < 2',
    ...     'condition 1 1 <',
    ...     'break 4',
    ...     'break 4',
    ...     'break',
    ...     'clear 3',
    ...     'break',
    ...     'condition 1',
    ...     'enable 1',
    ...     'clear 1',
    ...     'commands 2',
    ...     'p "42"',
    ...     'print("42", 7*6)',     # Issue 18764 (not about breakpoints)
    ...     'end',
    ...     'continue',  # will stop at breakpoint 2 (line 4)
    ...     'clear',     # clear all!
    ...     'y',
    ...     'tbreak 5',
    ...     'continue',  # will stop at temporary breakpoint
    ...     'break',     # make sure breakpoint is gone
    ...     'commands 10',  # out of range
    ...     'commands a',   # display help
    ...     'commands 4',   # already deleted
    ...     'break 6, undefined', # condition causing `NameError` during evaluation
    ...     'continue', # will stop, ignoring runtime error
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(3)test_function()
    -> print(1)
    (Pdb) break 3
    Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) break 4, +
    *** Invalid condition +: SyntaxError: invalid syntax
    (Pdb) disable 1
    Disabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) ignore 1 10
    Will ignore next 10 crossings of breakpoint 1.
    (Pdb) condition 1 1 < 2
    New condition set for breakpoint 1.
    (Pdb) condition 1 1 <
    *** Invalid condition 1 <: SyntaxError: invalid syntax
    (Pdb) break 4
    Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break 4
    Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
            stop only if 1 < 2
            ignore next 10 hits
    2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    3   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) clear 3
    Deleted breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
            stop only if 1 < 2
            ignore next 10 hits
    2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) condition 1
    Breakpoint 1 is now unconditional.
    (Pdb) enable 1
    Enabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) clear 1
    Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) commands 2
    (com) p "42"
    (com) print("42", 7*6)
    (com) end
    (Pdb) continue
    1
    '42'
    42 42
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(4)test_function()
    -> print(2)
    (Pdb) clear
    Clear all breaks? y
    Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) tbreak 5
    Breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
    (Pdb) continue
    2
    Deleted breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(5)test_function()
    -> print(3)
    (Pdb) break
    (Pdb) commands 10
    *** cannot set commands: Breakpoint number 10 out of range
    (Pdb) commands a
    *** Usage: commands [bnum]
            ...
            end
    (Pdb) commands 4
    *** cannot set commands: Breakpoint 4 already deleted
    (Pdb) break 6, undefined
    Breakpoint 5 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:6
    (Pdb) continue
    3
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(6)test_function()
    -> print(4)
    (Pdb) continue
    4
    Nr&r&rr�test_pdb_breakpoint_commandsr2�r)rc��y
)aTest breakpoints on function definitions with annotation.

    >>> def foo[T]():
    ...     return 0

    >>> def bar() -> int:
    ...     return 0

    >>> def foobar[T]() -> int:
    ...     return 0

    >>> reset_Breakpoint()

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

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'break foo',
    ...     'break bar',
    ...     'break foobar',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[4]>(3)test_function()
    -> pass
    (Pdb) break foo
    Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[0]>:1
    (Pdb) break bar
    Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[1]>:1
    (Pdb) break foobar
    Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[2]>:1
    (Pdb) continue
    Nr&r&rr�-test_pdb_breakpoint_on_annotated_function_defr4c
r)rc��y
)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:...
    (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_sessionsr6�
r)rc��y
)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_excr8�
r)rc��y
)aTest that empty line repeats the last command.

    >>> def test_function():
    ...     x = 1
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     pass
    ...     y = 2

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'p x',
    ...     '',  # Should repeat p x
    ...     'n ;; p 0 ;; p x',  # Fill cmdqueue with multiple commands
    ...     '',  # Should still repeat p x
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_empty_line[0]>(4)test_function()
    -> pass
    (Pdb) p x
    1
    (Pdb)
    1
    (Pdb) n ;; p 0 ;; p x
    0
    1
    > <doctest test.test_pdb.test_pdb_empty_line[0]>(5)test_function()
    -> y = 2
    (Pdb)
    1
    (Pdb) continue
    Nr&r&rr�test_pdb_empty_liner:�
r)rc��yrr&r&rr�
do_nothingr<s��rc��t
d
�

y)N�*)
�printr&rr�do_somethingr@	s	��	�"�Irc��y
)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_commandsrBr)rc��y
)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_commandrDkr)rc��y
)a�Test display command

    >>> def test_function():
    ...     a = 0
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     a = 1
    ...     a = 2
    ...     a = 3
    ...     a = 4

    >>> with PdbTestInput([  # doctest: +ELLIPSIS
    ...     'display +',
    ...     'display',
    ...     'display a',
    ...     'n',
    ...     'display',
    ...     'undisplay a',
    ...     'n',
    ...     'display a',
    ...     'undisplay',
    ...     'display a < 1',
    ...     'n',
    ...     'display undefined',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_display_command[0]>(4)test_function()
    -> a = 1
    (Pdb) display +
    *** Unable to display +: SyntaxError: invalid syntax
    (Pdb) display
    No expression is being displayed
    (Pdb) display a
    display a: 0
    (Pdb) n
    > <doctest test.test_pdb.test_pdb_display_command[0]>(5)test_function()
    -> a = 2
    display a: 1  [old: 0]
    (Pdb) display
    Currently displaying:
    a: 1
    (Pdb) undisplay a
    (Pdb) n
    > <doctest test.test_pdb.test_pdb_display_command[0]>(6)test_function()
    -> a = 3
    (Pdb) display a
    display a: 2
    (Pdb) undisplay
    (Pdb) display a < 1
    display a < 1: False
    (Pdb) n
    > <doctest test.test_pdb.test_pdb_display_command[0]>(7)test_function()
    -> a = 4
    (Pdb) display undefined
    display undefined: ** raised NameError: name 'undefined' is not defined **
    (Pdb) continue
    Nr&r&rr�test_pdb_display_commandrF�r)rc��y
)a�Test alias command

    >>> class A:
    ...     def __init__(self):
    ...         self.attr1 = 10
    ...         self.attr2 = 'str'
    ...     def method(self):
    ...         pass

    >>> def test_function():
    ...     o = A()
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     o.method()

    >>> with PdbTestInput([  # doctest: +ELLIPSIS
    ...     'alias pi',
    ...     'alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")',
    ...     'alias ps pi self',
    ...     'alias ps',
    ...     'pi o',
    ...     's',
    ...     'ps',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_alias_command[1]>(4)test_function()
    -> o.method()
    (Pdb) alias pi
    *** Unknown alias 'pi'
    (Pdb) alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")
    (Pdb) alias ps pi self
    (Pdb) alias ps
    ps = pi self
    (Pdb) pi o
    o.attr1 = 10
    o.attr2 = str
    (Pdb) s
    --Call--
    > <doctest test.test_pdb.test_pdb_alias_command[0]>(5)method()
    -> def method(self):
    (Pdb) ps
    self.attr1 = 10
    self.attr2 = str
    (Pdb) continue
    Nr&r&rr�test_pdb_alias_commandrH�r)rc��y
)aFTest where command

    >>> def g():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()

    >>> def f():
    ...     g();

    >>> def test_function():
    ...     f()

    >>> with PdbTestInput([  # doctest: +ELLIPSIS
    ...     'w',
    ...     'where',
    ...     'u',
    ...     'w',
    ...     'continue',
    ... ]):
    ...    test_function()
    --Return--
    > <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()->None
    -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    (Pdb) w
    ...
      <doctest test.test_pdb.test_pdb_where_command[3]>(8)<module>()
    -> test_function()
      <doctest test.test_pdb.test_pdb_where_command[2]>(2)test_function()
    -> f()
      <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
    -> g();
    > <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()->None
    -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    (Pdb) where
    ...
      <doctest test.test_pdb.test_pdb_where_command[3]>(8)<module>()
    -> test_function()
      <doctest test.test_pdb.test_pdb_where_command[2]>(2)test_function()
    -> f()
      <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
    -> g();
    > <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()->None
    -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    (Pdb) u
    > <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
    -> g();
    (Pdb) w
    ...
      <doctest test.test_pdb.test_pdb_where_command[3]>(8)<module>()
    -> test_function()
      <doctest test.test_pdb.test_pdb_where_command[2]>(2)test_function()
    -> f()
    > <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
    -> g();
      <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()->None
    -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    (Pdb) continue
    Nr&r&rr�test_pdb_where_commandrJ�r)rc��y
)a�
Test convenience variables

    >>> def util_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     try:
    ...         raise Exception('test')
    ...     except:
    ...         pass
    ...     return 1

    >>> def test_function():
    ...     util_function()

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...     '$_frame.f_lineno', # Check frame convenience variable
    ...     '$ _frame',         # This should be a syntax error
    ...     '$a = 10',          # Set a convenience variable
    ...     '$a',               # Print its value
    ...     'p "$a"',           # Print the string $a
    ...     'p $a + 2',         # Do some calculation
    ...     'p f"$a = {$a}"',   # Make sure $ in string is not converted and f-string works
    ...     'u',                # Switch frame
    ...     '$_frame.f_lineno', # Make sure the frame changed
    ...     '$a',               # Make sure the value persists
    ...     'd',                # Go back to the original frame
    ...     'next',
    ...     '$a',               # The value should be gone
    ...     'next',
    ...     '$_exception',      # Check exception convenience variable
    ...     'next',
    ...     '$_exception',      # Exception should be gone
    ...     'return',
    ...     '$_retval',         # Check return convenience variable
    ...     'continue',
    ... ]):
    ...     test_function()
    > <doctest test.test_pdb.test_convenience_variables[0]>(3)util_function()
    -> try:
    (Pdb) $_frame.f_lineno
    3
    (Pdb) $ _frame
    *** SyntaxError: invalid syntax
    (Pdb) $a = 10
    (Pdb) $a
    10
    (Pdb) p "$a"
    '$a'
    (Pdb) p $a + 2
    12
    (Pdb) p f"$a = {$a}"
    '$a = 10'
    (Pdb) u
    > <doctest test.test_pdb.test_convenience_variables[1]>(2)test_function()
    -> util_function()
    (Pdb) $_frame.f_lineno
    2
    (Pdb) $a
    10
    (Pdb) d
    > <doctest test.test_pdb.test_convenience_variables[0]>(3)util_function()
    -> try:
    (Pdb) next
    > <doctest test.test_pdb.test_convenience_variables[0]>(4)util_function()
    -> raise Exception('test')
    (Pdb) $a
    *** KeyError: 'a'
    (Pdb) next
    Exception: test
    > <doctest test.test_pdb.test_convenience_variables[0]>(4)util_function()
    -> raise Exception('test')
    (Pdb) $_exception
    Exception('test')
    (Pdb) next
    > <doctest test.test_pdb.test_convenience_variables[0]>(5)util_function()
    -> except:
    (Pdb) $_exception
    *** KeyError: '_exception'
    (Pdb) return
    --Return--
    > <doctest test.test_pdb.test_convenience_variables[0]>(7)util_function()->1
    -> return 1
    (Pdb) $_retval
    1
    (Pdb) continue
    Nr&r&rr�test_convenience_variablesrL:r)rc��y
)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_mortemrN�r)rc��y
)ahWhen pdb returns to a different file, it should not skip if f_trace is
       not already set

    >>> import pprint

    >>> class A:
    ...    def __repr__(self):
    ...        return 'A'

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     pprint.pprint(A())

    >>> reset_Breakpoint()
    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...     'b A.__repr__',
    ...     'continue',
    ...     'return',
    ...     'next',
    ...     'return',
    ...     'return',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_return_to_different_file[2]>(3)test_function()
    -> pprint.pprint(A())
    (Pdb) b A.__repr__
    Breakpoint 1 at <doctest test.test_pdb.test_pdb_return_to_different_file[1]>:2
    (Pdb) continue
    > <doctest test.test_pdb.test_pdb_return_to_different_file[1]>(3)__repr__()
    -> return 'A'
    (Pdb) return
    --Return--
    > <doctest test.test_pdb.test_pdb_return_to_different_file[1]>(3)__repr__()->'A'
    -> return 'A'
    (Pdb) next
    > ...pprint.py..._safe_repr()
    -> return rep,...
    (Pdb) return
    --Return--
    > ...pprint.py..._safe_repr()->('A'...)
    -> return rep,...
    (Pdb) return
    --Return--
    > ...pprint.py...format()->('A'...)
    -> return...
    (Pdb) continue
    A
    Nr&r&rr�!test_pdb_return_to_different_filerP�r)rc��y
)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_modulesrRr)r�module_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonec��y
)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_callbackrUr)rc��y
)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_bottomframerWJr)rc�R�t
tjd
d��|�|
�

y)zRun pdb.method(arg).TF)�nosigint�readrcN)�getattr�pdb�Pdb)�method�args  r�
pdb_invoker`ts��9�G�C�G�G�T�%�0�&�9�#�>rc��y
)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_argumentrbyr)rc��y
)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_objectrd�r)rc��y
)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_eventrf�r)rc��y
)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_generatorrh�r)rc��y
)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_coroutinerjr)rc��y
)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_asyncgenrlSr)rc��y
)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_generatorrn�r)rc��y
)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_coroutinerp�r)rc��y
)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_generatorrr�r)rc��y
)a�Testing no unwindng stack for coroutines
        for "until" command if target breakpoint is not reached

        >>> import asyncio

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

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

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

        >>> with PdbTestInput(['step',
        ...                    'until 8',
        ...                    'continue']):
        ...     test_function()
        > <doctest test.test_pdb.test_pdb_until_command_for_coroutine[2]>(3)test_main()
        -> await test_coro()
        (Pdb) step
        --Call--
        > <doctest test.test_pdb.test_pdb_until_command_for_coroutine[1]>(1)test_coro()
        -> async def test_coro():
        (Pdb) until 8
        0
        1
        2
        > <doctest test.test_pdb.test_pdb_until_command_for_coroutine[1]>(8)test_coro()
        -> print(3)
        (Pdb) continue
        3
        finished
        Nr&r&rr�$test_pdb_until_command_for_coroutinertr)rc��y
)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_looprvNr)rc��y
)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_subiteratorrxxr)rc��y
)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_20766rz�r)rc��y
)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_43318r|�r)rc��y
)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_91742r~�r)rc��y
)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_94215r�
r)rc��y
)a�See GH-101673

    Make sure ll won't revert local variable assignment

    >>> def test_function():
    ...    a = 1
    ...    import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     '!a = 2',
    ...     'll',
    ...     'p a',
    ...     'continue'
    ... ]):
    ...     test_function()
    --Return--
    > <doctest test.test_pdb.test_pdb_issue_gh_101673[0]>(3)test_function()->None
    -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    (Pdb) !a = 2
    (Pdb) ll
      1         def test_function():
      2            a = 1
      3  ->        import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    (Pdb) p a
    2
    (Pdb) continue
    Nr&r&rr�test_pdb_issue_gh_101673r�Lr)rc��y
)a�See GH-103225

    Make sure longlist uses 1-based line numbers in frames that correspond to a module

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'longlist',
    ...     'continue'
    ... ]):
    ...     a = 1
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     b = 2
    > <doctest test.test_pdb.test_pdb_issue_gh_103225[0]>(7)<module>()
    -> b = 2
    (Pdb) longlist
      1     with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
      2         'longlist',
      3         'continue'
      4     ]):
      5         a = 1
      6         import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
      7  ->     b = 2
    (Pdb) continue
    Nr&r&rr�test_pdb_issue_gh_103225r�ir)rc��y
)a9See GH-101517

    Make sure pdb doesn't crash when the exception is caught in a try/except* block

    >>> def test_function():
    ...     try:
    ...         raise KeyError
    ...     except* Exception as e:
    ...         import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'continue'
    ... ]):
    ...    test_function()
    --Return--
    > <doctest test.test_pdb.test_pdb_issue_gh_101517[0]>(None)test_function()->None
    -> Warning: lineno is None
    (Pdb) continue
    Nr&r&rr�test_pdb_issue_gh_101517r��r)rc��y
)a1See GH-108976
    Make sure setting f_trace_opcodes = True won't crash pdb
    >>> def test_function():
    ...     import sys
    ...     sys._getframe().f_trace_opcodes = True
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     a = 1
    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'continue'
    ... ]):
    ...    test_function()
    bdb.Bdb.dispatch: unknown debugging event: 'opcode'
    > <doctest test.test_pdb.test_pdb_issue_gh_108976[0]>(5)test_function()
    -> a = 1
    (Pdb) continue
    Nr&r&rr�test_pdb_issue_gh_108976r��r)rc��y
)a�See GH-104301

    Make sure that ambiguous statements prefixed by '!' are properly disambiguated

    >>> with PdbTestInput([
    ...     '! n = 42',  # disambiguated statement: reassign the name n
    ...     'n',         # advance the debugger into the print()
    ...     'continue'
    ... ]):
    ...     n = -1
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     print(f"The value of n is {n}")
    > <doctest test.test_pdb.test_pdb_ambiguous_statements[0]>(8)<module>()
    -> print(f"The value of n is {n}")
    (Pdb) ! n = 42
    (Pdb) n
    The value of n is 42
    > <doctest test.test_pdb.test_pdb_ambiguous_statements[0]>(1)<module>()
    -> with PdbTestInput([
    (Pdb) continue
    Nr&r&rr�test_pdb_ambiguous_statementsr��r)rc��y
)a�
    pdb should not leak reference to frames

    >>> def frame_leaker(container):
    ...     import sys
    ...     container.append(sys._getframe())
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     pass

    >>> def test_function():
    ...     import gc
    ...     container = []
    ...     frame_leaker(container)  # c
    ...     print(len(gc.get_referrers(container[0])))
    ...     container = []
    ...     frame_leaker(container)  # n c
    ...     print(len(gc.get_referrers(container[0])))
    ...     container = []
    ...     frame_leaker(container)  # r c
    ...     print(len(gc.get_referrers(container[0])))

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'continue',
    ...     'next',
    ...     'continue',
    ...     'return',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()
    -> pass
    (Pdb) continue
    1
    > <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()
    -> pass
    (Pdb) next
    --Return--
    > <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()->None
    -> pass
    (Pdb) continue
    1
    > <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()
    -> pass
    (Pdb) return
    --Return--
    > <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()->None
    -> pass
    (Pdb) continue
    1
    Nr&r&rr�test_pdb_frame_refleakr��r)rc��y
)aASee GH-65052

    args, retval and display should not crash if the object is not displayable
    >>> class A:
    ...     def __new__(cls):
    ...         import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...         return object.__new__(cls)
    ...     def __init__(self):
    ...         import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...         self.a = 1
    ...     def __repr__(self):
    ...         return self.a

    >>> def test_function():
    ...     A()
    >>> with PdbTestInput([  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
    ...     's',
    ...     'retval',
    ...     'continue',
    ...     'args',
    ...     'display self',
    ...     'display',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(4)__new__()
    -> return object.__new__(cls)
    (Pdb) s
    --Return--
    > <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(4)__new__()-><A instance at ...>
    -> return object.__new__(cls)
    (Pdb) retval
    *** repr(retval) failed: AttributeError: 'A' object has no attribute 'a' ***
    (Pdb) continue
    > <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(7)__init__()
    -> self.a = 1
    (Pdb) args
    self = *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' ***
    (Pdb) display self
    display self: *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' ***
    (Pdb) display
    Currently displaying:
    self: *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' ***
    (Pdb) continue
    Nr&r&rr�test_pdb_issue_gh_65052r��r)rc�
�eZ
dZd
�Zej
ejjd�d3d�
�Z				d4d�
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'd#�Z(d$�Z)d%�Z*d&�Z+d'�Z,d(�Z-d)�Z.d*�Z/d+�Z0d,�Z1e2jfd-��Z4d.�Z5d/�Z6d0�Z7d1�Z8d2�Z9y)5�PdbTestCasec
�J�t
jtj�

yr�r�unlink�TESTFNrs
 r�tearDownzPdbTestCase.tearDown&�������)�)�*rz'PYTHONSAFEPATH changes default sys.pathc	�H�|j
tjd
�
tjddg|
z}tj|t
jt
jt
jitj�
ddi
�
��5}|jtj|�
�
\}}ddd�
x
r
tj|�
}x
r
tj|�
}|j!j"|d|�d|���
||fS#1s
w
Y

�bxYw
)	N�__pycache__�-mr\�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�procr�r�s        r�_run_pdbzPdbTestCase._run_pdb)s���	
���	�(�(�-�8��~�~�t�U�+�h�6��
�
�
��!��� �o�o�!�(�(�A����A�%7��A�
��!�-�-�c�j�j��.B�C�N�F�F�
��0�E�L�L��0���0�E�L�L��0������O�O��.�v�h�j���I�	
�
�v�~��
�
�s�(D�D!Nc�~�d
}t
|d�5}|jtj|
�
�

ddd�
|�Yt
dd�5}|jtj|�
�

ddd�
|j	t
jd�
|j	t
j|�
d}|r tjjdd�}	|j|g
||�\}	}
|�|tjd<|	|
fS#1s
w
Y

��xYw
#1s
w
Y

��xYw
#|�|tjd<wwxYw
)z3Run 'script' lines with pdb and the pdb 'commands'.zmain.py�
wN�.pdbrc�HOME)�open�write�textwrap�dedentr�rr�r�r��popr�)r�scriptr�r��pdbrc�remove_home�filename�
f�homesaver�r�s           r�run_pdb_scriptzPdbTestCase.run_pdb_script?s
��
��
�(�C�
 �A�
�G�G�H�O�O�F�+�,�!����h��$�
��������.�/�%��O�O�I�,�,�h�7����	�(�(�(�3�����z�z�~�~�f�d�3�H�	.�!�]�]�H�:�x�AT�U�N�F�F��#�%-��
�
�6�"��v�~��#!�
 ��%�$���#�%-��
�
�6�"�$�s#�%D�
%D�D$�D�D!�$D<c�&�d
|_tj|j�

|jdz}|jdz}tj|j�

t|d�5}	ddd�
t|d�5}|j
tj|
�
�

ddd�
|jtj|j�
|jd|jg|�S#1s
w
Y

��xYw
#1s
w
Y

�]xYw
)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_moduleXs���#�������)�)�*��$�$�~�5�	��$�$�~�5�	�
����!�!�"�
�)�S�
!�Q��"�
�)�S�
!�Q�
�G�G�H�O�O�F�+�,�"����	�(�(�$�*:�*:�;��}�}�d�D�$4�$4�5�x�@�@�"�
!��
!�
!�s�0
C;�%D�;D�Dc�&
�t
tjd
�5}|j|
�

ddd�
|sdn|dtj|df}|j	|tj|tj��
y#1s
w
Y

�[xYw
)N�wbr�
)r�rr�r�r�r\�
find_function)r�file_content�	func_name�expectedr�s     r�_assert_find_functionz!PdbTestCase._assert_find_functionfsx��
�)�"�"�D�
)�Q�
�G�G�L�!�*� (�4��Q�K��)�)�8�A�;�
.8������c�'�'�	�9�3C�3C�D�
	F
�*�
)�s�B�Bc
�*�|j
d
dd�
y)Nr�foo)
r�rs
 r�test_find_function_empty_filez)PdbTestCase.test_find_function_empty_fileos���"�"�3��t�4rc
�F�|j
d
j�dd�
y)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_foundrs$���"�"�	
��F�H���
	
rc
�H�|j
d
jd�
dd�
y)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_cookie�s'���"�"�

��F�=����	
rc
�h�|j
tjd
j�zdd�
y)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�s2���"�"��O�O���F�H�

�
��
	
rc
�Z�d
}
d}|j
|
|�\}}|jd|�
y)NzJ
            import __main__
            print(__main__.__spec__)
        �continue�None)r��assertIn�rr�r�r��
_s     r�	test_speczPdbTestCase.test_spec�s4����
���'�'���9�	��
��
�
�f�f�%rc
��
�t
tjd
�5}
|
jd�

ddd�
tj
ddtjg}t
j|tjtjtj��}|j|jj�

|jd�
\}}|jd|d�
y#1s
w
Y

��xYw
)	Nr�sprint("testing my pdb")
r�r\)r�rr�squit
sSyntaxErrorz0Got a syntax error running test script under PDB)r�rr�r�rr�r�r�r�r�r�r��closer��assertNotIn�rr�r�r�r�r�s      r�test_issue7964zPdbTestCase.test_issue7964�s���
�)�"�"�D�
)�Q�
�G�G�2�3�*��~�~�t�U�I�,<�,<�=�������?�?��/�/��$�$���
	
������)�)�*��)�)�)�4���������K�
	M
�*�
)�s�C'�'C0c
��d
}
d}|j
|
|�\}}|x
s
d|x
s
dz}|jd|d�
|jd|d�
y)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�r�)rr�r�r�r��outputs      r�test_issue46434zPdbTestCase.test_issue46434�sg�������,�,�V�X�>�����,�B�6�<�R�0�����)�6�^�
	`
��
�
�S�U[�T�
	V
rc
�d
�d
}
d}d}t
dd�5}|jtj|�
�

ddd�
|j	t
jd�
|j|
|�\}}|jtd�|j�D��
d�
y#1s
w
Y

�oxYw
)Nz�
            from bar import bar

            def foo():
                bar()

            def nope():
                pass

            def foobar():
                foo()
                nope()

            foobar()
        z�
            from bar import bar
            break bar
            continue
            step
            step
            quit
        z5
            def bar():
                pass
        �bar.pyr�c
3�$K
�|]}
d|
v�
�

�
y
�w
)zmain.py(5)foo()->NoneNr&��.0�
ls  r�	<genexpr>z.PdbTestCase.test_issue13183.<locals>.<genexpr>�s����J�6I��'�1�,�6I���
z+Fail to step into the caller after a return)r�r�r�r�r�rr�r��
assertTrue�any�
splitlines)rr�r��barr�r�r�s       r�test_issue13183zPdbTestCase.test_issue13183�s����������(�C�
 �A�
�G�G�H�O�O�C�(�)�!����	�(�(�(�3��,�,�V�X�>��������J�f�6G�6G�6I�J�J�9�	;�	!�
 �s�%B&�&B/c
	�R�t
tjd
�5}
|
jt	j
d�
j
d�
�

ddd�
tjdtjg}tj|tjtjtjitj�
ddi
�
��}|j|j j"�

|j%d�
\}}|j'd	|d
�
y#1s
w
Y

��xYw
)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�rr�r�r�r�r�rr�r�r�r�r�r�r�r�r�r�r�r�r�s      r�test_issue13120zPdbTestCase.test_issue13120�s����)�"�"�D�
)�Q�
�G�G�H�O�O�
%�
�%�f�W�o�

/�*��~�~�t�Y�%5�%5�6�������?�?��/�/��$�$�;�2�:�:�;�1�7�;�	��	
������)�)�*��)�)�)�4��������6�E�
	G
�+*�
)���4D�D&c
	�R�t
tjd
�5}
|
jt	j
d�
j
d�
�

ddd�
tjdtjg}tj|tjtjtjitj�
ddi
�
��}|j|j j"�

|j%d�
\}}|j'd	|d
�
y#1s
w
Y

��xYw
)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
	s���
�)�"�"�D�
)�Q�
�G�G�H�O�O�%��$�V�G�_�
.�*� �~�~�t�Y�%5�%5�6�������?�?��/�/��$�$�=�R�Z�Z�=�!3�W�=�	��	
������)�)�*��)�)�/�:��������6�E�
	G
�3*�
)�r
c
��d
}
d}d}|j
|
|d��\}}|j||dj||��
y)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�r�r�s      r�test_issue16180zPdbTestCase.test_issue16180+	sT�� ����!���,�,��H�!�-�
����	
�
�
�h��

=�
�V�H�f�
%�	'rc
��d
}
d}|j
|
|�\}}dj|j�D�cgc]}|j���c}�
}|j	|d�
|j	|d�
yc
c}w)Nzprint('hello')z[
            continue
            run a b c
            run d e f
            quit
        �

z#Restarting .* with arguments:
a b cz#Restarting .* with arguments:
d e f)r��joinr

�strip�assertRegex)rr�r�r�r��
x�ress       r�test_issue26053zPdbTestCase.test_issue260538	s|��!�����,�,�V�X�>�����i�i�F�,=�,=�,?�@�,?�q�����,?�@�A������D�E�����D�E��A
s�A:c
�l
�d
}
d}d}t
dd�5}|jtj|�
�

ddd�
|j	t
jd�
|j|
|�\}}|j�}|jd|�
|jd|�
y#1s
w
Y

�sxYw
)Nz~
            import bar
            def foo():
                ret = bar.bar()
                pass
            foo()
        zv
            b bar.bar
            c
            b main.py:5
            c
            p ret
            quit
        z:
            def bar():
                return 42
        r�r��-> passz(Pdb) 42)
r�r�r�r�r�rr�r�r

r�)rr�r�r
r�r�r��liness        r�test_issue58956zPdbTestCase.test_issue58956F	s����������(�C�
 �A�
�G�G�H�O�O�C�(�)�!����	�(�(�(�3��,�,�V�X�>�����!�!�#���
�
�i��'��
�
�j�%�(�
!�
 �s�%B*�*B3c
�~�d
}
d}|j
|
|�\}}|jd|�
|jd|�
y)Nzx = 1zM
            step
            step
            step
            quit
        zThe program finishedzbdb.py)r�r�r�r�s     r�test_step_into_botframez#PdbTestCase.test_step_into_botframed	sG�������'�'���9�	��
��
�
�,�f�5�����6�*rc
���t
jd
�
}
t
jd�
}|j|
d|d��\}}|jd|�
|j	d|�
y)Nz-
            a = 1
            b = 2
        zU
            # Comments should be fine
            n
            p f"{a+8=}"
        �q
T�r�r��SyntaxErrorza+8=9)r�r�r�r�r��rr�r�r�r�s     r�test_pdbrc_basiczPdbTestCase.test_pdbrc_basicr	sh�����"�
��
���!�
���,�,�V�U�%�UY�,�Z���������/��
�
�g�v�&rc
���t
jd
�
}
t
jd�
}|j|
d|d��\}}|jd|�
|j	d|�
y)	z,Test that empty lines in .pdbrc are ignored.z?
            a = 1
            b = 2
            c = 3
        z
            n

        r!
Tr"
zb = 2zc = 3N)r�r�r�r�r�r$
s     r�test_pdbrc_empty_linez!PdbTestCase.test_pdbrc_empty_line�	sj�����"�
�����!�
��
�,�,�V�U�%�UY�,�Z�����
�
�g�v�&�����&�)rc
��t
jd
�
}
t
jd�
}|j|
d|d��\}}|jd|�
y)N��
            class A:
                def __init__(self):
                    self.attr = 1
            a = A()
            b = 2
        z�
            alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")
            until 6
            pi a
        r!
Tr"
z
a.attr = 1�r�r�r�r�r$
s     r�test_pdbrc_aliaszPdbTestCase.test_pdbrc_alias�	sX�����"�
�����!�
���,�,�V�U�%�UY�,�Z�����
�
�l�F�+rc
��t
jd
�
}
t
jd�
}|j|
d|d��\}}|jd|�
y)Nr)
z
            b 5;;c;;n
        r!
Tr"
z-> b = 2r*
r$
s     r�test_pdbrc_semicolonz PdbTestCase.test_pdbrc_semicolon�	sX�����"�
�����!�
���,�,�V�U�%�UY�,�Z�����
�
�j�&�)rc
��t
jd
�
}
t
jd�
}|j|
d|d��\}}|jd|�
y)Nr)
zK
            b 6
            commands 1 ;; p a;; end
            c
        r!
Tr"
z<__main__.A object atr*
r$
s     r�test_pdbrc_commandszPdbTestCase.test_pdbrc_commands�	sY�����"�
�����!�
���,�,�V�U�%�UY�,�Z�����
�
�-�v�6rc
��t
jd
�
}
|j|
ddd��\}}|jd|�
y)Nz$
            print('hello')
        r!
�invalidTr"
z(NameError: name 'invalid' is not definedr*
)rr�r�r�s    r�test_readrc_kwargzPdbTestCase.test_readrc_kwarg�	sD�����"�
���,�,�V�U�)�Y]�,�^�����
�
�@�&�Irc
�~�tjjd
d�}
tj�5}td�
5
tjj|d�}|tjj_		t|d�5}|jd�

ddd�
|jtj�jdd�
|
�|
tjd
<	ddd�
ddd�
y#1s
w
Y

�axYw
#|
�|
tjd
<wwxYw
#1s
w
Y

�9xYw
#1s
w
Y

yxYw
)Nr�zos.path.expanduserr�r�r1
r)r�r�r�r�temp_dirr�pathr
�
expanduser�return_valuer�r�r�r\r]�rcLines)r�	save_homer4
�rc_pathr�s     r�test_readrc_homedirzPdbTestCase.test_readrc_homedir�	s����J�J�N�N�6�4�0�	�
�
�
�
!�X�u�5I�/J��g�g�l�l�8�X�6�G�.5�B�G�G���+�
3��'�3�'�1��G�G�I�&�(�� � �����!2�!2�1�!5�y�A��(�)2�B�J�J�v�&�0K
�
!�
!�(�'���(�)2�B�J�J�v�&�)��0K
�/J��
!�
!�sT�D3�
AD'�D�D� 9D�D'�/D3�D	�D�D$�$D'�'D0	�,D3�3D<c
�h
�t
�}
d
}t�5}|jtd|
��

|jtjt
jd��

tj|��

ddd�
|j|
j�|dz�
y#1s
w
Y

�-xYw
)Nz"Nobody expects... blah, blah, blahz
sys.stdout�	set_trace)
�headerr
)
rr�
enter_contextr�objectr\r]r=
r��getvalue)rr�r>
�	resourcess    r�test_headerzPdbTestCase.test_header�	s}�����5��
�[�I��#�#�E�,��$?�@��#�#�E�L�L����+�$F�G��M�M��(��	
������*�F�T�M�:�	�[�s�A%B(�(B1c
��d
}
d}|j
|
|�\}}|jtd�|j�D��
|�
y)Nzprint("SUCCESS")�/
            continue
            quit
        c
3�$K
�|]}
d|
v�
�

�
y
�w
��SUCCESSNr&r�s  rr�z.PdbTestCase.test_run_module.<locals>.<genexpr>�	�����H�4G�q�I��N�4G�r��r�r�r
r

�rr�r�r�r�s     r�test_run_modulezPdbTestCase.test_run_module�	sH��'�����,�,�V�X�>��������H�F�4E�4E�4G�H�H�&�Qrc
��d
}
d}|j
|
|�\}}|jtd�|j�D��
|�
y)NzQ
            if __name__ == '__main__':
                print("SUCCESS")
        rE
c
3�$K
�|]}
d|
v�
�

�
y
�w
rG
r&r�s  rr�z9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>�	rI
r�rJ
rK
s     r�test_module_is_run_as_mainz&PdbTestCase.test_module_is_run_as_main�	sJ�������,�,�V�X�>��������H�F�4E�4E�4G�H�H�&�Qrc
��d
}
d}|j
|
|�\}}|jtd�|j�D��
|�
|jt	d�|j�D��
|�
y)Nz{
            if __name__ == '__main__':
                pass
                print("SUCCESS")
                pass
        z*
            b 3
            quit
        c
3�$K
�|]}
d|
v�
�

�
y
�w
)zBreakpoint 1 atNr&r�s  rr�z.PdbTestCase.test_breakpoint.<locals>.<genexpr>
�����P�<O�q�-��2�<O�r�c
3�$K
�|]}
d|
v
�
�

�
y
�w
rG
r&r�s  rr�z.PdbTestCase.test_breakpoint.<locals>.<genexpr>
s����L�8K�1�I�Q�.�8K�r�)r�r�r
r

�allrK
s     r�test_breakpointzPdbTestCase.test_breakpoint�	sm�������,�,�V�X�>��������P�F�<M�<M�<O�P�P�RX�Y�����L��8I�8I�8K�L�L�f�Urc
��d
}
|j
ddg|
�\}}|jtj|j	dd��
y)Nz(
            c
            quit
        r�r\�

r�)r�r�r\�_usage�replace)rr�r�r�s    r�test_run_pdb_with_pdbz!PdbTestCase.test_run_pdb_with_pdb

sD��������e�}�h�?�����
�
��J�J��N�N�4��$�	
rc
�@
�d
}
t
j|
�

|
dz}tj|
�

t	|d�5
	ddd�
|jtj|
�
|j
d|
gdd��\}}|jd|�
y#1s
w
Y

�UxYw
)	Nr�r�r�r�r�r�r
z-ImportError: No module named t_main.__main__;)rr�r�r�r�r�r�r�)rr�r�r�r�s     r�test_module_without_a_mainz&PdbTestCase.test_module_without_a_main
s���������%��.�0�	�
�����
�)�S�
!��"����	�(�(�+�6����
�;����'�
����	
�
�
�E�v�N�
"�
!�s�
B�Bc
�p
�d
}
d}t
j|
�

|
dz|z}tj|�

t	|dzd�5
	ddd�
|jtj|
�
|j
d|jdd�gdd	�
�\}}|jd|�
y#1s
w
Y

�exYw
)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�rY
r�)r�pkg_namer��modpathr�r�s      r�test_package_without_a_mainz'PdbTestCase.test_package_without_a_main"
s�����������"��S�.�;�.��
���G��
�'�N�*�C�
0��1����	�(�(�(�3����
�7�?�?�3��,�-�r�q�'�
����	
�
�
�I��	�
1�
0�s�
B,�,B5c
��tjjtj�
rJ�
|jd
tjgdd��\}
}|j
dtj��|
�
y)Nr�r�r�r
zImportError: No module named )r�r5
�existsrr�r�r��rr�r�s   r�test_nonexistent_modulez#PdbTestCase.test_nonexistent_module2
s_���7�7�>�>�)�"2�"2�3�3�3�����i�.>�.>�'?��YZ��[�����
�
�5�i�6F�6F�5G�H�&�Qrc
��t
j�5}
|j|
g
d
d��\}}|jd|
�d�|�
ddd�
y#1s
w
Y

yxYw
)Nr�r�r
zError: z is a directory)rr4
r�r�)rr4
r�r�s    r�test_dir_as_scriptzPdbTestCase.test_dir_as_script7
sM��
�
�
�
!�X�!�]�]�H�:�r�q�]�Q�N�F�F��M�M�G�H�:�_�=�v�F�"�
!�
!�s�/A
�
Ac
��|j
d
g
dd��\}
}|jd|
�
|j
dg
dd��\}
}|jd|
�
y)Nz-cr�r�r
z"Error: option -c requires argumentz--spamz#Error: option --spam not recognized)r�r�rg
s   r�test_invalid_cmd_line_optionsz)PdbTestCase.test_invalid_cmd_line_options<
sT������v�r�q��I�����
�
�:�V�D�����z�2�1��M�����
�
�;�f�Erc
��d
}
d}|j
|
|�\}}|jtd�|j�D��
|�
y)NzY
                #This is a comment, on line 2

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

�
y
�w
)z__main__.py(4)<module>()Nr&r�s  rr�z=PdbTestCase.test_blocks_at_first_code_line.<locals>.<genexpr>L
s ����
?�*=�Q�7� �
!�*=�r�rJ
rK
s     r�test_blocks_at_first_code_linez*PdbTestCase.test_blocks_at_first_code_lineB
sU����
���,�,�V�X�>��������
?�*0�*;�*;�*=�
?�
?�@F�
	H
rc
�@�d
|_tj|j�

|jdz}
|jdz}|jdz}|jtj|j�
t	j
|j�

t
|d�5}|jtjd�
�

ddd�
t
|
d�5}|jtjd�
�

ddd�
t
|d�5}|jtjd�
�

ddd�
d	}|jd
|jg|�\}}|jtd�|j�D��
|�
|jtd�|j�D��
�

|jtd
�|j�D��
�

y#1s
w
Y

�
�.xYw
#1s
w
Y

�
�xYw
#1s
w
Y

��xYw
)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|
v�
�

�
y
�w
�zVAR from moduleNr&r�s  rr�z4PdbTestCase.test_relative_imports.<locals>.<genexpr>p
rR
r�c
3�$K
�|]}
d|
v�
�

�
y
�w
)zVAR from topNr&r�s  rr�z4PdbTestCase.test_relative_imports.<locals>.<genexpr>q
s����M�9L�A�N�a�/�9L�r�c
3�$K
�|]}
d|
v�
�

�
y
�w
)z
second varNr&r�s  rr�z4PdbTestCase.test_relative_imports.<locals>.<genexpr>r
s����K�7J�!�L�A�-�7J�r��r�rr�r�r�r�r�r�r�r�r�r�r
r

�rr�r��module_filer�r�r�r�s        r�test_relative_importsz!PdbTestCase.test_relative_importsO
s�
��#�������)�)�*��$�$�~�5�	��$�$�~�5�	��&�&��5�����	�(�(�$�*:�*:�;�
����!�!�"�
�)�S�
!�Q�
�G�G�H�O�O�%��
�"��)�S�
!�Q�
�G�G�H�O�O�%��
�"��+�s�
#�q�
�G�G�H�O�O�%��
�$�
���M�M�4��)9�)9�":�H�E�	��
�����P�F�<M�<M�<O�P�P�RX�Y�����M��9J�9J�9L�M�M�N�����K�v�7H�7H�7J�K�K�L�7"�
!��"�
!��$�
#�s$�)%G:�"%H�%H�:H�H�Hc
��d
|_tj|j�

|jdz}
|jdz}|jdz}|jtj|j�
t	j
|j�

t
|d�5}|jtjd�
�

ddd�
t
|
d�5}|jtjd�
�

ddd�
t
|d�5}|jtjd�
�

ddd�
d	}|jd
|jdzg|�\}}|jtd�|j�D��
|�
y#1s
w
Y

��xYw
#1s
w
Y

��xYw
#1s
w
Y

�xxYw
)
Nr�z	/runme.pyr�rq
r�rr
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|
v�
�

�
y
�w
rt
r&r�s  rr�zDPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr>�
rR
r�rw
rx
s        r�%test_relative_imports_on_plain_modulez1PdbTestCase.test_relative_imports_on_plain_modulet
sp
��#�������)�)�*��$�$�{�2�	��$�$�~�5�	��&�&��5�����	�(�(�$�*:�*:�;�
����!�!�"�
�)�S�
!�Q�
�G�G�H�O�O�%��
�"��)�S�
!�Q�
�G�G�H�O�O�%��
�"�
�+�s�
#�q�
�G�G�H�O�O�%��
�$����M�M�4��)9�)9�H�)D�"E�x�P�	��
�����P�F�<M�<M�<O�P�P�RX�Y�)"�
!��"�
!��
$�
#�s$�)%F�"%F+�%F7�F(�+F4�7Gc
��d
j
gd�
�
}
|jd|
d
z�\}}|j|j�ddgd�
�
y)Nr
)zprint(zdebug print(zdebug doesnotexist�
c�passr�)
r
z+(Pdb) *** SyntaxError: '(' was never closed�!(Pdb) ENTERING RECURSIVE DEBUGGERz%*** SyntaxError: '(' was never closed�LEAVING RECURSIVE DEBUGGERr�
z> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedr�
�(Pdb) �r
r�r�r

)rr�r�r�s    r�test_errors_in_commandz"PdbTestCase.test_errors_in_command�
sV���9�9�
����'�'���4��@�	��
�����*�*�,�Q�R�0�
3
�
	rc
�4���f
d
�}
|
dd�
|
dd�
y)z.do_run handles exceptions from parsing its argc��
�d
j
d|��dg�
}�jd|d
z�\}}�j|j�dddd|�d|
��d	g�
y)
Nr
zrun �
qr�
r�r
z(Pdb) *** Cannot run z: r�
r�
)�bad_arg�msgr�r�r�rs     �r�checkz*PdbTestCase.test_issue34266.<locals>.check�
sz����y�y��w�i� ��"��H��+�+�F�H�t�O�D�I�F�A����V�.�.�0���4��'��y��3�%�8��7�
r�
\zNo escaped character�
"zNo closing quotationNr&)rr�
s` r�test_issue34266zPdbTestCase.test_issue34266�
s ���
	�	�d�*�+�
�c�)�*rc
�X
�t
jd
�
}
d}tj�5}dtj
j
|�
��}|j|
|�\}}|j|jd�
djd�
|�
ddd�
y#1s
w
Y

yxYw
)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
�rW
N)r�r�r�temp_cwdr�r5
�realpathr�r��split�rstrip)rr�r��cwdr�r�r�s       r�test_issue42384zPdbTestCase.test_issue42384�
s������"�
����
�
�
�
!�S�.�r�w�w�/?�/?��/D�.E�F�H�!�0�0���B�N�F�F����V�\�\�$�/�
�2�9�9�$�?��J�"�
!�
!�s�A+B � B)c
��t
jd
�
}
d}tj�5}tj
j
|�
}tj
j|d�}tj
j|d�}d|��}t	j|�

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

ddd�
t	j|�

t	jtj
j|d�tj
j|d��
|jtj
jdd�g
|�\}}	|j|jd	�
d
jd�
|�
ddd�
y#1s
w
Y

��xYw
#1s
w
Y

yxYw
)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�Nr
r�
rW
)r�r�rr�
r�r5
r�
r
r�r�r��symlinkr�r�r�
r�
)
rr�r�r�
r�
r�
r�r�r�r�s
          r�test_issue42384_symlinkz#PdbTestCase.test_issue42384_symlink�
sM
�����"�
����
�
�
�
!�S��'�'�"�"�3�'�C��g�g�l�l�3�	�2�G��g�g�l�l�3�	�2�G�.�w�i�8�H��H�H�W���b�g�g�l�l�7�H�5�s�;�q������<��H�H�W���J�J�r�w�w�|�|�G�X�6������W�h�8W�X�!�]�]�B�G�G�L�L��H�,M�+N�PX�Y�N�F�F����V�\�\�$�/�
�2�9�9�$�?��J�"�
!�<�;��"�
!�s%�B$G
�G
�"CG
�
G
	�G
�
Gc
���t
j�5}
td
d�5}tjd�
}|j|�

ddd�
tjj|
d�}t
j|�

t
jtjj|d��

tjj|d
�}t|d�5}|jd�

ddd�
|jd
g
d�\}}d}|j|jd�
d	jd
�
|�
ddd�
y#1s
w
Y

�
�xYw
#1s
w
Y

�jxYw
#1s
w
Y

yxYw
)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
�rW
)rr�
r�r�r�r�r�r5
r
r�r�r�r�
r�
)	rr�
r��
sr�
�
wrong_filer�r�r�s	         r�test_issue42383zPdbTestCase.test_issue42383�
s
��
�
�
�
!�S��h��$�
��O�O�%��
����
�
�%��W�W�\�\�#�x�0�F��H�H�V���H�H�R�W�W�\�\�&�(�3�4������f�h�7�J��j�#�&�!����>�?�'�"�]�]�H�:�y�A�N�F�F�<�H����V�\�\�$�/�
�2�9�9�$�?��J�)"�
!�$�$��'�&��"�
!�s<�
E,�'E�	BE,�%E �7AE,�E	�E,� E)	�%E,�,E5c
�~�d
}
t
jd�
}|j|
|�\}}|j|�

y)Nz�            def func():
                def inner(v): pass
                inner(
                    42
                )
            func()
        zj
            break func
            continue
            next
            next
            jump 2
        )r�r�r��assertFalserK
s     r�test_gh_94215_crashzPdbTestCase.test_gh_94215_crash�
sD�����?�?�$�
���,�,�V�X�>�������� rc
�
�d
}
d}d}t
dd�5}|jtj|
�
�

ddd�
t
dd�5}|jtj|�
�

ddd�
|j	t
jd�
|j	t
jd�
|jdg
|�\}}|jd|d�
y#1s
w
Y

��xYw
#1s
w
Y

�xYw
)	Nza
        def func():
            x = "Sentinel string for gh-93696"
            print(x)
        aL
        import os
        import sys

        def _create_fake_frozen_module():
            with open('gh93696.py') as f:
                src = f.read()

            # this function has a co_filename as if it were in a frozen module
            dummy_mod = compile(src, "<frozen gh93696>", "exec")
            func_code = dummy_mod.co_consts[0]

            mod = type(sys)("gh93696")
            mod.func = type(lambda: None)(func_code, mod.__dict__)
            mod.__file__ = 'gh93696.py'

            return mod

        mod = _create_fake_frozen_module()
        mod.func()
        zf
            break 20
            continue
            step
            list
            quit
        z
gh93696.pyr�zgh93696_host.pyz"x = "Sentinel string for gh-93696"zSentinel statement not found)	r�r�r�r�r�rr�r�r�)r�
frozen_src�host_programr�r�r�r�s       r�test_gh_93696_frozen_listz%PdbTestCase.test_gh_93696_frozen_list
s����
�
��*���,��
$�
�
�G�G�H�O�O�J�/�0�%��#�S�
)�Q�
�G�G�H�O�O�L�1�2�*�	
���	�(�(�,�7����	�(�(�*;�<����(9�':�H�E�����
�
�:�F�Db�c�%�
$��*�
)�s�%C#�%C/�#C,�/C8c
��d
}
d}|j
|
|�\}}|jd|�
|j|
|�\}}|jd|�
y)Nr�r!
z
main.py(0)z__main__.py(0))r�r�r�r�s     r�test_empty_filezPdbTestCase.test_empty_file;sW�������'�'���9�	��
��
�
�l�F�+��'�'���9�	��
��
�
�&��/rc
�@
�tjjtjjt�
d
�}
t
j
|
�
D]E}|j
d�
s
�|jtjj|
|�g
d�
�Gy)N�encoded_modulesz.pyr�
)r�r5
r
�dirname�__file__�listdir�endswithr�)r�
script_dirr�s   r�test_non_utf8_encodingz"PdbTestCase.test_non_utf8_encodingEse���W�W�\�\�"�'�'�/�/�(�";�=N�O�
��
�
�:�.�H�� � ��'��
�
�r�w�w�|�|�J��A�B�C�H�/r)
r)rNF):r"r#r$r��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/
r2
r;
rC
rL
rO
rU
rZ
r\
rd
rh
rj
rl
ro
rz
r}
r�
r�
r�
r�skip_unless_symlinkr�
r�
r�
r�
r�
r�
r&rrr�r�$sX
��
+��X�_�_�S�Y�Y�(�(�>�
@
��
@
��*,-�!�#(��2A
�F
�
5�
� 
�"
�
&�
M
�V
�*";�H
G
�8G
�<'�F
�)�<+�'� *�$,�$*� 7�$J
�3�;�R
�
R
�
V
�	
�O
�� R
�
G
�
F
�H
�#M
�J
Z
�>�0+� 
K
��"�"�K
�#�K
�0K
�.!�&,d
�\
0�I
rr�c
�*�eZ
dZd
�Zd�Zd�Zd�Zd�Zy)�ChecklineTestsc
�,�t
j�
yr)�	linecache�
clearcachers
 r�setUpzChecklineTests.setUpLs�����rc
�J�t
jtj�

yrr�rs
 rr�zChecklineTests.tearDownOr�rc
�
�t
tjd
�5}
|
jd�

ddd�
t	j
�}|j
|jtjd�d�
y#1s
w
Y

�NxYw
�Nr�z
print(123)r�)r�rr�r�r\r]r��	checkline�rr��dbs   r�test_checkline_before_debuggingz.ChecklineTests.test_checkline_before_debuggingRsZ��
�)�"�"�C�
(�A�
�G�G�L�!�)�
�W�W�Y��������i�&6�&6�
�:�A�>�)�
(�s�A:�:Bc
�,
�t
tjd
�5}
|
jd�

ddd�
t	j
�}|j
�
|j|jtjd�d�
y#1s
w
Y

�^xYw
r�
)	r�rr�r�r\r]�resetr�r�
r�
s   r�test_checkline_after_resetz)ChecklineTests.test_checkline_after_resetXsc��
�)�"�"�C�
(�A�
�G�G�L�!�)�
�W�W�Y��
���
�������i�&6�&6�
�:�A�>�	)�
(�s�B
�
Bc
��
�t
jd
�
}
ttjd�5}|j|
�

ddd�
t
|
j��
dz}tt��
5
tj�}t|�
D]1}|j|jtj|��

�3	ddd�
y#1s
w
Y

��xYw
#1s
w
Y

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

        r�r�
)r�r�r�rr�r��lenr

rrr\r]�ranger�
r�
)rr�
r��	num_linesr�
�linenos      r� test_checkline_is_not_executablez/ChecklineTests.test_checkline_is_not_executable_s����O�O��

�
��)�"�"�C�
(�A�
�G�G�A�J�)��
����'�!�+�	�
�X�Z�
(�����B��	�*��� � ����i�.>�.>��!G�H�+�)�
(�)�
(��)�
(�s�C�9AC#�C �#C,N)r"r#r$r�
r�r�
r�
r�
r&rrr�
r�
Ks��
�
+�?�?�I
rr�
c
��eZ
dZd
�Zd�Zy)�PdbTestReadlinec�z�t
d
�
}|jr$d|jvrtjd�
�
yy)N�readline�libeditz)libedit readline is not supported for pdb)rr%r�
�SkipTest)
r�
s
 r�
setUpClasszPdbTestReadline.setUpClassrs>��!��,�����	�X�-=�-=� =��#�#�$O�P�P�!>�rc
���t
jd
�
}
d}t|
|�}|jd|�
|jd|�
|jd|�
|jd|�
y)Nz�
            import pdb; pdb.Pdb().set_trace()
            # Concatenate strings so that the output doesn't appear in the source
            print('hello' + '!')
        s
co		ntin	
scommandss	conditionscontinueshello!)r�r�r	r�)rr�rr�s    r�test_basic_completionz%PdbTestReadline.test_basic_completionys`�����"�
��"�����'���
�
�k�6�*��
�
�l�F�+��
�
�k�6�*��
�
�i��(rN)r"r#r$r�
r�
r&rrr�
r�
ps
��Q
�)rr�
c�Z�d
dlm
}
|
jtj|�
�

|
S)Nr)
�test_pdb)�testr�
�addTest�doctest�DocTestSuite)�loader�tests�patternr�
s    r�
load_testsr�
�s!���	�M�M�'�&�&�x�0�1��Lr�__main__)Wr�
r�r\r�typesr�r�
r�r�r�
�
contextlibrr�iorr�
r�test.supportr�test.support.import_helperr�test.support.pty_helperr	r
�
unittest.mockr�has_socket_support�SKIP_ASYNCIO_TESTSr@
r
r(r+r0r2r4r6r8r:r<r@rBrDrFrHrJrLrNrPrR�
ModuleType�mod�exec�__dict__rUrWr`rbrdrfrhrjrlrnrprrrtrvrxrzr|r~r�r�r�r�r�r�r�r��requires_subprocess�TestCaser�r�
r�
r�
r"�mainr&rr�<module>r�

s!�


�
�	�
�
��
�����1���"�4�6��"�4�4�4��
*�6�
*�"
�:S
�j
&�@
�D"
�H
A

�F
�6
�B


	�

�]

�~(
�T
9
�v
-
�^
9
�v
U

�n;
�|
1
�h

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

?�


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

�2
�:+
�Z
@

�D
�:
�2
�*
�$
�.2
�h
-
�`
��
�
�
�d
I
�(�#�#�d
I
��d
I
�L"
I
�X�&�&�"
I
�J
��
�
�
�
)�h�'�'�
)��
)�6
��z���H�M�M�O�r