o

�
i�
�@sdd
lZdd
l
Z
dd
lZdd
lZdd
lZdd
lZdd
lZdd
lZdd
lZdd
l	Z	ddl
mZmZ
ddl
mZ
ddlmZ
ddlmZ
ddlmZ
Gdd�de�Zd	d
�Zdd�Zd
d�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Z dd�Z!dd �Z"d!d"�Z#d#d$�Z$d%d&�Z%e�&d'�
Z'e(d(e'j)�
d)d*�Z*d+d,�Z+d-d.�Z,d/d0�Z-d1d2�Z.d3d4�Z/d5d6�Z0d7d8�Z1d9d:�Z2d;d<�Z3d=d>�Z4d?d@�Z5dAdB�Z6dCdD�Z7dEdF�Z8dGdH�Z9dIdJ�Z:dKdL�Z;GdMdN�dNej<�Z=GdOdP�dPej<�Z>dQdR�Z?e@dSkr�e�A�
d
Sd
S)T�N)�	ExitStack�redirect_stdout)
�StringIO)
�	os_helper)
�
_FakeInput)
�patchc@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	�PdbTestInputz:Context manager that makes testing Pdb in doctests easier.cCs
|
|_dS�
N)
�input)�selfr
�r�*/usr/local/lib/python3.10/test/test_pdb.py�__init__s

zPdbTestInput.__init__c

Cs6tj
|_t|j�
t_
ttd
�rt��|_dSd|_dS)N�gettrace)�sys�stdin�
real_stdinrr
�hasattrr�
orig_trace�
rrrr
�	__enter__s

"
zPdbTestInput.__enter__c
Gs"|jt
_|jrt
�|j�

dSdSr	)rrrr�settrace)r�excrrr
�__exit__!s


�zPdbTestInput.__exit__N)�__name__�
__module__�__qualname__�__doc__rrrrrrr
rs

rc
C�d
S)a1This tests the custom displayhook for pdb.

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

    >>> with PdbTestInput([
    ...     'foo',
    ...     'bar',
    ...     'for i in range(5): print(i)',
    ...     'continue',
    ... ]):
    ...     test_function(1, None)
    > <doctest test.test_pdb.test_pdb_displayhook[0]>(3)test_function()
    -> pass
    (Pdb) foo
    1
    (Pdb) bar
    (Pdb) for i in range(5): print(i)
    0
    1
    2
    3
    4
    (Pdb) continue
    Nrrrrr
�test_pdb_displayhook'�rc
Cr)a�Test the basic commands of pdb.

    >>> def test_function_2(foo, bar='default'):
    ...     print(foo)
    ...     for i in range(5):
    ...         print(i)
    ...     print(bar)
    ...     for i in range(10):
    ...         never_executed
    ...     print('after for')
    ...     print('...')
    ...     return foo.upper()

    >>> def test_function3(arg=None, *, kwonly=None):
    ...     pass

    >>> def test_function4(a, b, c, /):
    ...     pass

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     ret = test_function_2('baz')
    ...     test_function3(kwonly=True)
    ...     test_function4(1, 2, 3)
    ...     print(ret)

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...     'step',       # entering the function call
    ...     'args',       # display function args
    ...     'list',       # list function source
    ...     'bt',         # display backtrace
    ...     'up',         # step up to test_function()
    ...     'down',       # step down to test_function_2() again
    ...     'next',       # stepping to print(foo)
    ...     'next',       # stepping to the for loop
    ...     'step',       # stepping into the for loop
    ...     'until',      # continuing until out of the for loop
    ...     'next',       # executing the print(bar)
    ...     'jump 8',     # jump over second for loop
    ...     'return',     # return out of function
    ...     'retval',     # display return value
    ...     'next',       # step to test_function3()
    ...     'step',       # stepping into test_function3()
    ...     'args',       # display function args
    ...     'return',     # return out of function
    ...     'next',       # step to test_function4()
    ...     'step',       # stepping to test_function4()
    ...     'args',       # display function args
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
    -> ret = test_function_2('baz')
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
    -> def test_function_2(foo, bar='default'):
    (Pdb) args
    foo = 'baz'
    bar = 'default'
    (Pdb) list
      1  ->     def test_function_2(foo, bar='default'):
      2             print(foo)
      3             for i in range(5):
      4                 print(i)
      5             print(bar)
      6             for i in range(10):
      7                 never_executed
      8             print('after for')
      9             print('...')
     10             return foo.upper()
    [EOF]
    (Pdb) bt
    ...
      <doctest test.test_pdb.test_pdb_basic_commands[4]>(25)<module>()
    -> test_function()
      <doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
    -> ret = test_function_2('baz')
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
    -> def test_function_2(foo, bar='default'):
    (Pdb) up
    > <doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
    -> ret = test_function_2('baz')
    (Pdb) down
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
    -> def test_function_2(foo, bar='default'):
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(2)test_function_2()
    -> print(foo)
    (Pdb) next
    baz
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(3)test_function_2()
    -> for i in range(5):
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(4)test_function_2()
    -> print(i)
    (Pdb) until
    0
    1
    2
    3
    4
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(5)test_function_2()
    -> print(bar)
    (Pdb) next
    default
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(6)test_function_2()
    -> for i in range(10):
    (Pdb) jump 8
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(8)test_function_2()
    -> print('after for')
    (Pdb) return
    after for
    ...
    --Return--
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(10)test_function_2()->'BAZ'
    -> return foo.upper()
    (Pdb) retval
    'BAZ'
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_basic_commands[3]>(4)test_function()
    -> test_function3(kwonly=True)
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_basic_commands[1]>(1)test_function3()
    -> def test_function3(arg=None, *, kwonly=None):
    (Pdb) args
    arg = None
    kwonly = True
    (Pdb) return
    --Return--
    > <doctest test.test_pdb.test_pdb_basic_commands[1]>(2)test_function3()->None
    -> pass
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_basic_commands[3]>(5)test_function()
    -> test_function4(1, 2, 3)
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_basic_commands[2]>(1)test_function4()
    -> def test_function4(a, b, c, /):
    (Pdb) args
    a = 1
    b = 2
    c = 3
    (Pdb) continue
    BAZ
    Nrrrrr
�test_pdb_basic_commandsDr r!c
Csd
dl}|j
��
dS)Nr
)�bdbZ
BreakpointZclearBreakpoints)
r"rrr
�reset_Breakpoint�s

r#c
Cr)a�Test basic commands related to breakpoints.

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

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

    >>> reset_Breakpoint()

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

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'break 3',
    ...     'disable 1',
    ...     'ignore 1 10',
    ...     'condition 1 1 < 2',
    ...     'break 4',
    ...     'break 4',
    ...     'break',
    ...     'clear 3',
    ...     'break',
    ...     'condition 1',
    ...     'enable 1',
    ...     'clear 1',
    ...     'commands 2',
    ...     'p "42"',
    ...     'print("42", 7*6)',     # Issue 18764 (not about breakpoints)
    ...     'end',
    ...     'continue',  # will stop at breakpoint 2 (line 4)
    ...     'clear',     # clear all!
    ...     'y',
    ...     'tbreak 5',
    ...     'continue',  # will stop at temporary breakpoint
    ...     'break',     # make sure breakpoint is gone
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(3)test_function()
    -> print(1)
    (Pdb) break 3
    Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) disable 1
    Disabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) ignore 1 10
    Will ignore next 10 crossings of breakpoint 1.
    (Pdb) condition 1 1 < 2
    New condition set for breakpoint 1.
    (Pdb) break 4
    Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break 4
    Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
            stop only if 1 < 2
            ignore next 10 hits
    2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    3   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) clear 3
    Deleted breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
            stop only if 1 < 2
            ignore next 10 hits
    2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) condition 1
    Breakpoint 1 is now unconditional.
    (Pdb) enable 1
    Enabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) clear 1
    Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) commands 2
    (com) p "42"
    (com) print("42", 7*6)
    (com) end
    (Pdb) continue
    1
    '42'
    42 42
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(4)test_function()
    -> print(2)
    (Pdb) clear
    Clear all breaks? y
    Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) tbreak 5
    Breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
    (Pdb) continue
    2
    Deleted breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(5)test_function()
    -> print(3)
    (Pdb) break
    (Pdb) continue
    3
    4
    Nrrrrr
�test_pdb_breakpoint_commands�r r$c
Cr)a;Breakpoints are remembered between interactive sessions

    >>> reset_Breakpoint()
    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...    'import test.test_pdb',
    ...    'break test.test_pdb.do_something',
    ...    'break test.test_pdb.do_nothing',
    ...    'break',
    ...    'continue',
    ... ]):
    ...    pdb.run('print()')
    > <string>(1)<module>()...
    (Pdb) import test.test_pdb
    (Pdb) break test.test_pdb.do_something
    Breakpoint 1 at ...test_pdb.py:...
    (Pdb) break test.test_pdb.do_nothing
    Breakpoint 2 at ...test_pdb.py:...
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep yes   at ...test_pdb.py:...
    2   breakpoint   keep yes   at ...test_pdb.py:...
    (Pdb) continue

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...    'break',
    ...    'break pdb.find_function',
    ...    'break',
    ...    'clear 1',
    ...    'continue',
    ... ]):
    ...    pdb.run('print()')
    > <string>(1)<module>()...
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep yes   at ...test_pdb.py:...
    2   breakpoint   keep yes   at ...test_pdb.py:...
    (Pdb) break pdb.find_function
    Breakpoint 3 at ...pdb.py:94
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep yes   at ...test_pdb.py:...
    2   breakpoint   keep yes   at ...test_pdb.py:...
    3   breakpoint   keep yes   at ...pdb.py:...
    (Pdb) clear 1
    Deleted breakpoint 1 at ...test_pdb.py:...
    (Pdb) continue

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...    'break',
    ...    'clear 2',
    ...    'clear 3',
    ...    'continue',
    ... ]):
    ...    pdb.run('print()')
    > <string>(1)<module>()...
    (Pdb) break
    Num Type         Disp Enb   Where
    2   breakpoint   keep yes   at ...test_pdb.py:...
    3   breakpoint   keep yes   at ...pdb.py:...
    (Pdb) clear 2
    Deleted breakpoint 2 at ...test_pdb.py:...
    (Pdb) clear 3
    Deleted breakpoint 3 at ...pdb.py:...
    (Pdb) continue
    Nrrrrr
�:test_pdb_breakpoints_preserved_across_interactive_sessionsG
r r%c
Cr)a�Test that do_p/do_pp do not swallow exceptions.

    >>> class BadRepr:
    ...     def __repr__(self):
    ...         raise Exception('repr_exc')
    >>> obj = BadRepr()

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

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'p obj',
    ...     'pp obj',
    ...     'continue',
    ... ]):
    ...    test_function()
    --Return--
    > <doctest test.test_pdb.test_pdb_pp_repr_exc[2]>(2)test_function()->None
    -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    (Pdb) p obj
    *** Exception: repr_exc
    (Pdb) pp obj
    *** Exception: repr_exc
    (Pdb) continue
    Nrrrrr
�test_pdb_pp_repr_exc�
r r&c
CsdSr	rrrrr
�
do_nothing�
s
r'cCstd
�

dS)N�*)
�printrrrr
�do_something�
�
r*c
Cr)a�Test the list and source commands of pdb.

    >>> def test_function_2(foo):
    ...     import test.test_pdb
    ...     test.test_pdb.do_nothing()
    ...     'some...'
    ...     'more...'
    ...     'code...'
    ...     'to...'
    ...     'make...'
    ...     'a...'
    ...     'long...'
    ...     'listing...'
    ...     'useful...'
    ...     '...'
    ...     '...'
    ...     return foo

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     ret = test_function_2('baz')

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...     'list',      # list first function
    ...     'step',      # step into second function
    ...     'list',      # list second function
    ...     'list',      # continue listing to EOF
    ...     'list 1,3',  # list specific lines
    ...     'list x',    # invalid argument
    ...     'next',      # step to import
    ...     'next',      # step over import
    ...     'step',      # step into do_nothing
    ...     'longlist',  # list all lines
    ...     'source do_something',  # list all lines of function
    ...     'source fooxxx',        # something that doesn't exit
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_list_commands[1]>(3)test_function()
    -> ret = test_function_2('baz')
    (Pdb) list
      1         def test_function():
      2             import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
      3  ->         ret = test_function_2('baz')
    [EOF]
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_list_commands[0]>(1)test_function_2()
    -> def test_function_2(foo):
    (Pdb) list
      1  ->     def test_function_2(foo):
      2             import test.test_pdb
      3             test.test_pdb.do_nothing()
      4             'some...'
      5             'more...'
      6             'code...'
      7             'to...'
      8             'make...'
      9             'a...'
     10             'long...'
     11             'listing...'
    (Pdb) list
     12             'useful...'
     13             '...'
     14             '...'
     15             return foo
    [EOF]
    (Pdb) list 1,3
      1  ->     def test_function_2(foo):
      2             import test.test_pdb
      3             test.test_pdb.do_nothing()
    (Pdb) list x
    *** ...
    (Pdb) next
    > <doctest test.test_pdb.test_list_commands[0]>(2)test_function_2()
    -> import test.test_pdb
    (Pdb) next
    > <doctest test.test_pdb.test_list_commands[0]>(3)test_function_2()
    -> test.test_pdb.do_nothing()
    (Pdb) step
    --Call--
    > ...test_pdb.py(...)do_nothing()
    -> def do_nothing():
    (Pdb) longlist
    ...  ->     def do_nothing():
    ...             pass
    (Pdb) source do_something
    ...         def do_something():
    ...             print(42)
    (Pdb) source fooxxx
    *** ...
    (Pdb) continue
    Nrrrrr
�test_list_commands�
r r,c
Cr)aITest the whatis command

    >>> myvar = (1,2)
    >>> def myfunc():
    ...     pass

    >>> class MyClass:
    ...    def mymethod(self):
    ...        pass

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

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...    'whatis myvar',
    ...    'whatis myfunc',
    ...    'whatis MyClass',
    ...    'whatis MyClass()',
    ...    'whatis MyClass.mymethod',
    ...    'whatis MyClass().mymethod',
    ...    'continue',
    ... ]):
    ...    test_function()
    --Return--
    > <doctest test.test_pdb.test_pdb_whatis_command[3]>(2)test_function()->None
    -> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    (Pdb) whatis myvar
    <class 'tuple'>
    (Pdb) whatis myfunc
    Function myfunc
    (Pdb) whatis MyClass
    Class test.test_pdb.MyClass
    (Pdb) whatis MyClass()
    <class 'test.test_pdb.MyClass'>
    (Pdb) whatis MyClass.mymethod
    Function mymethod
    (Pdb) whatis MyClass().mymethod
    Method mymethod
    (Pdb) continue
    Nrrrrr
�test_pdb_whatis_commandr r-c
Cr)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 a',
    ...     'n',
    ...     'display',
    ...     'undisplay a',
    ...     'n',
    ...     'display a',
    ...     'undisplay',
    ...     'display a < 1',
    ...     'n',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_display_command[0]>(4)test_function()
    -> a = 1
    (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) continue
    Nrrrrr
�test_pdb_display_command5r r.c
Cr)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 for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")',
    ...     'alias ps pi self',
    ...     'pi o',
    ...     's',
    ...     'ps',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_alias_command[1]>(4)test_function()
    -> o.method()
    (Pdb) alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")
    (Pdb) alias 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rrr
�test_pdb_alias_commandgr r/c
Cr)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rrr
�test_pdb_where_command�r r0c
Cr)a�Test post mortem traceback debugging.

    >>> def test_function_2():
    ...     try:
    ...         1/0
    ...     finally:
    ...         print('Exception!')

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     test_function_2()
    ...     print('Not reached.')

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...     'next',      # step over exception-raising call
    ...     'bt',        # get a backtrace
    ...     'list',      # list code of test_function()
    ...     'down',      # step into test_function_2()
    ...     'list',      # list code of test_function_2()
    ...     'continue',
    ... ]):
    ...    try:
    ...        test_function()
    ...    except ZeroDivisionError:
    ...        print('Correctly reraised.')
    > <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
    -> test_function_2()
    (Pdb) next
    Exception!
    ZeroDivisionError: division by zero
    > <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
    -> test_function_2()
    (Pdb) bt
    ...
      <doctest test.test_pdb.test_post_mortem[2]>(10)<module>()
    -> test_function()
    > <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
    -> test_function_2()
      <doctest test.test_pdb.test_post_mortem[0]>(3)test_function_2()
    -> 1/0
    (Pdb) list
      1         def test_function():
      2             import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
      3  ->         test_function_2()
      4             print('Not reached.')
    [EOF]
    (Pdb) down
    > <doctest test.test_pdb.test_post_mortem[0]>(3)test_function_2()
    -> 1/0
    (Pdb) list
      1         def test_function_2():
      2             try:
      3  >>             1/0
      4             finally:
      5  ->             print('Exception!')
    [EOF]
    (Pdb) continue
    Correctly reraised.
    Nrrrrr
�test_post_mortem�r r1c
Cr)a[This illustrates the simple case of module skipping.

    >>> def skip_module():
    ...     import string
    ...     import pdb; pdb.Pdb(skip=['stri*'], nosigint=True, readrc=False).set_trace()
    ...     string.capwords('FOO')

    >>> with PdbTestInput([
    ...     'step',
    ...     'continue',
    ... ]):
    ...     skip_module()
    > <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()
    -> string.capwords('FOO')
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()->None
    -> string.capwords('FOO')
    (Pdb) continue
    Nrrrrr
�test_pdb_skip_modules	r r2Zmodule_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonec
Cr)aAThis illustrates skipping of modules that call into other code.

    >>> def skip_module():
    ...     def callback():
    ...         return None
    ...     import pdb; pdb.Pdb(skip=['module_to_skip*'], nosigint=True, readrc=False).set_trace()
    ...     mod.foo_pony(callback)

    >>> with PdbTestInput([
    ...     'step',
    ...     'step',
    ...     'step',
    ...     'step',
    ...     'step',
    ...     'continue',
    ... ]):
    ...     skip_module()
    ...     pass  # provides something to "step" to
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(5)skip_module()
    -> mod.foo_pony(callback)
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(2)callback()
    -> def callback():
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(3)callback()
    -> return None
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(3)callback()->None
    -> return None
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(5)skip_module()->None
    -> mod.foo_pony(callback)
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[1]>(10)<module>()
    -> pass  # provides something to "step" to
    (Pdb) continue
    Nrrrrr
�#test_pdb_skip_modules_with_callback%r r3c
Cr)a�Test that "continue" and "next" work properly in bottom frame (issue #5294).

    >>> def test_function():
    ...     import pdb, sys; inst = pdb.Pdb(nosigint=True, readrc=False)
    ...     inst.set_trace()
    ...     inst.botframe = sys._getframe()  # hackery to get the right botframe
    ...     print(1)
    ...     print(2)
    ...     print(3)
    ...     print(4)

    >>> with PdbTestInput([  # doctest: +ELLIPSIS
    ...     'next',
    ...     'break 7',
    ...     'continue',
    ...     'next',
    ...     'continue',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(4)test_function()
    -> inst.botframe = sys._getframe()  # hackery to get the right botframe
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(5)test_function()
    -> print(1)
    (Pdb) break 7
    Breakpoint ... at <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>:7
    (Pdb) continue
    1
    2
    > <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(7)test_function()
    -> print(3)
    (Pdb) next
    3
    > <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(8)test_function()
    -> print(4)
    (Pdb) continue
    4
    Nrrrrr
� test_pdb_continue_in_bottomframePr r4cCstt
jd
dd�|�|
�

dS)zRun pdb.method(arg).TF)ZnosigintZreadrcN)�getattr�pdb�Pdb)�method�argrrr
�
pdb_invokezsr:c
Cr)a�
Testing run and runeval with incorrect first argument.

    >>> pti = PdbTestInput(['continue',])
    >>> with pti:
    ...     pdb_invoke('run', lambda x: x)
    Traceback (most recent call last):
    TypeError: exec() arg 1 must be a string, bytes or code object

    >>> with pti:
    ...     pdb_invoke('runeval', lambda x: x)
    Traceback (most recent call last):
    TypeError: eval() arg 1 must be a string, bytes or code object
    Nrrrrr
�$test_pdb_run_with_incorrect_argumentr r;c
Cr)a Testing run and runeval with code object as a first argument.

    >>> with PdbTestInput(['step','x', 'continue']):  # doctest: +ELLIPSIS
    ...     pdb_invoke('run', compile('x=1', '<string>', 'exec'))
    > <string>(1)<module>()...
    (Pdb) step
    --Return--
    > <string>(1)<module>()->None
    (Pdb) x
    1
    (Pdb) continue

    >>> with PdbTestInput(['x', 'continue']):
    ...     x=0
    ...     pdb_invoke('runeval', compile('x+1', '<string>', 'eval'))
    > <string>(1)<module>()->None
    (Pdb) x
    1
    (Pdb) continue
    Nrrrrr
�test_pdb_run_with_code_object�r r<c
Cr)a�Test that pdb stops after a next/until/return issued at a return debug event.

    >>> def test_function_2():
    ...     x = 1
    ...     x = 2

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

    >>> reset_Breakpoint()
    >>> with PdbTestInput(['break test_function_2',
    ...                    'continue',
    ...                    'return',
    ...                    'next',
    ...                    'continue',
    ...                    'return',
    ...                    'until',
    ...                    'continue',
    ...                    'return',
    ...                    'return',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(3)test_function()
    -> test_function_2()
    (Pdb) break test_function_2
    Breakpoint 1 at <doctest test.test_pdb.test_next_until_return_at_return_event[0]>:1
    (Pdb) continue
    > <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
    -> x = 1
    (Pdb) return
    --Return--
    > <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
    -> x = 2
    (Pdb) next
    > <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(4)test_function()
    -> test_function_2()
    (Pdb) continue
    > <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
    -> x = 1
    (Pdb) return
    --Return--
    > <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
    -> x = 2
    (Pdb) until
    > <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(5)test_function()
    -> test_function_2()
    (Pdb) continue
    > <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
    -> x = 1
    (Pdb) return
    --Return--
    > <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
    -> x = 2
    (Pdb) return
    > <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(6)test_function()
    -> end = 1
    (Pdb) continue
    Nrrrrr
�&test_next_until_return_at_return_event�r r=c
Cr)aXTesting skip unwindng stack on yield for generators for "next" command

    >>> def test_gen():
    ...     yield 0
    ...     return 1
    ...     yield 2

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     it = test_gen()
    ...     try:
    ...         if next(it) != 0:
    ...             raise AssertionError
    ...         next(it)
    ...     except StopIteration as ex:
    ...         if ex.value != 1:
    ...             raise AssertionError
    ...     print("finished")

    >>> with PdbTestInput(['step',
    ...                    'step',
    ...                    'step',
    ...                    'next',
    ...                    'next',
    ...                    'step',
    ...                    'step',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(3)test_function()
    -> it = test_gen()
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(4)test_function()
    -> try:
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(5)test_function()
    -> if next(it) != 0:
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(1)test_gen()
    -> def test_gen():
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(2)test_gen()
    -> yield 0
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(3)test_gen()
    -> return 1
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(3)test_gen()->1
    -> return 1
    (Pdb) step
    StopIteration: 1
    > <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(7)test_function()
    -> next(it)
    (Pdb) continue
    finished
    Nrrrrr
�#test_pdb_next_command_for_generator�r r>c
Cr)a,Testing skip unwindng stack on yield for coroutines for "next" command

    >>> import asyncio

    >>> async def test_coro():
    ...     await asyncio.sleep(0)
    ...     await asyncio.sleep(0)
    ...     await asyncio.sleep(0)

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

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

    >>> with PdbTestInput(['step',
    ...                    'step',
    ...                    'next',
    ...                    'next',
    ...                    'next',
    ...                    'step',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()
    -> await test_coro()
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(1)test_coro()
    -> async def test_coro():
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(2)test_coro()
    -> await asyncio.sleep(0)
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(3)test_coro()
    -> await asyncio.sleep(0)
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(4)test_coro()
    -> await asyncio.sleep(0)
    (Pdb) next
    Internal StopIteration
    > <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()
    -> await test_coro()
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()->None
    -> await test_coro()
    (Pdb) continue
    finished
    Nrrrrr
�#test_pdb_next_command_for_coroutine r r?c
Cr)a*Testing skip unwindng stack on yield for coroutines for "next" command

    >>> import asyncio

    >>> async def agen():
    ...     yield 1
    ...     await asyncio.sleep(0)
    ...     yield 2

    >>> async def test_coro():
    ...     async for x in agen():
    ...         print(x)

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

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

    >>> with PdbTestInput(['step',
    ...                    'step',
    ...                    'next',
    ...                    'next',
    ...                    'step',
    ...                    'next',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[3]>(3)test_main()
    -> await test_coro()
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(1)test_coro()
    -> async def test_coro():
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(2)test_coro()
    -> async for x in agen():
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(3)test_coro()
    -> print(x)
    (Pdb) next
    1
    > <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(2)test_coro()
    -> async for x in agen():
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[1]>(2)agen()
    -> yield 1
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[1]>(3)agen()
    -> await asyncio.sleep(0)
    (Pdb) continue
    2
    finished
    Nrrrrr
�"test_pdb_next_command_for_asyncgenXr r@c
Cr)a�Testing no unwindng stack on yield for generators
       for "return" command

    >>> def test_gen():
    ...     yield 0
    ...     return 1
    ...     yield 2

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     it = test_gen()
    ...     try:
    ...         if next(it) != 0:
    ...             raise AssertionError
    ...         next(it)
    ...     except StopIteration as ex:
    ...         if ex.value != 1:
    ...             raise AssertionError
    ...     print("finished")

    >>> with PdbTestInput(['step',
    ...                    'step',
    ...                    'step',
    ...                    'return',
    ...                    'step',
    ...                    'step',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(3)test_function()
    -> it = test_gen()
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(4)test_function()
    -> try:
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(5)test_function()
    -> if next(it) != 0:
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_return_command_for_generator[0]>(1)test_gen()
    -> def test_gen():
    (Pdb) return
    StopIteration: 1
    > <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(7)test_function()
    -> next(it)
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(8)test_function()
    -> except StopIteration as ex:
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(9)test_function()
    -> if ex.value != 1:
    (Pdb) continue
    finished
    Nrrrrr
�%test_pdb_return_command_for_generator�r rAc
Cr)a%Testing no unwindng stack on yield for coroutines for "return" command

    >>> import asyncio

    >>> async def test_coro():
    ...     await asyncio.sleep(0)
    ...     await asyncio.sleep(0)
    ...     await asyncio.sleep(0)

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

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

    >>> with PdbTestInput(['step',
    ...                    'step',
    ...                    'next',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_return_command_for_coroutine[2]>(3)test_main()
    -> await test_coro()
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(1)test_coro()
    -> async def test_coro():
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(2)test_coro()
    -> await asyncio.sleep(0)
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(3)test_coro()
    -> await asyncio.sleep(0)
    (Pdb) continue
    finished
    Nrrrrr
�%test_pdb_return_command_for_coroutine�r rBc
Cr)a�Testing no unwindng stack on yield for generators
       for "until" command if target breakpoint is not reached

    >>> def test_gen():
    ...     yield 0
    ...     yield 1
    ...     yield 2

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     for i in test_gen():
    ...         print(i)
    ...     print("finished")

    >>> with PdbTestInput(['step',
    ...                    'until 4',
    ...                    'step',
    ...                    'step',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_until_command_for_generator[1]>(3)test_function()
    -> for i in test_gen():
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(1)test_gen()
    -> def test_gen():
    (Pdb) until 4
    0
    1
    > <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(4)test_gen()
    -> yield 2
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(4)test_gen()->2
    -> yield 2
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_until_command_for_generator[1]>(4)test_function()
    -> print(i)
    (Pdb) continue
    2
    finished
    Nrrrrr
�$test_pdb_until_command_for_generator�r rCc
Cr)aTesting no unwindng stack for coroutines
       for "until" command if target breakpoint is not reached

    >>> import asyncio

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

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

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

    >>> with PdbTestInput(['step',
    ...                    'until 8',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_until_command_for_coroutine[2]>(3)test_main()
    -> await test_coro()
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_until_command_for_coroutine[1]>(1)test_coro()
    -> async def test_coro():
    (Pdb) until 8
    0
    1
    2
    > <doctest test.test_pdb.test_pdb_until_command_for_coroutine[1]>(8)test_coro()
    -> print(3)
    (Pdb) continue
    3
    finished
    Nrrrrr
�$test_pdb_until_command_for_coroutine"r rDc
Cr)a�The next command on returning from a generator controlled by a for loop.

    >>> def test_gen():
    ...     yield 0
    ...     return 1

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     for i in test_gen():
    ...         print('value', i)
    ...     x = 123

    >>> reset_Breakpoint()
    >>> with PdbTestInput(['break test_gen',
    ...                    'continue',
    ...                    'next',
    ...                    'next',
    ...                    'next',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[1]>(3)test_function()
    -> for i in test_gen():
    (Pdb) break test_gen
    Breakpoint 1 at <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>:1
    (Pdb) continue
    > <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>(2)test_gen()
    -> yield 0
    (Pdb) next
    value 0
    > <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>(3)test_gen()
    -> return 1
    (Pdb) next
    Internal StopIteration: 1
    > <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[1]>(3)test_function()
    -> for i in test_gen():
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[1]>(5)test_function()
    -> x = 123
    (Pdb) continue
    Nrrrrr
�+test_pdb_next_command_in_generator_for_loopQr rEc
Cr)a�The next command in a generator with a subiterator.

    >>> def test_subgenerator():
    ...     yield 0
    ...     return 1

    >>> def test_gen():
    ...     x = yield from test_subgenerator()
    ...     return x

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
    ...     for i in test_gen():
    ...         print('value', i)
    ...     x = 123

    >>> with PdbTestInput(['step',
    ...                    'step',
    ...                    'next',
    ...                    'next',
    ...                    'next',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(3)test_function()
    -> for i in test_gen():
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(1)test_gen()
    -> def test_gen():
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(2)test_gen()
    -> x = yield from test_subgenerator()
    (Pdb) next
    value 0
    > <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(3)test_gen()
    -> return x
    (Pdb) next
    Internal StopIteration: 1
    > <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(3)test_function()
    -> for i in test_gen():
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(5)test_function()
    -> x = 123
    (Pdb) continue
    Nrrrrr
�!test_pdb_next_command_subiterator{r rFc
Cr)a\Test for reference leaks when the SIGINT handler is set.

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

    >>> reset_Breakpoint()
    >>> with PdbTestInput(['continue',
    ...                    'continue']):
    ...     test_function()
    > <doctest test.test_pdb.test_pdb_issue_20766[0]>(6)test_function()
    -> print('pdb %d: %s' % (i, sess._previous_sigint_handler))
    (Pdb) continue
    pdb 1: <built-in function default_int_handler>
    > <doctest test.test_pdb.test_pdb_issue_20766[0]>(6)test_function()
    -> print('pdb %d: %s' % (i, sess._previous_sigint_handler))
    (Pdb) continue
    pdb 2: <built-in function default_int_handler>
    Nrrrrr
�test_pdb_issue_20766�r rGc
Cr)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rrr
�test_pdb_issue_43318�r rHc
Cr)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rrr
�test_pdb_issue_gh_101673�r rIc@s"
eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�Z d=d>�Z!e"j#d?d@��
Z$dAdB�Z%dCdD�Z&dES)F�PdbTestCasec

C�t�
tj�

dSr	�r�unlink�TESTFNrrrr
�tearDown��
zPdbTestCase.tearDowncCs�|�t
jd
�
tjddg|
}tj|tjtjtjit	j
�
ddi
�
d��}|�t�
|�
�
\}}Wd�
n1s8w



Y
|oCt�|�
}|oJt�|�
}||fS)N�__pycache__�-mr6�PYTHONIOENCODING�utf-8��stdoutr�stderr�env)�
addCleanupr�rmtreer�
executable�
subprocess�Popen�PIPE�STDOUT�os�environ�communicate�str�encode�bytes�decode)rZpdb_args�commands�cmd�procrVrWrrr
�_run_pdbs







�
�

zPdbTestCase._run_pdbcCsZd
}t|d��}|�
t�|
�
�

Wd�
n1sw



Y
|�tj|�
|�|g
|�S)z3Run 'script' lines with pdb and the pdb 'commands'.�main.py�
wN)�open�write�textwrap�dedentrYrrMrj)r�scriptrg�filename�
frrr
�run_pdb_scripts

�
zPdbTestCase.run_pdb_scriptcCs�d
|_t
�|j�

|jd}|jd}t�|j�

t|d��}Wd�
n1s)w



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

Wd�
n1sFw



Y
|�	t
j|j�
|�
d|jg|�S)z(Runs the script code as part of a module�t_main�/__main__.py�/__init__.pyrlNrR)�module_namerrZr`�mkdirrmrnrorprYrj)rrqrg�	main_file�	init_filersrrr
�run_pdb_modules







�
�
zPdbTestCase.run_pdb_modulecCsltt
jd
��
}|�|
�

Wd�
n1sw



Y
|sdn	|dt
j|df}|�|t�|t
j��
dS)N�wbr
�
)rmrrNrn�assertEqualr6Z
find_function)rZfile_content�	func_name�expectedrsrrr
�_assert_find_function's

�
�
�z!PdbTestCase._assert_find_functionc

Cs|�d
dd�
dS)N�Zfoo)
r�rrrr
�test_find_function_empty_file0s
z)PdbTestCase.test_find_function_empty_filec

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

def bœr():
    pass

def quux():
    pass
�bœr)r���r�rdrrrr
�test_find_function_found3s

	

�z$PdbTestCase.test_find_function_foundc

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

def bœr():
    pass

def quux():
    pass
ziso-8859-15r�)r��r�rrrr
�-test_find_function_found_with_encoding_cookieCs




�z9PdbTestCase.test_find_function_found_with_encoding_cookiec

Cs|�t
jd
��dd�
dS)Nudef bœr():
    pass
r�)r�r~)r��codecs�BOM_UTF8rdrrrr
�!test_find_function_found_with_bomTs

�
�z-PdbTestCase.test_find_function_found_with_bomc
Cs�tt
jd
��
}
|
�d�

Wd�
n1sw



Y
tjddt
jg}tj|tjtjtj	d�}|�
|jj�

|�
d�
\}}|�d|d�
dS)	Nr}sprint("testing my pdb")
rRr6�rVrrWsquit
sSyntaxErrorz0Got a syntax error running test script under PDB)rmrrNrnrr[r\r]r^r_rYrV�closerb�assertNotIn�rrsrhrirVrWrrr
�test_issue7964^s
�



�


�zPdbTestCase.test_issue7964c
CsHd
}
d}|�|
|�\}}|pd|pd}|�
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)rtr��assertIn)rrqrgrVrW�outputrrr
�test_issue46434ms


�
�zPdbTestCase.test_issue46434c
Cs�d
}
d}d}tdd��}|�
t�|�
�

Wd�
n1sw



Y
|�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.pyrlc
s��|]}
d|
vV
qd
S)zmain.py(5)foo()->NoneNr��.0�
lrrr
�	<genexpr>���z.PdbTestCase.test_issue13183.<locals>.<genexpr>z+Fail to step into the caller after a return)rmrnrorprYrrMrt�
assertTrue�any�
splitlines)rrqrgZbarrsrVrWrrr
�test_issue13183�s

�



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

Wd�
n1sw



Y
tjdt
jg}t	j
|t	jt	jt	jit
j�
ddi
�
d�}|�|jj�

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

                import threading
                import pdb

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

                t = threading.Thread(target=start_pdb)
                t.start()�ascii�-urSrTrUscont
�Error�*Got an error running test script under PDB�rmrrNrnrorprdrr[r\r]r^r_r`rarYrVr�rbr�r�rrr
�test_issue13120�s"

��




�


�zPdbTestCase.test_issue13120c
Cr�)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�rSrTrUs
cont
cont
r�r�r�r�rrr
�test_issue36250�s"
��




�


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

Expected:
{}
Got:
{}
Fail to handle a syntax error in the debuggee.)rtr��format)rrqrgr�rVrWrrr
�test_issue16180�s




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

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



zPdbTestCase.test_issue26053c
	Cs:
t�
d
�
}
tj�dd�}z�t���l
tdd��
}|�d�

Wd�
n1s'w



Y
tdd��
}|�|
�

Wd�
n1sAw



Y
t	j
dg}tj|tj
tj
tj
d�}|�
|�d�
\}}|�d	|�
Wd�
n1sqw



Y
Wd�
n1s�w



Y
W|du
r�|tjd<dSdS|du
r�|tjd<w)
Nz_
            import pdb; pdb.Pdb(readrc=False).set_trace()

            print('hello')
        �HOME�.pdbrcrlzinvalid
rkr�sq
s(NameError: name 'invalid' is not defined)rorpr`ra�popr�temp_cwdrmrnrr[r\r]r^rbr�)rrq�	save_homersrhrirVrWrrr
�test_readrc_kwarg�s<






�
�





�


�����
�
zPdbTestCase.test_readrc_kwargc
Cs
tj
�d
d�}
t���l}td�
�O
tj�|d�}|tjj_	z0t
|d��
}|�d�

Wd�
n1s3w



Y
|�t
��jdd�
W|
du
rM|
tj
d
<n
|
du
rW|
tj
d
<wWd�
n1sbw



Y
Wd�
dSWd�
dS1szw



Y
dS)Nr�zos.path.expanduserr�rl�invalidr
)r`rar�r�temp_dirr�pathr��
expanduserZreturn_valuermrnrr6r7ZrcLines)rr�r�Zrc_pathrsrrr
�test_readrc_homedirs 







�

��
�P�zPdbTestCase.test_readrc_homedirc
Csxt�}
d
}t
�� }|�td|
��

|�t�tjd��

tj|d�

Wd�
n1s+w



Y
|�|
�	�|d�
dS)Nz"Nobody expects... blah, blah, blahz
sys.stdout�	set_trace)
�headerr�)
rr�
enter_contextr�objectr6r7r�r�getvalue)rrVr�Z	resourcesrrr
�test_header&s





�zPdbTestCase.test_headerc
C�:d
}
d}|�|
|�\}}|�
tdd�|��D�
�
|�
dS)Nzprint("SUCCESS")�/
            continue
            quit
        c
sr���SUCCESSNrr�rrr
r�6r�z.PdbTestCase.test_run_module.<locals>.<genexpr>�r|r�r�r��rrqrgrVrWrrr
�test_run_module/s

"
zPdbTestCase.test_run_modulec
Cr�)NzQ
            if __name__ == '__main__':
                print("SUCCESS")
        r�c
sr�r�rr�rrr
r�Br�z9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>r�r�rrr
�test_module_is_run_as_main8s
"
z&PdbTestCase.test_module_is_run_as_mainc
CsXd
}
d}|�|
|�\}}|�
tdd�|��D�
�
|�
|�
tdd�|��D�
�
|�
dS)Nz{
            if __name__ == '__main__':
                pass
                print("SUCCESS")
                pass
        z*
            b 3
            quit
        c
sr�)zBreakpoint 1 atNrr�rrr
r�Pr�z.PdbTestCase.test_breakpoint.<locals>.<genexpr>c
ss�|]}
d|
v
V
qd
Sr�rr�rrr
r�Qr�)r|r�r�r��allr�rrr
�test_breakpointDs


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

r�)rjr�r6Z_usage�replace)rrgrVrWrrr
�test_run_pdb_with_pdbSs




�z!PdbTestCase.test_run_pdb_with_pdbc
Cs�d
}
t�
|
�

|
d}t�|
�

t|d��
Wd�
n1s w



Y
|�tj
|
�
|�d|
gd�\}}|�d|���
dS)NrurwrlrRr�z,ImportError: No module named t_main.__main__)	rrZr`ryrmrYrjr�r�)rrxr{rVrWrrr
�test_module_without_a_main^s







�


�z&PdbTestCase.test_module_without_a_mainc
Cs�d
}
d}t�
|
�

|
d|}t�|�

t|dd��
Wd�
n1s&w



Y
|�tj
|
�
|�d|�dd�gd�\}}|�d	|�
dS)
NZt_pkgru�
/rwrlrR�
.r�z;'t_pkg.t_main' is a package and cannot be directly executed)	rrZr`�makedirsrmrYrjr�r�)rZpkg_namerx�modpathrVrWrrr
�test_package_without_a_mainjs








�



�z'PdbTestCase.test_package_without_a_mainc
Cr�)NzY
                #This is a comment, on line 2

                print("SUCCESS")
        z
            quit
        c
sr�)z__main__.py(4)<module>()Nrr�rrr
r��s�
�
�z=PdbTestCase.test_blocks_at_first_code_line.<locals>.<genexpr>r�r�rrr
�test_blocks_at_first_code_linexs


�
�z*PdbTestCase.test_blocks_at_first_code_linec
Csn
d
|_t
�|j�

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

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

Wd�
n1s>w



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

Wd�
n1s[w



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

Wd�
n1sxw



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

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

dS)Nrurvrw�
/module.pyrl�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
        rRc
sr��zVAR from moduleNrr�rrr
r��r�z4PdbTestCase.test_relative_imports.<locals>.<genexpr>c
sr�)zVAR from topNrr�rrr
r��r�c
sr�)z
second varNrr�rrr
r��r��rxrrZrYr`ryrmrnrorprjr�r�r��rrzr{Zmodule_filersrgrV�
_rrr
�test_relative_imports�s*











�
�
�

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

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

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

Wd�
n1s>w



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

Wd�
n1s[w



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

Wd�
n1sxw



Y
d	}|�
d
|jdg|�\}}|�tdd
�|�
�D�
�
|�
dS)Nruz	/runme.pyrwr�rlr�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
        rRz.runmec
sr�r�rr�rrr
r��r�zDPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr>r�r�rrr
�%test_relative_imports_on_plain_module�s&










�
�
�"
z1PdbTestCase.test_relative_imports_on_plain_modulec
CsBd
�gd�
�
}
|�
d|
d
�\}}|�|��dd�gd�
�
dS)Nr�)zprint(zdebug print(zdebug doesnotexist�
c�passr~)
�-> passz+(Pdb) *** SyntaxError: '(' was never closed�!(Pdb) ENTERING RECURSIVE DEBUGGERz%*** SyntaxError: '(' was never closed�LEAVING RECURSIVE DEBUGGERr�z> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedr��(Pdb) �r�rtrr�)rrgrVr�rrr
�test_errors_in_command�s
 z"PdbTestCase.test_errors_in_commandc
s$�f
d
d�}
|
dd�
|
dd�
dS)z.do_run handles exceptions from parsing its argcsVd
�d|��dg�
}��
d|d
�\}}��|��dd�dd|�d|
��d	g�
dS)
Nr�zrun �
qr�r~r�z(Pdb) *** Cannot run z: r�r�)Zbad_arg�msgrgrVr�rrr
�check�s


�




�z*PdbTestCase.test_issue34266.<locals>.check�
\zNo escaped character�
"zNo closing quotationNr)rr�rrr
�test_issue34266�s

zPdbTestCase.test_issue34266c
Cszt�
d
�
}
d}t���(}dtj�|�
��}|�|
|�\}}|�|�	d�
d�
d�
|�
Wd�
dS1s6w



Y
dS)zkWhen running `python foo.py` sys.path[0] is an absolute path. `python -m pdb foo.py` should behave the same�Q
            import sys
            print('sys.path[0] is', sys.path[0])
        �c
q�(Pdb) sys.path[0] is r��r�N)rorprr�r`r��realpathrtr�split�rstrip)rrqrg�cwdr�rVrWrrr
�test_issue42384�s


"�zPdbTestCase.test_issue42384c

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

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

Wd�
n1sDw



Y
t�|�

t�tj�|d�tj�|d��
|�tj�dd�g
|�\}}	|�
|�d	�
d
�d�
|�
Wd�
dS1s�w



Y
dS)ziWhen running `python foo.py` sys.path[0] resolves symlinks. `python -m pdb foo.py` should behave the samer�r��dir_one�dir_twor��foo.pyrlNr�r�r�)rorprr�r`r�r�r�ryrmrn�symlinkrjrr�r�)
rrqrgr�r�r�r�rsrVrWrrr
�test_issue42384_symlinks 








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

Wd�
n1sw



Y
tj�|
d�}t�	|�

t�	tj�|d��

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

Wd�
n1sVw



Y
|�
d
g
d�\}}d}|�|�d�
d	�
d
�
|�
Wd�
dS1sw



Y
dS)Nr�rlz�
                    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�rmrorprnr`r�r�ryrjrr�r�)	rr�rs�
sr�Z
wrong_filerVrWr�rrr
�test_issue42383s 




�	




�

"�zPdbTestCase.test_issue42383c
Cs�d
}
d}d}tdd��}|�
t�|
�
�

Wd�
n1sw



Y
tdd��}|�
t�|�
�

Wd�
n1s;w



Y
|�tjd�
|�tjd�
|�dg
|�\}}|�d|d�
dS)	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.pyrlzgh93696_host.pyz"x = "Sentinel string for gh-93696"zSentinel statement not found)	rmrnrorprYrrMrjr�)rZ
frozen_srcZhost_programrgrsrVrWrrr
�test_gh_93696_frozen_list1s

�
�

z%PdbTestCase.test_gh_93696_frozen_listN)'rrrrOrjrtr|r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rZskip_unless_symlinkr�r�r
rrrr
rJ�sH
	
$ 
		
%

rJc@s4eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�ZdS)�ChecklineTestsc

Cst�
�
dSr	)�	linecache�
clearcacherrrr
�setUp`r+zChecklineTests.setUpc

CrKr	rLrrrr
rOcrPzChecklineTests.tearDownc
CsXtt
jd
��
}
|
�d�

Wd�
n1sw



Y
t��}|�|�t
jd�d�
dS�Nrlz
print(123)r~)rmrrNrnr6r7r�	checkline�rrs�dbrrr
�test_checkline_before_debuggingfs


�
z.ChecklineTests.test_checkline_before_debuggingc
Cs`tt
jd
��
}
|
�d�

Wd�
n1sw



Y
t��}|��
|�|�t
jd�d�
dSr
)	rmrrNrnr6r7�resetrr
r
rrr
�test_checkline_after_resetls

�

z)ChecklineTests.test_checkline_after_resetc
Cs�t�
d
�
}
ttjd��
}|�|
�

Wd�
n1sw



Y
t|
���
d}tt	��
�
t
��}t|�
D]}|�
|�tj|��

q6Wd�
dS1sNw



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

        rlr�)rorprmrrNrn�lenr�rrr6r7�rangeZassertFalser
)rr�rsZ	num_linesr
�linenorrr
� test_checkline_is_not_executabless

�



�"�z/ChecklineTests.test_checkline_is_not_executableN)rrrr
rOr	
r
r
rrrr
r

_s
r

cGs2d
dlm
}

t�t�
t�t�
t�|
�
g}t�|�
S)Nr
)
�test_pdb)	�testr
�unittestZ	makeSuiterJr

�doctestZDocTestSuiteZ	TestSuite)�argsr
Zsuitesrrr
�
load_tests�s


�
r
�__main__)Br
r`r6r�typesr�r
r\ror
�
contextlibrr�iorZtest.supportrZtest.test_doctestrZ
unittest.mockrr�rrr!r#r$r%r&r'r*r,r-r.r/r0r1r2�
ModuleType�mod�exec�__dict__r3r4r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIZTestCaserJr

r
r�mainrrrr
�<module>
s|











jC_*2);>

+*@;8=7*,/*/e%

�