Sindbad~EG File Manager

Current Path : /usr/local/lib/python3.9/test/__pycache__/
Current File : //usr/local/lib/python3.9/test/__pycache__/test_pdb.cpython-39.pyc
a

��g7��@s�ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZmZddl
mZddlmZddlmZddlmZddlmZdd	�ZGd
d�de�Zdd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Z dd�Z!dd�Z"dd�Z#e�$d �Z%e&d!e%j'�d"d#�Z(d$d%�Z)d&d'�Z*d(d)�Z+d*d+�Z,d,d-�Z-d.d/�Z.d0d1�Z/d2d3�Z0d4d5�Z1d6d7�Z2d8d9�Z3d:d;�Z4d<d=�Z5d>d?�Z6d@dA�Z7dBdC�Z8GdDdE�dEej9�Z:GdFdG�dGej9�Z;dHdI�Z<e=dJk�r�e�>�dS)K�N)�	ExitStack�redirect_stdout)�StringIO)�support)�
_FakeInput)�patch)�
BreakpointcCsdt_it_dgt_dS)N�)r�nextZbplistZ
bpbynumber�rr�)/usr/local/lib/python3.9/test/test_pdb.py�reset_Breakpointsr
c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�PdbTestInputz:Context manager that makes testing Pdb in doctests easier.cCs
||_dS�N)�input)�selfrrrr�__init__ szPdbTestInput.__init__cCs0tj|_t|j�t_ttd�r&t��nd|_dS)N�gettrace)�sys�stdin�
real_stdinrr�hasattrr�
orig_trace�rrrr�	__enter__#szPdbTestInput.__enter__cGs|jt_|jrt�|j�dSr)rrrr�settrace)r�excrrr�__exit__(szPdbTestInput.__exit__N)�__name__�
__module__�__qualname__�__doc__rrrrrrrrsrcCsdS)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
    Nrrrrr�test_pdb_displayhook.sr"cCsdS)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
    Nrrrrr�test_pdb_basic_commandsKsr#cCsdS)a�Test basic commands related to breakpoints.

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

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

    >>> reset_Breakpoint()

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

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'break 3',
    ...     'disable 1',
    ...     'ignore 1 10',
    ...     'condition 1 1 < 2',
    ...     'break 4',
    ...     'break 4',
    ...     'break',
    ...     'clear 3',
    ...     'break',
    ...     'condition 1',
    ...     'enable 1',
    ...     'clear 1',
    ...     'commands 2',
    ...     'p "42"',
    ...     'print("42", 7*6)',     # Issue 18764 (not about breakpoints)
    ...     'end',
    ...     'continue',  # will stop at breakpoint 2 (line 4)
    ...     'clear',     # clear all!
    ...     'y',
    ...     'tbreak 5',
    ...     'continue',  # will stop at temporary breakpoint
    ...     'break',     # make sure breakpoint is gone
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(3)test_function()
    -> print(1)
    (Pdb) break 3
    Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) disable 1
    Disabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) ignore 1 10
    Will ignore next 10 crossings of breakpoint 1.
    (Pdb) condition 1 1 < 2
    New condition set for breakpoint 1.
    (Pdb) break 4
    Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break 4
    Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
            stop only if 1 < 2
            ignore next 10 hits
    2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    3   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) clear 3
    Deleted breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
            stop only if 1 < 2
            ignore next 10 hits
    2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) condition 1
    Breakpoint 1 is now unconditional.
    (Pdb) enable 1
    Enabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) clear 1
    Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) commands 2
    (com) p "42"
    (com) print("42", 7*6)
    (com) end
    (Pdb) continue
    1
    '42'
    42 42
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(4)test_function()
    -> print(2)
    (Pdb) clear
    Clear all breaks? y
    Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) tbreak 5
    Breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
    (Pdb) continue
    2
    Deleted breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(5)test_function()
    -> print(3)
    (Pdb) break
    (Pdb) continue
    3
    4
    Nrrrrr�test_pdb_breakpoint_commands�sr$cCsdS)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
    Nrrrrr�test_pdb_pp_repr_excLsr%cCsdSrrrrrr�
do_nothinghsr&cCstd�dS)N�*)�printrrrr�do_somethingksr)cCsdS)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
    Nrrrrr�test_list_commandsnsr*cCsdS)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
    Nrrrrr�test_pdb_whatis_command�sr+cCsdS)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.
    Nrrrrr�test_post_mortem�sr,cCsdS)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
    Nrrrrr�test_pdb_skip_modules5sr-Zmodule_to_skipz6def foo_pony(callback): x = 1; callback(); return NonecCsdS)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
    Nrrrrr�#test_pdb_skip_modules_with_callbackQsr.cCsdS)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
    Nrrrrr� test_pdb_continue_in_bottomframe|sr/cCsttjddd�|�|�dS)zRun pdb.method(arg).TF)ZnosigintZreadrcN)�getattr�pdb�Pdb)�method�argrrr�
pdb_invoke�sr5cCsdS)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
    Nrrrrr�$test_pdb_run_with_incorrect_argument�sr6cCsdS)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
    Nrrrrr�test_pdb_run_with_code_object�sr7cCsdS)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
    Nrrrrr�&test_next_until_return_at_return_event�sr8cCsdS)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
    Nrrrrr�#test_pdb_next_command_for_generatorsr9cCsdS)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
    Nrrrrr�#test_pdb_next_command_for_coroutineLsr:cCsdS)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
    Nrrrrr�"test_pdb_next_command_for_asyncgen�sr;cCsdS)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
    Nrrrrr�%test_pdb_return_command_for_generator�sr<cCsdS)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
    Nrrrrr�%test_pdb_return_command_for_coroutine�sr=cCsdS)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
    Nrrrrr�$test_pdb_until_command_for_generator"sr>cCsdS)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
    Nrrrrr�$test_pdb_until_command_for_coroutineNsr?cCsdS)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
    Nrrrrr�+test_pdb_next_command_in_generator_for_loop}sr@cCsdS)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
    Nrrrrr�!test_pdb_next_command_subiterator�srAcCsdS)a(Test for reference leaks when the SIGINT handler is set.

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

    >>> with PdbTestInput(['continue',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_issue_20766[0]>(6)test_function()
    -> print('pdb %d: %s' % (i, sess._previous_sigint_handler))
    (Pdb) continue
    pdb 1: <built-in function default_int_handler>
    > <doctest test.test_pdb.test_pdb_issue_20766[0]>(5)test_function()
    -> sess.set_trace(sys._getframe())
    (Pdb) continue
    pdb 2: <built-in function default_int_handler>
    Nrrrrr�test_pdb_issue_20766�srBcCsdS)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
    Nrrrrr�test_pdb_issue_43318�srCc@seZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�Z d=d>�Z!e"j#d?d@��Z$dAdB�Z%dCS)D�PdbTestCasecCst�tj�dSr�r�unlink�TESTFNrrrr�tearDown
szPdbTestCase.tearDowncCs�|�tjd�tjddg|}tj|tjtjtjit	j
�ddi�d��$}|�t�
|��\}}Wd�n1sp0Y|o�t�|�}|o�t�|�}||fS)N�__pycache__�-mr1�PYTHONIOENCODING�utf-8��stdoutr�stderr�env)�
addCleanupr�rmtreer�
executable�
subprocess�Popen�PIPE�STDOUT�os�environ�communicate�str�encode�bytes�decode)rZpdb_args�commands�cmd�procrNrOrrr�_run_pdbs�2zPdbTestCase._run_pdbcCsZd}t|d�� }|�t�|��Wd�n1s40Y|�tj|�|�|g|�S)z3Run 'script' lines with pdb and the pdb 'commands'.�main.py�wN)�open�write�textwrap�dedentrQrrFrb)r�scriptr_�filename�frrr�run_pdb_scripts
.zPdbTestCase.run_pdb_scriptcCs�d|_t�|j�|jd}|jd}t�|j�t|d��}Wd�n1sR0Yt|d�� }|�t�|��Wd�n1s�0Y|�	tj|j�|�
d|jg|�S)z(Runs the script code as part of a module�t_main�/__main__.py�/__init__.pyrdNrJ)�module_namerrRrX�mkdirrerfrgrhrQrb)rrir_�	main_file�	init_filerkrrr�run_pdb_module's

.zPdbTestCase.run_pdb_modulecCslttjd��}|�|�Wd�n1s,0Y|s>dn|dtj|df}|�|t�|tj��dS)N�wbrr	)rerrGrf�assertEqualr1Z
find_function)rZfile_content�	func_name�expectedrkrrr�_assert_find_function5s(��z!PdbTestCase._assert_find_functioncCs|�ddd�dS)N�Zfoo)ryrrrr�test_find_function_empty_file>sz)PdbTestCase.test_find_function_empty_filecCs|�d��dd�dS)Nu@def foo():
    pass

def bœr():
    pass

def quux():
    pass
�bœr)r|��ryr\rrrr�test_find_function_foundAs

�z$PdbTestCase.test_find_function_foundcCs|�d�d�dd�dS)NuV# coding: iso-8859-15
def foo():
    pass

def bœr():
    pass

def quux():
    pass
ziso-8859-15r|)r|�r~rrrr�-test_find_function_found_with_encoding_cookieQs
��z9PdbTestCase.test_find_function_found_with_encoding_cookiecCs|�tjd��dd�dS)Nudef bœr():
    pass
r|)r|r	)ry�codecs�BOM_UTF8r\rrrr�!test_find_function_found_with_bombs
�z-PdbTestCase.test_find_function_found_with_bomcCs�ttjd��}|�d�Wd�n1s,0Ytjddtjg}tj|tjtjtj	d�}|�
|jj�|�
d�\}}|�d|d�dS)	Nrusprint("testing my pdb")
rJr1�rNrrOsquit
sSyntaxErrorz0Got a syntax error running test script under PDB)rerrGrfrrSrTrUrVrWrQrN�closerZ�assertNotIn�rrkr`rarNrOrrr�test_issue7964ls(��zPdbTestCase.test_issue7964cCsHd}d}|�||�\}}|pd|p$d}|�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)rlr��assertIn)rrir_rNrO�outputrrr�test_issue46434{s��zPdbTestCase.test_issue46434cCs�d}d}d}tdd�� }|�t�|��Wd�n1s<0Y|�tjd�|�||�\}}|�t	dd�|�
�D��d�dS)	Nz�
            from bar import bar

            def foo():
                bar()

            def nope():
                pass

            def foobar():
                foo()
                nope()

            foobar()
        z�
            from bar import bar
            break bar
            continue
            step
            step
            quit
        z5
            def bar():
                pass
        zbar.pyrdcss|]}d|vVqdS)zmain.py(5)foo()->NoneNr��.0�lrrr�	<genexpr>�rzz.PdbTestCase.test_issue13183.<locals>.<genexpr>z+Fail to step into the caller after a return)rerfrgrhrQrrFrl�
assertTrue�any�
splitlines)rrir_ZbarrkrNrOrrr�test_issue13183�s.�zPdbTestCase.test_issue13183cCs�ttjd��&}|�t�d��d��Wd�n1s80Ytjdtjg}t	j
|t	jt	jt	jit
j�ddi�d�}|�|jj�|�d�\}}|�d	|d
�dS)Nrua
                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�-urKrLrMscont
�Error�*Got an error running test script under PDB�rerrGrfrgrhr\rrSrTrUrVrWrXrYrQrNr�rZr�r�rrr�test_issue13120�s 
�$��zPdbTestCase.test_issue13120cCs�ttjd��&}|�t�d��d��Wd�n1s80Ytjdtjg}t	j
|t	jt	jt	jit
j�ddi�d�}|�|jj�|�d�\}}|�d	|d
�dS)Nrua�
                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�rKrLrMs
cont
cont
r�r�r�r�rrr�test_issue36250�s �$��zPdbTestCase.test_issue36250cCs6d}d}d}|�||�\}}|�||d�||��dS)Nzdef f: pass
r�zSyntaxError:zE

Expected:
{}
Got:
{}
Fail to handle a syntax error in the debuggee.)rlr��format)rrir_rxrNrOrrr�test_issue16180�s��zPdbTestCase.test_issue16180cCsLd}d}|�||�\}}d�dd�|��D��}|�|d�|�|d�dS)Nzprint('hello')z[
            continue
            run a b c
            run d e f
            quit
        �
cSsg|]}|���qSr)�strip)r��xrrr�
<listcomp>rzz/PdbTestCase.test_issue26053.<locals>.<listcomp>z#Restarting .* with arguments:
a b cz#Restarting .* with arguments:
d e f)rl�joinr�ZassertRegex)rrir_rNrO�resrrr�test_issue26053�szPdbTestCase.test_issue26053c	Cs@t�d�}tj�dd�}�z
t����tdd��}|�d�Wd�n1sP0Ytdd��}|�|�Wd�n1s�0Yt	j
dg}tj|tj
tj
tj
d�}|�*|�d�\}}|�d	|�Wd�n1s�0YWd�n1�s0YW|du�r<|tjd<n|du�r:|tjd<0dS)
Nz_
            import pdb; pdb.Pdb(readrc=False).set_trace()

            print('hello')
        �HOME�.pdbrcrdzinvalid
rcr�sq
s(NameError: name 'invalid' is not defined)rgrhrXrY�popr�temp_cwdrerfrrSrTrUrVrZr�)rri�	save_homerkr`rarNrOrrr�test_readrc_kwargs0

((
��D
�
zPdbTestCase.test_readrc_kwargcCs�tj�dd�}t����}td���tj�|d�}|tjj_	z`t
|d��}|�d�Wd�n1sf0Y|�t
��jdd�W|dur�|tjd<n|dur�|tjd<0Wd�n1s�0YWd�n1s�0YdS)Nr�zos.path.expanduserr�rd�invalidr)rXrYr�r�temp_dirr�pathr��
expanduserZreturn_valuererfrvr1r2ZrcLines)rr�r�Zrc_pathrkrrr�test_readrc_homedir's
(�zPdbTestCase.test_readrc_homedircCsxt�}d}t��@}|�td|��|�t�tjd��tj|d�Wd�n1sV0Y|�|�	�|d�dS)Nz"Nobody expects... blah, blah, blahz
sys.stdout�	set_trace)�headerr�)
rr�
enter_contextr�objectr1r2r�rv�getvalue)rrNr�Z	resourcesrrr�test_header4s*zPdbTestCase.test_headercCs:d}d}|�||�\}}|�tdd�|��D��|�dS)Nzprint("SUCCESS")�/
            continue
            quit
        css|]}d|vVqdS��SUCCESSNrr�rrrr�Drzz.PdbTestCase.test_run_module.<locals>.<genexpr>�rtr�r�r��rrir_rNrOrrr�test_run_module=szPdbTestCase.test_run_modulecCs:d}d}|�||�\}}|�tdd�|��D��|�dS)NzQ
            if __name__ == '__main__':
                print("SUCCESS")
        r�css|]}d|vVqdSr�rr�rrrr�Przz9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>r�r�rrr�test_module_is_run_as_mainFsz&PdbTestCase.test_module_is_run_as_maincCsXd}d}|�||�\}}|�tdd�|��D��|�|�tdd�|��D��|�dS)Nz{
            if __name__ == '__main__':
                pass
                print("SUCCESS")
                pass
        z*
            b 3
            quit
        css|]}d|vVqdS)zBreakpoint 1 atNrr�rrrr�^rzz.PdbTestCase.test_breakpoint.<locals>.<genexpr>css|]}d|vVqdSr�rr�rrrr�_rz)rtr�r�r��allr�rrr�test_breakpointRs
zPdbTestCase.test_breakpointcCs2d}|�ddg|�\}}|�tj|�dd��dS)Nz(
            c
            quit
        rJr1�
r�)rbr�r1Z_usage�replace)rr_rNrOrrr�test_run_pdb_with_pdbas
�z!PdbTestCase.test_run_pdb_with_pdbcCs�d}t�|�|d}t�|�t|d��Wd�n1s@0Y|�tj|�|�d|gd�\}}|�d|���dS)NrmrordrJr�z,ImportError: No module named t_main.__main__)	rrRrXrqrerQrbr�r�)rrprsrNrOrrr�test_module_without_a_mainls

�z&PdbTestCase.test_module_without_a_maincCs�d}d}t�|�|d|}t�|�t|dd��Wd�n1sL0Y|�tj|�|�d|�dd�gd�\}}|�d	|�dS)
NZt_pkgrm�/rordrJ�.r�z;'t_pkg.t_main' is a package and cannot be directly executed)	rrRrX�makedirsrerQrbr�r�)rZpkg_namerp�modpathrNrOrrr�test_package_without_a_mainxs

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

                print("SUCCESS")
        z
            quit
        css|]}d|vVqdS)z__main__.py(4)<module>()Nrr�rrrr��s��z=PdbTestCase.test_blocks_at_first_code_line.<locals>.<genexpr>r�r�rrr�test_blocks_at_first_code_line�s��z*PdbTestCase.test_blocks_at_first_code_linecCsnd|_t�|j�|jd}|jd}|jd}|�tj|j�t�|j�t|d�� }|�t�	d��Wd�n1s|0Yt|d�� }|�t�	d��Wd�n1s�0Yt|d�� }|�t�	d��Wd�n1s�0Yd	}|�
d
|jg|�\}}|�tdd�|�
�D��|�|�td
d�|�
�D���|�tdd�|�
�D���dS)Nrmrnro�
/module.pyrd�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
        rJcss|]}d|vVqdS�zVAR from moduleNrr�rrrr��rzz4PdbTestCase.test_relative_imports.<locals>.<genexpr>css|]}d|vVqdS)zVAR from topNrr�rrrr��rzcss|]}d|vVqdS)z
second varNrr�rrrr��rz�rprrRrQrXrqrerfrgrhrbr�r�r��rrrrsZmodule_filerkr_rN�_rrr�test_relative_imports�s$


...z!PdbTestCase.test_relative_importscCs:d|_t�|j�|jd}|jd}|jd}|�tj|j�t�|j�t|d�� }|�t�	d��Wd�n1s|0Yt|d�� }|�t�	d��Wd�n1s�0Yt|d�� }|�t�	d��Wd�n1s�0Yd	}|�
d
|jdg|�\}}|�tdd
�|�
�D��|�dS)Nrmz	/runme.pyror�rdr�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
        rJz.runmecss|]}d|vVqdSr�rr�rrrr��rzzDPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr>r�r�rrr�%test_relative_imports_on_plain_module�s 


...z1PdbTestCase.test_relative_imports_on_plain_modulecCsBd�gd��}|�d|d�\}}|�|��dd�gd��dS)Nr�)zprint(zdebug print(zdebug doesnotexist�cr�r	)	z3(Pdb) *** SyntaxError: unexpected EOF while parsing�!(Pdb) ENTERING RECURSIVE DEBUGGERz-*** SyntaxError: unexpected EOF while parsing�LEAVING RECURSIVE DEBUGGERr�z> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedr��(Pdb) �r�rlrvr�)rr_rNr�rrr�test_errors_in_command�sz"PdbTestCase.test_errors_in_commandcs$�fdd�}|dd�|dd�dS)z.do_run handles exceptions from parsing its argcsVd�d|��dg�}��d|d�\}}��|��dd�dd|�d|��d	g�dS)
Nr�zrun �q�passr	z-> passz(Pdb) *** Cannot run z: r�r�)Zbad_arg�msgr_rNr�rrr�check�s��z*PdbTestCase.test_issue34266.<locals>.check�\zNo escaped character�"zNo closing quotationNr)rr�rrr�test_issue34266�s
zPdbTestCase.test_issue34266cCsxt�d�}d}t���N}dtj�|���}|�||�\}}|�|�	d�d�
d�|�Wd�n1sj0YdS)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)rgrhrr�rXr��realpathrlrv�split�rstrip)rrir_�cwdrxrNrOrrr�test_issue42384�s

zPdbTestCase.test_issue42384c
	Cst�d�}d}t����}tj�|�}tj�|d�}tj�|d�}d|��}t�|�t	tj�|d�d��}|�
|�Wd�n1s�0Yt�|�t�tj�|d�tj�|d��|�tj�dd�g|�\}}	|�
|�d	�d
�d�|�Wd�n1�s
0YdS)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.pyrdNr�r�r�)rgrhrr�rXr�r�r�rqrerf�symlinkrbrvr�r�)
rrir_r�r�r�rxrkrNrOrrr�test_issue42384_symlink
s



(
 z#PdbTestCase.test_issue42384_symlinkc		Cs
t����}tdd��$}t�d�}|�|�Wd�n1s>0Ytj�|d�}t�	|�t�	tj�|d��tj�|d�}t|d��}|�d�Wd�n1s�0Y|�
dgd�\}}d}|�|�d�d	�
d
�|�Wd�n1s�0YdS)Nr�rdz�
                    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�rergrhrfrXr�r�rqrbrvr�r�)	rr�rk�sr�Z
wrong_filerNrOrxrrr�test_issue42383&s

(
(zPdbTestCase.test_issue42383N)&rrr rHrbrlrtryr{rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rZskip_unless_symlinkr�r�rrrrrDsD	
$ 
		
%
rDc@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�ChecklineTestscCst��dSr)�	linecache�
clearcacherrrr�setUp?szChecklineTests.setUpcCst�tj�dSrrErrrrrHBszChecklineTests.tearDowncCsXttjd��}|�d�Wd�n1s,0Yt��}|�|�tjd�d�dS�Nrdz
print(123)r	)rerrGrfr1r2rv�	checkline�rrk�dbrrr�test_checkline_before_debuggingEs(z.ChecklineTests.test_checkline_before_debuggingcCs`ttjd��}|�d�Wd�n1s,0Yt��}|��|�|�tjd�d�dSr�)	rerrGrfr1r2�resetrvr�r�rrr�test_checkline_after_resetKs
(z)ChecklineTests.test_checkline_after_resetcCs�t�d�}ttjd��}|�|�Wd�n1s60Yt|���d}tt	���:t
��}t|�D]}|�
|�tj|��qlWd�n1s�0YdS)Nz\
            # Comment
            """ docstring """
            ''' docstring '''

        rdr�)rgrhrerrGrf�lenr�rrr1r2�rangeZassertFalser�)rr�rkZ	num_linesr��linenorrr� test_checkline_is_not_executableRs
(z/ChecklineTests.test_checkline_is_not_executableN)rrr r�rHr�r�rrrrrr�>s
r�cGs2ddlm}t�t�t�t�t�|�g}t�|�S)Nr)�test_pdb)	�testr�unittestZ	makeSuiterDr��doctestZDocTestSuiteZ	TestSuite)�argsrZsuitesrrr�
load_testscs�r�__main__)?rrXr1r�typesr�rrTrgr��
contextlibrr�iorrrZtest.test_doctestrZ
unittest.mockrZbdbrr
r�rr"r#r$r%r&r)r*r+r,r-�
ModuleType�mod�exec�__dict__r.r/r5r6r7r8r9r:r;r<r=r>r?r@rArBrCZTestCaserDr�rr�mainrrrr�<module>spk_*>
+*@;8=7*,/*/6%
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists