+
    Biy                       ^ RI t ^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RI	t	^ RI
t
^ RIt^ RIt^ RIt^ RIt^ RIHt ^ RIHtHt ^ RIHt ^ RIHt ^ RIHtHt ^ RIHt ^ RIHtHt ^ R	IH t  ^ R
I!H"t" Rt# ! R R]$4      t%R t&R t'R t(R t)R t*R t+R t,R t-R t.R t/R t0R t1R t2R t3R t4R t5R t6R t7R  t8R! t9R" t:]Pv                  Px                  '       g   R# t=R$ t>R% t?R& t@R' tAR( tBR) tCR* tDR+ tER, tFR- tGR. tHR/ tI]P                  ! R04      tK]L! R1]KP                  4       R2 tNR3 tOR4 tPR5 tQR6 tRR7 tSR8 tT]#'       g   ]'       d   R9 tUR: tVR; tWR< tXR= tYR> tZR? t[]#'       g   R@ t\RA t]]#'       g   RB t^RC t_RD t`RE taRF tbRG tcRH td]P                  tfRI tgRJ thRK tiRL tjRM tkRN tlRO tmRP tnRQ toRR tpRS tqRT trRU tsRV ttRW tuRX tv]P                  ]P                  ! 4        ! RY RZ]	P                  4      4       4       tz ! R[ R\]	P                  4      t{]P                  ! 4        ! R] R^]	P                  4      4       t|]P                   ! R_ R`]	P                  4      4       t~]P                  ]P                  ! 4        ! Ra Rb]	P                  4      4       4       t]P                  ]P                  ! 4        ! Rc Rd]	P                  4      4       4       tRe t]Rf8X  d   ]	EP                  ! 4        R# R# )g    N)_set_event_loop_policy)	ExitStackredirect_stdout)StringIO)support)has_socket_support	os_helper)import_module)run_pty	FakeInput)kill_python)patchFc                   6   a  ] tR t^ t o RtR tR tR tRtV t	R# )PdbTestInputz:Context manager that makes testing Pdb in doctests easier.c                    Wn         R # N)input)selfr   s   &&$/usr/lib/python3.14/test/test_pdb.py__init__PdbTestInput.__init__#   s    
    c                    \         P                  V n        \        V P                  4      \         n        \        \         R 4      '       d   \         P                  ! 4       V n        R# RV n        R# )gettraceN)sysstdin
real_stdinr   r   hasattrr   
orig_tracer   s   &r   	__enter__PdbTestInput.__enter__&   s<    ))djj)	,3C,D,D#,,.$r   c                    V P                   \        n        V P                  '       d#   \        P                  ! V P                  4       R # R # r   )r   r   r   r   settrace)r   excs   &*r   __exit__PdbTestInput.__exit__+   s+    OO	???LL) r   )r   r   r   N)
__name__
__module____qualname____firstlineno____doc__r   r!   r&   __static_attributes____classdictcell____classdict__s   @r   r   r       s     DO
* *r   r   c                     R# )a   This tests the custom displayhook for pdb.

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

>>> with PdbTestInput([
...     'foo',
...     'bar',
...     'for i in range(5): print(i)',
...     'continue',
... ]):
...     test_function(1, None)
> <doctest test.test_pdb.test_pdb_displayhook[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) foo
1
(Pdb) bar
(Pdb) for i in range(5): print(i)
0
1
2
3
4
(Pdb) continue
N r2   r   r   test_pdb_displayhookr3   1       r   c                     R# )aB  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',       # go to line ret = test_function_2('baz')
...     '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]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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]>(26)<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
Nr2   r2   r   r   test_pdb_basic_commandsr6   M   r4   r   c                     R# )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)

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'break 3',
...     'break 4, +',
...     'disable 1',
...     'ignore 1 10',
...     'condition 1 1 < 2',
...     'condition 1 1 <',
...     'break 4',
...     'break 4',
...     'break',
...     'clear 3',
...     'break',
...     'condition 1',
...     'commands 1',
...     'EOF',       # Simulate Ctrl-D/Ctrl-Z from user, should end input
...     'enable 1',
...     'clear 1',
...     'commands 2',
...     'p "42"',
...     'print("42", 7*6)',     # Issue 18764 (not about breakpoints)
...     'end',
...     'continue',  # will stop at breakpoint 2 (line 4)
...     'clear',     # clear all!
...     'y',
...     'tbreak 5',
...     'continue',  # will stop at temporary breakpoint
...     'break',     # make sure breakpoint is gone
...     'commands 10',  # out of range
...     'commands a',   # display help
...     'commands 4',   # already deleted
...     'break 6, undefined', # condition causing `NameError` during evaluation
...     'continue', # will stop, ignoring runtime error
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break 3
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
(Pdb) break 4, +
*** Invalid condition +: SyntaxError: invalid syntax
(Pdb) disable 1
Disabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
(Pdb) ignore 1 10
Will ignore next 10 crossings of breakpoint 1.
(Pdb) condition 1 1 < 2
New condition set for breakpoint 1.
(Pdb) condition 1 1 <
*** Invalid condition 1 <: SyntaxError: invalid syntax
(Pdb) break 4
Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) break 4
Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) break
Num Type         Disp Enb   Where
1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
        stop only if 1 < 2
        ignore next 10 hits
2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
3   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) clear 3
Deleted breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) break
Num Type         Disp Enb   Where
1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
        stop only if 1 < 2
        ignore next 10 hits
2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) condition 1
Breakpoint 1 is now unconditional.
(Pdb) commands 1
(com) EOF
<BLANKLINE>
(Pdb) enable 1
Enabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
(Pdb) commands 2
(com) p "42"
(com) print("42", 7*6)
(com) end
(Pdb) continue
1
'42'
42 42
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(4)test_function()
-> print(2)
(Pdb) clear
Clear all breaks? y
Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
(Pdb) tbreak 5
Breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
(Pdb) continue
2
Deleted breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(5)test_function()
-> print(3)
(Pdb) break
(Pdb) commands 10
*** cannot set commands: Breakpoint number 10 out of range
(Pdb) commands a
*** Invalid argument: a
      Usage: (Pdb) commands [bpnumber]
             (com) ...
             (com) end
             (Pdb)
(Pdb) commands 4
*** cannot set commands: Breakpoint 4 already deleted
(Pdb) break 6, undefined
Breakpoint 5 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:6
(Pdb) continue
3
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(6)test_function()
-> print(4)
(Pdb) continue
4
Nr2   r2   r   r   test_pdb_breakpoint_commandsr8      r4   r   c                     R# )aq  
>>> def test_function():
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
...     for i in range(5):
...         print(i)

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'break 4',
...     'ignore 1 2',  # ignore once
...     'continue',
...     'condition 1 i == 4',
...     'continue',
...     'clear 1',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break 4
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>:4
(Pdb) ignore 1 2
Will ignore next 2 crossings of breakpoint 1.
(Pdb) continue
0
1
> <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>(4)test_function()
-> print(i)
(Pdb) condition 1 i == 4
New condition set for breakpoint 1.
(Pdb) continue
2
3
> <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>(4)test_function()
-> print(i)
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_ignore_and_condition[0]>:4
(Pdb) continue
4
Nr2   r2   r   r   (test_pdb_breakpoint_ignore_and_conditionr:   j  r4   r   c                     R# )a  Test breakpoints on function definitions with annotation.

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

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

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

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'break foo',
...     'break bar',
...     'break foobar',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[3]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break foo
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[0]>:2
(Pdb) break bar
Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[1]>:2
(Pdb) break foobar
Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_on_annotated_function_def[2]>:2
(Pdb) continue
Nr2   r2   r   r   -test_pdb_breakpoint_on_annotated_function_defr<     r4   r   c                     R# )a`  Test the commands command of pdb.

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'b 3',
...     'commands',
...     'silent',      # suppress the frame status output
...     'p "hello"',
...     'end',
...     'b 4',
...     'commands',
...     'until 5',     # no output, should stop at line 5
...     'continue',    # hit breakpoint at line 3
...     '',            # repeat continue, hit breakpoint at line 4 then `until` to line 5
...     '',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_commands[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) b 3
Breakpoint 1 at <doctest test.test_pdb.test_pdb_commands[0]>:3
(Pdb) commands
(com) silent
(com) p "hello"
(com) end
(Pdb) b 4
Breakpoint 2 at <doctest test.test_pdb.test_pdb_commands[0]>:4
(Pdb) commands
(com) until 5
(Pdb) continue
'hello'
(Pdb)
1
2
> <doctest test.test_pdb.test_pdb_commands[0]>(5)test_function()
-> print(3)
(Pdb)
3
Nr2   r2   r   r   test_pdb_commandsr>     r4   r   c                     R# )aM  Breakpoints with filename:lineno

>>> def test_function():
...     # inspect_fodder2 is a great module as the line number is stable
...     from test.test_inspect import inspect_fodder2 as mod2
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
...     mod2.func88()
...     mod2.func114()

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
...     'break test.test_inspect.inspect_fodder2:90',
...     'continue', # will stop at func88
...     'break test/test_inspect/inspect_fodder2.py:115',
...     'continue', # will stop at func114
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_with_filename[0]>(4)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break test.test_inspect.inspect_fodder2:90
Breakpoint 1 at ...inspect_fodder2.py:90
(Pdb) continue
> ...inspect_fodder2.py(90)func88()
-> return 90
(Pdb) break test/test_inspect/inspect_fodder2.py:115
Breakpoint 2 at ...inspect_fodder2.py:115
(Pdb) continue
> ...inspect_fodder2.py(115)func114()
-> return 115
(Pdb) continue
Nr2   r2   r   r   !test_pdb_breakpoint_with_filenamer@     r4   r   c                     R# )a  New breakpoint on once disabled line should work

>>> def test_function():
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
...     for i in range(3):
...         j = i * 2
...         print(j)

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'break 5',
...     'c',
...     'clear 1',
...     'break 4',
...     'c',
...     'clear 2',
...     'c'
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break 5
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>:5
(Pdb) c
> <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>(5)test_function()
-> print(j)
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>:5
(Pdb) break 4
Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>:4
(Pdb) c
0
> <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>(4)test_function()
-> j = i * 2
(Pdb) clear 2
Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_on_disabled_line[0]>:4
(Pdb) c
2
4
Nr2   r2   r   r   $test_pdb_breakpoint_on_disabled_linerB     r4   r   c                     R# )a1  Breakpoints are remembered between interactive sessions

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

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

>>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...    'break',
...    'clear 2',
...    'clear 3',
...    'continue',
... ]):
...    pdb.run('print()')
> <string>(1)<module>()...
(Pdb) break
Num Type         Disp Enb   Where
2   breakpoint   keep yes   at ...test_pdb.py:...
3   breakpoint   keep yes   at ...pdb.py:...
(Pdb) clear 2
Deleted breakpoint 2 at ...test_pdb.py:...
(Pdb) clear 3
Deleted breakpoint 3 at ...pdb.py:...
(Pdb) continue
Nr2   r2   r   r   :test_pdb_breakpoints_preserved_across_interactive_sessionsrD   -  r4   r   c                     R# )a,  Test break_anywhere() method of Pdb.

>>> def outer():
...     def inner():
...         import pdb
...         import sys
...         p = pdb.Pdb(nosigint=True, readrc=False)
...         p.set_trace()
...         frame = sys._getframe()
...         print(p.break_anywhere(frame))  # inner
...         print(p.break_anywhere(frame.f_back))  # outer
...         print(p.break_anywhere(frame.f_back.f_back))  # caller
...     inner()

>>> def caller():
...     outer()

>>> def test_function():
...     caller()

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'b 3',
...     'c',
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_break_anywhere[0]>(6)inner()
-> p.set_trace()
(Pdb) b 3
Breakpoint 1 at <doctest test.test_pdb.test_pdb_break_anywhere[0]>:3
(Pdb) c
True
False
False
Nr2   r2   r   r   test_pdb_break_anywhererF   o  r4   r   c                     R# )ah  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()
> <doctest test.test_pdb.test_pdb_pp_repr_exc[2]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) p obj
*** Exception: repr_exc
(Pdb) pp obj
*** Exception: repr_exc
(Pdb) continue
Nr2   r2   r   r   test_pdb_pp_repr_excrH     r4   r   c                     R# )a  Test that empty line repeats the last command.

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'p x',
...     '',  # Should repeat p x
...     'n ;; p 0 ;; p x',  # Fill cmdqueue with multiple commands
...     '',  # Should still repeat p x
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_empty_line[0]>(3)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) p x
1
(Pdb)
1
(Pdb) n ;; p 0 ;; p x
0
1
> <doctest test.test_pdb.test_pdb_empty_line[0]>(4)test_function()
-> y = 2
(Pdb)
1
(Pdb) continue
Nr2   r2   r   r   test_pdb_empty_linerJ     r4   r   c                      R # r   r2   r2   r   r   
do_nothingrL     s    r   c                      \        ^*4       R# )*   N)printr2   r   r   do_somethingrP     s	    	"Ir   c                     R# )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
...     'step',      # go to the test function line
...     '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]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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
Nr2   r2   r   r   test_list_commandsrR     r4   r   c                     R# )a  Test 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()
> <doctest test.test_pdb.test_pdb_whatis_command[3]>(2)test_function()
-> 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
Nr2   r2   r   r   test_pdb_whatis_commandrT   6  r4   r   c                     R# )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
...     's',
...     'display +',
...     'display',
...     'display a',
...     'n',
...     'display',
...     'undisplay a',
...     'n',
...     'display a',
...     'undisplay',
...     'display a < 1',
...     'n',
...     'display undefined',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_display_command[0]>(3)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) s
> <doctest test.test_pdb.test_pdb_display_command[0]>(4)test_function()
-> a = 1
(Pdb) display +
*** Unable to display +: SyntaxError: invalid syntax
(Pdb) display
No expression is being displayed
(Pdb) display a
display a: 0
(Pdb) n
> <doctest test.test_pdb.test_pdb_display_command[0]>(5)test_function()
-> a = 2
display a: 1  [old: 0]
(Pdb) display
Currently displaying:
a: 1
(Pdb) undisplay a
(Pdb) n
> <doctest test.test_pdb.test_pdb_display_command[0]>(6)test_function()
-> a = 3
(Pdb) display a
display a: 2
(Pdb) undisplay
(Pdb) display a < 1
display a < 1: False
(Pdb) n
> <doctest test.test_pdb.test_pdb_display_command[0]>(7)test_function()
-> a = 4
(Pdb) display undefined
display undefined: ** raised NameError: name 'undefined' is not defined **
(Pdb) continue
Nr2   r2   r   r   test_pdb_display_commandrV   _  r4   r   c                     R# )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
...     's',
...     'alias pi',
...     'alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")',
...     'alias ps pi self',
...     'alias ps',
...     'pi o',
...     's',
...     'ps',
...     'alias myp p %2',
...     'alias myp',
...     'alias myp p %1',
...     'myp',
...     'myp 1',
...     'myp 1 2',
...     'alias repeat_second_arg p "%* %2"',
...     'repeat_second_arg 1 2 3',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_alias_command[1]>(3)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) s
> <doctest test.test_pdb.test_pdb_alias_command[1]>(4)test_function()
-> o.method()
(Pdb) alias pi
*** Unknown alias 'pi'
(Pdb) alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")
(Pdb) alias ps pi self
(Pdb) alias ps
ps = pi self
(Pdb) pi o
o.attr1 = 10
o.attr2 = str
(Pdb) s
--Call--
> <doctest test.test_pdb.test_pdb_alias_command[0]>(5)method()
-> def method(self):
(Pdb) ps
self.attr1 = 10
self.attr2 = str
(Pdb) alias myp p %2
*** Replaceable parameters must be consecutive
(Pdb) alias myp
*** Unknown alias 'myp'
(Pdb) alias myp p %1
(Pdb) myp
*** Not enough arguments for alias 'myp'
(Pdb) myp 1
1
(Pdb) myp 1 2
*** Too many arguments for alias 'myp'
(Pdb) alias repeat_second_arg p "%* %2"
(Pdb) repeat_second_arg 1 2 3
'1 2 3 2'
(Pdb) continue
Nr2   r2   r   r   test_pdb_alias_commandrX     r4   r   c                     R# )a}
  Test 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',
...     'w 1',
...     'w invalid',
...     'u',
...     'w',
...     'w 0',
...     'w 100',
...     'w -100',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w
...
  <doctest test.test_pdb.test_pdb_where_command[3]>(13)<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()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) where
...
  <doctest test.test_pdb.test_pdb_where_command[3]>(13)<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()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w 1
> <doctest test.test_pdb.test_pdb_where_command[0]>(2)g()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w invalid
*** Invalid count (invalid)
(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]>(13)<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()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w 0
> <doctest test.test_pdb.test_pdb_where_command[1]>(2)f()
-> g()
(Pdb) w 100
...
  <doctest test.test_pdb.test_pdb_where_command[3]>(13)<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()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) w -100
...
  <doctest test.test_pdb.test_pdb_where_command[3]>(13)<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()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
Nr2   r2   r   r   test_pdb_where_commandrZ     r4   r   c                     R# )ad  Test restart command

>>> def test_function():
...     import pdb; pdb.Pdb(nosigint=True, readrc=False, mode='inline').set_trace()
...     x = 1

>>> with PdbTestInput([  # doctest: +ELLIPSIS
...     'restart',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_restart_command[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False, mode='inline').set_trace()
(Pdb) restart
*** run/restart command is disabled when pdb is running in inline mode.
Use the command line interface to enable restarting your program
e.g. "python -m pdb myscript.py"
(Pdb) continue
Nr2   r2   r   r   test_pdb_restart_commandr\   B  r4   r   c                     R# )zTest that commands can be passed to Pdb.set_trace()

>>> def test_function():
...     x = 1
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace(commands=['p x', 'c'])

>>> test_function()
1
Nr2   r2   r   r    test_pdb_commands_with_set_tracer^   W  r4   r   c                     R# )a  Test interact command

>>> g = 0
>>> dict_g = {}

>>> def test_function():
...     x = 1
...     lst_local = []
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()

>>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     'interact',
...     'x',
...     'g',
...     'x = 2',
...     'g = 3',
...     'dict_g["a"] = True',
...     'lst_local.append(x)',
...     'exit()',
...     'p x',
...     'p g',
...     'p dict_g',
...     'p lst_local',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_interact_command[2]>(4)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) interact
*pdb interact start*
... x
1
... g
0
... x = 2
... g = 3
... dict_g["a"] = True
... lst_local.append(x)
... exit()
*exit from pdb interact command*
(Pdb) p x
1
(Pdb) p g
0
(Pdb) p dict_g
{'a': True}
(Pdb) p lst_local
[2]
(Pdb) continue
Nr2   r2   r   r   test_pdb_interact_commandr`   f  r4   r   c                     R# )a;
  Test convenience variables

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

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

>>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     'step',             # Step to try statement
...     '$_frame.f_lineno', # Check frame convenience variable
...     '$ _frame',         # This should be a syntax error
...     '$a = 10',          # Set a convenience variable
...     '$a',               # Print its value
...     'p "$a"',           # Print the string $a
...     'p $a + 2',         # Do some calculation
...     'p f"$a = {$a}"',   # Make sure $ in string is not converted and f-string works
...     'u',                # Switch frame
...     '$_frame.f_lineno', # Make sure the frame changed
...     '$a',               # Make sure the value persists
...     'd',                # Go back to the original frame
...     'next',
...     '$a',               # The value should be gone
...     'next',
...     '$_exception',      # Check exception convenience variable
...     'next',
...     '$_exception',      # Exception should be gone
...     'return',
...     '$_retval',         # Check return convenience variable
...     'continue',
... ]):
...     test_function()
> <doctest test.test_pdb.test_convenience_variables[0]>(2)util_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_convenience_variables[0]>(3)util_function()
-> try:
(Pdb) $_frame.f_lineno
3
(Pdb) $ _frame
*** SyntaxError: invalid syntax
(Pdb) $a = 10
(Pdb) $a
10
(Pdb) p "$a"
'$a'
(Pdb) p $a + 2
12
(Pdb) p f"$a = {$a}"
'$a = 10'
(Pdb) u
> <doctest test.test_pdb.test_convenience_variables[1]>(2)test_function()
-> util_function()
(Pdb) $_frame.f_lineno
2
(Pdb) $a
10
(Pdb) d
> <doctest test.test_pdb.test_convenience_variables[0]>(3)util_function()
-> try:
(Pdb) next
> <doctest test.test_pdb.test_convenience_variables[0]>(4)util_function()
-> raise Exception('test')
(Pdb) $a
*** KeyError: 'a'
(Pdb) next
Exception: test
> <doctest test.test_pdb.test_convenience_variables[0]>(4)util_function()
-> raise Exception('test')
(Pdb) $_exception
Exception('test')
(Pdb) next
> <doctest test.test_pdb.test_convenience_variables[0]>(5)util_function()
-> except Exception:
(Pdb) $_exception
*** KeyError: '_exception'
(Pdb) return
--Return--
> <doctest test.test_pdb.test_convenience_variables[0]>(7)util_function()->1
-> return 1
(Pdb) $_retval
1
(Pdb) continue
Nr2   r2   r   r   test_convenience_variablesrb     r4   r   c                     R# )a  Test post mortem traceback debugging of chained exception

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

>>> def test_function_reraise():
...     try:
...         test_function_2()
...     except ZeroDivisionError as e:
...         raise ZeroDivisionError('reraised') from e

>>> def test_function():
...     import pdb;
...     instance = pdb.Pdb(nosigint=True, readrc=False)
...     try:
...         test_function_reraise()
...     except Exception as e:
...         pdb._post_mortem(e, instance)

>>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     'exceptions',
...     'exceptions 0',
...     '$_exception',
...     'up',
...     'down',
...     'exceptions 1',
...     '$_exception',
...     'up',
...     'down',
...     'exceptions -1',
...     'exceptions 3',
...     'up',
...     'exit',
... ]):
...    try:
...        test_function()
...    except ZeroDivisionError:
...        print('Correctly reraised.')
Exception!
> <doctest test.test_pdb.test_post_mortem_chained[1]>(5)test_function_reraise()
-> raise ZeroDivisionError('reraised') from e
(Pdb) exceptions
  0 ZeroDivisionError('division by zero')
> 1 ZeroDivisionError('reraised')
(Pdb) exceptions 0
> <doctest test.test_pdb.test_post_mortem_chained[0]>(3)test_function_2()
-> 1/0
(Pdb) $_exception
ZeroDivisionError('division by zero')
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_chained[1]>(3)test_function_reraise()
-> test_function_2()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_chained[0]>(3)test_function_2()
-> 1/0
(Pdb) exceptions 1
> <doctest test.test_pdb.test_post_mortem_chained[1]>(5)test_function_reraise()
-> raise ZeroDivisionError('reraised') from e
(Pdb) $_exception
ZeroDivisionError('reraised')
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_chained[2]>(5)test_function()
-> test_function_reraise()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_chained[1]>(5)test_function_reraise()
-> raise ZeroDivisionError('reraised') from e
(Pdb) exceptions -1
*** No exception with that number
(Pdb) exceptions 3
*** No exception with that number
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_chained[2]>(5)test_function()
-> test_function_reraise()
(Pdb) exit
Nr2   r2   r   r   test_post_mortem_chainedrd     r4   r   c                     R# )a  Test post mortem traceback debugging of chained exception

>>> def make_exc_with_stack(type_, *content, from_=None):
...     try:
...         raise type_(*content) from from_
...     except Exception as out:
...         return out
...

>>> def main():
...     try:
...         raise ValueError('Context Not Shown')
...     except Exception as e1:
...         raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause')

>>> def test_function():
...     import pdb;
...     instance = pdb.Pdb(nosigint=True, readrc=False)
...     try:
...         main()
...     except Exception as e:
...         pdb._post_mortem(e, instance)

>>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     'exceptions',
...     'exceptions 0',
...     'exceptions 1',
...     'up',
...     'down',
...     'exit',
... ]):
...    try:
...        test_function()
...    except ValueError:
...        print('Ok.')
> <doctest test.test_pdb.test_post_mortem_cause_no_context[1]>(5)main()
-> raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause')
(Pdb) exceptions
    0 TypeError('The Cause')
>   1 ValueError('With Cause')
(Pdb) exceptions 0
> <doctest test.test_pdb.test_post_mortem_cause_no_context[0]>(3)make_exc_with_stack()
-> raise type_(*content) from from_
(Pdb) exceptions 1
> <doctest test.test_pdb.test_post_mortem_cause_no_context[1]>(5)main()
-> raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause')
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_cause_no_context[2]>(5)test_function()
-> main()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_cause_no_context[1]>(5)main()
-> raise ValueError("With Cause") from make_exc_with_stack(TypeError,'The Cause')
(Pdb) exitNr2   r2   r   r   !test_post_mortem_cause_no_contextrf   G  r4   r   c                     R# )a  Test post mortem traceback debugging of chained exception


>>> def main():
...     try:
...         raise TypeError('Context of the cause')
...     except Exception as e1:
...         try:
...             raise ValueError('Root Cause')
...         except Exception as e2:
...             ex = e2
...         raise ValueError("With Cause, and cause has context") from ex

>>> def test_function():
...     import pdb;
...     instance = pdb.Pdb(nosigint=True, readrc=False)
...     try:
...         main()
...     except Exception as e:
...         pdb._post_mortem(e, instance)

>>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     'exceptions',
...     'exceptions 2',
...     'up',
...     'down',
...     'exceptions 3',
...     'up',
...     'down',
...     'exceptions 4',
...     'up',
...     'down',
...     'exit',
... ]):
...    try:
...        test_function()
...    except ValueError:
...        print('Correctly reraised.')
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) exceptions
  0 TypeError('Context of the cause')
  1 ValueError('Root Cause')
> 2 ValueError('With Cause, and cause has context')
(Pdb) exceptions 2
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[1]>(5)test_function()
-> main()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) exceptions 3
*** No exception with that number
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[1]>(5)test_function()
-> main()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) exceptions 4
*** No exception with that number
(Pdb) up
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[1]>(5)test_function()
-> main()
(Pdb) down
> <doctest test.test_pdb.test_post_mortem_context_of_the_cause[0]>(9)main()
-> raise ValueError("With Cause, and cause has context") from ex
(Pdb) exit
Nr2   r2   r   r   %test_post_mortem_context_of_the_causerh     r4   r   c                     R# )a  Test post mortem traceback debugging of chained exception

In particular that cause from None (which sets __suppress_context__ to True)
does not show context.


>>> def main():
...     try:
...         raise TypeError('Context of the cause')
...     except Exception as e1:
...         raise ValueError("With Cause, and cause has context") from None

>>> def test_function():
...     import pdb;
...     instance = pdb.Pdb(nosigint=True, readrc=False)
...     try:
...         main()
...     except Exception as e:
...         pdb._post_mortem(e, instance)

>>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     'exceptions',
...     'exit',
... ]):
...    try:
...        test_function()
...    except ValueError:
...        print('Correctly reraised.')
> <doctest test.test_pdb.test_post_mortem_from_none[0]>(5)main()
-> raise ValueError("With Cause, and cause has context") from None
(Pdb) exceptions
> 0 ValueError('With Cause, and cause has context')
(Pdb) exit
Nr2   r2   r   r   test_post_mortem_from_nonerj     r4   r   c                     R# )ag  Test post mortem traceback debugging of chained exception

especially when one exception has no stack.

>>> def main():
...     raise Exception() from Exception()


>>> def test_function():
...     import pdb;
...     instance = pdb.Pdb(nosigint=True, readrc=False)
...     try:
...         main()
...     except Exception as e:
...         pdb._post_mortem(e, instance)

>>> with PdbTestInput(  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     ["exceptions",
...      "exceptions 0",
...     "exit"],
... ):
...    try:
...        test_function()
...    except ValueError:
...        print('Correctly reraised.')
> <doctest test.test_pdb.test_post_mortem_from_no_stack[0]>(2)main()
-> raise Exception() from Exception()
(Pdb) exceptions
    - Exception()
>   1 Exception()
(Pdb) exceptions 0
*** This exception does not have a traceback, cannot jump to it
(Pdb) exit
Nr2   r2   r   r   test_post_mortem_from_no_stackrl     r4   r   c                     R# )a  Test post mortem called when origin exception has no stack


>>> def test_function():
...     import pdb;
...     instance = pdb.Pdb(nosigint=True, readrc=False)
...     import sys
...     sys.last_exc = Exception()
...     pdb._post_mortem(sys.last_exc, instance)

>>> with PdbTestInput(  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     []
... ):
...    try:
...        test_function()
...    except ValueError as e:
...        print(e)
A valid traceback must be passed if no exception is being handled
Nr2   r2   r   r    test_post_mortem_single_no_stackrn     r4   r   c                     R# )au
  Test post mortem traceback debugging of chained exception

Test with simple and complex cycles, exception groups,...

>>> def make_ex_with_stack(type_, *content, from_=None):
...     try:
...         raise type_(*content) from from_
...     except Exception as out:
...         return out
...

>>> def cycle():
...     try:
...         raise ValueError("Cycle Leaf")
...     except Exception as e:
...         raise e from e
...

>>> def tri_cycle():
...     a = make_ex_with_stack(ValueError, "Cycle1")
...     b = make_ex_with_stack(ValueError, "Cycle2")
...     c = make_ex_with_stack(ValueError, "Cycle3")
...
...     a.__cause__ = b
...     b.__cause__ = c
...
...     raise c from a
...

>>> def cause():
...     try:
...         raise ValueError("Cause Leaf")
...     except Exception as e:
...         raise e
...

>>> def context(n=10):
...     try:
...         raise ValueError(f"Context Leaf {n}")
...     except Exception as e:
...         if n == 0:
...             raise ValueError(f"With Context {n}") from e
...         else:
...             context(n - 1)
...

>>> def main():
...     try:
...         cycle()
...     except Exception as e1:
...         try:
...             tri_cycle()
...         except Exception as e2:
...             ex = e2
...         raise ValueError("With Context and With Cause") from ex


>>> def test_function():
...     import pdb;
...     instance = pdb.Pdb(nosigint=True, readrc=False)
...     try:
...         main()
...     except Exception as e:
...         pdb._post_mortem(e, instance)

>>> with PdbTestInput(  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     ["exceptions",
...     "exceptions 0",
...     "exceptions 1",
...     "exceptions 2",
...     "exceptions 3",
...     "exit"],
... ):
...    try:
...        test_function()
...    except ValueError:
...        print('Correctly reraised.')
    > <doctest test.test_pdb.test_post_mortem_complex[5]>(9)main()
-> raise ValueError("With Context and With Cause") from ex
(Pdb) exceptions
    0 ValueError('Cycle2')
    1 ValueError('Cycle1')
    2 ValueError('Cycle3')
>   3 ValueError('With Context and With Cause')
(Pdb) exceptions 0
> <doctest test.test_pdb.test_post_mortem_complex[0]>(3)make_ex_with_stack()
-> raise type_(*content) from from_
(Pdb) exceptions 1
> <doctest test.test_pdb.test_post_mortem_complex[0]>(3)make_ex_with_stack()
-> raise type_(*content) from from_
(Pdb) exceptions 2
> <doctest test.test_pdb.test_post_mortem_complex[0]>(3)make_ex_with_stack()
-> raise type_(*content) from from_
(Pdb) exceptions 3
> <doctest test.test_pdb.test_post_mortem_complex[5]>(9)main()
-> raise ValueError("With Context and With Cause") from ex
(Pdb) exit
Nr2   r2   r   r   test_post_mortem_complexrp   (  r4   r   c                     R# )at  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
...     'step',      # step to test_function_2() line
...     '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]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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]>(11)<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.
Nr2   r2   r   r   test_post_mortemrr     r4   r   c                     R# )a  When pdb returns to a different file, it should not skip if f_trace is
   not already set

>>> import pprint

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

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

>>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
...     'b A.__repr__',
...     'continue',
...     'return',
...     'next',
...     'return',
...     'return',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_return_to_different_file[2]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) b A.__repr__
Breakpoint 1 at <doctest test.test_pdb.test_pdb_return_to_different_file[1]>:3
(Pdb) continue
> <doctest test.test_pdb.test_pdb_return_to_different_file[1]>(3)__repr__()
-> return 'A'
(Pdb) return
--Return--
> <doctest test.test_pdb.test_pdb_return_to_different_file[1]>(3)__repr__()->'A'
-> return 'A'
(Pdb) next
> ...pprint.py..._safe_repr()
-> return rep,...
(Pdb) return
--Return--
> ...pprint.py..._safe_repr()->('A'...)
-> return rep,...
(Pdb) return
--Return--
> ...pprint.py...format()->('A'...)
-> return...
(Pdb) continue
A
Nr2   r2   r   r   !test_pdb_return_to_different_filert     r4   r   c                     R# )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',
...     'step',
...     'continue',
... ]):
...     skip_module()
> <doctest test.test_pdb.test_pdb_skip_modules[0]>(3)skip_module()
-> import pdb; pdb.Pdb(skip=['stri*'], nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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
Nr2   r2   r   r   test_pdb_skip_modulesrv     r4   r   c                     R# )aG  This tests pdb commands that have invalid arguments

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'a = 3',
...     'll 4',
...     'step 1',
...     'p',
...     'enable ',
...     'continue'
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_invalid_arg[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) a = 3
*** Invalid argument: = 3
      Usage: a(rgs)
(Pdb) ll 4
*** Invalid argument: 4
      Usage: ll | longlist
(Pdb) step 1
*** Invalid argument: 1
      Usage: s(tep)
(Pdb) p
*** Argument is required for this command
      Usage: p expression
(Pdb) enable
*** Argument is required for this command
      Usage: enable bpnumber [bpnumber ...]
(Pdb) continue
Nr2   r2   r   r   test_pdb_invalid_argrx     r4   r   module_to_skipz6def foo_pony(callback): x = 1; callback(); return Nonec                     R# )as  This 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',
...     'step',
...     'continue',
... ]):
...     skip_module()
...     pass  # provides something to "step" to
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(4)skip_module()
-> import pdb; pdb.Pdb(skip=['module_to_skip*'], nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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]>(11)<module>()
-> pass  # provides something to "step" to
(Pdb) continue
Nr2   r2   r   r   #test_pdb_skip_modules_with_callbackr{   E  r4   r   c                     R# )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
...     'step',
...     'next',
...     'break 7',
...     'continue',
...     'next',
...     'continue',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(3)test_function()
-> inst.set_trace()
(Pdb) step
> <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
Nr2   r2   r   r    test_pdb_continue_in_bottomframer}   t  r4   r   c                V    \        \        P                  ! RRR7      V 4      ! V4       R# )zRun pdb.method(arg).TF)nosigintreadrcN)getattrpdbPdb)methodargs   &&r   
pdb_invoker     s    CGGT%0&9#>r   c                     R# )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
Nr2   r2   r   r   $test_pdb_run_with_incorrect_argumentr     r4   r   c                     R# )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
Nr2   r2   r   r   test_pdb_run_with_code_objectr     r4   r   c                     R# )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

>>> 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]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break test_function_2
Breakpoint 1 at <doctest test.test_pdb.test_next_until_return_at_return_event[0]>: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) 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
Nr2   r2   r   r   &test_next_until_return_at_return_eventr     r4   r   c                     R# )aB  Testing skip unwinding 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',
...                    'step',
...                    'next',
...                    'next',
...                    'step',
...                    'step',
...                    'continue']):
...     test_function()
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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
Nr2   r2   r   r   #test_pdb_next_command_for_generatorr     r4   r   c                     R# )aq  Testing $_asynctask is accessible in async context

>>> import asyncio

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

>>> def test_function():
...     asyncio.run(test(), loop_factory=asyncio.EventLoop)

>>> with PdbTestInput([  # doctest: +ELLIPSIS
...     '$_asynctask',
...     'continue',
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_asynctask[1]>(2)test()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) $_asynctask
<Task pending name=... coro=<test() running at <doctest test.test_pdb.test_pdb_asynctask[1]>:2> ...
(Pdb) continue
Nr2   r2   r   r   test_pdb_asynctaskr   M  r4   r   c                     R# )a  Testing await support in pdb

>>> import asyncio

>>> async def test():
...     print("hello")
...     await asyncio.sleep(0)
...     print("world")
...     return 42

>>> async def main():
...     import pdb
...     task = asyncio.create_task(test())
...     await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
...     pass

>>> def test_function():
...     asyncio.run(main(), loop_factory=asyncio.EventLoop)

>>> with PdbTestInput([  # doctest: +ELLIPSIS
...     'x = await task',
...     'p x',
...     'x = await test()',
...     'p x',
...     'new_task = asyncio.create_task(test())',
...     'await new_task',
...     'await non_exist()',
...     's',
...     'continue',
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) x = await task
hello
world
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p x
42
(Pdb) x = await test()
hello
world
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p x
42
(Pdb) new_task = asyncio.create_task(test())
(Pdb) await new_task
hello
world
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) await non_exist()
*** NameError: name 'non_exist' is not defined
> <doctest test.test_pdb.test_pdb_await_support[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) s
> <doctest test.test_pdb.test_pdb_await_support[2]>(5)main()
-> pass
(Pdb) continue
Nr2   r2   r   r   test_pdb_await_supportr   d  r4   r   c                     R# )a  Testing await support with breakpoints set in tasks

>>> import asyncio

>>> async def test():
...     x = 2
...     await asyncio.sleep(0)
...     return 42

>>> async def main():
...     import pdb
...     task = asyncio.create_task(test())
...     await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()

>>> def test_function():
...     asyncio.run(main(), loop_factory=asyncio.EventLoop)

>>> with PdbTestInput([  # doctest: +ELLIPSIS
...     'b test',
...     'k = await task',
...     'n',
...     'p x',
...     'continue',
...     'p k',
...     'continue',
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_await_with_breakpoint[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) b test
Breakpoint 1 at <doctest test.test_pdb.test_pdb_await_with_breakpoint[1]>:2
(Pdb) k = await task
> <doctest test.test_pdb.test_pdb_await_with_breakpoint[1]>(2)test()
-> x = 2
(Pdb) n
> <doctest test.test_pdb.test_pdb_await_with_breakpoint[1]>(3)test()
-> await asyncio.sleep(0)
(Pdb) p x
2
(Pdb) continue
> <doctest test.test_pdb.test_pdb_await_with_breakpoint[2]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p k
42
(Pdb) continue
Nr2   r2   r   r   test_pdb_await_with_breakpointr     r4   r   c                     R# )ak  Testing await support context vars

>>> import asyncio
>>> import contextvars

>>> var = contextvars.ContextVar('var')

>>> async def get_var():
...     return var.get()

>>> async def set_var(val):
...     var.set(val)
...     return var.get()

>>> async def main():
...     var.set(42)
...     import pdb
...     await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()

>>> def test_function():
...     asyncio.run(main(), loop_factory=asyncio.EventLoop)

>>> with PdbTestInput([
...     'p var.get()',
...     'print(await get_var())',
...     'print(await asyncio.create_task(set_var(100)))',
...     'p var.get()',
...     'print(await set_var(99))',
...     'p var.get()',
...     'print(await get_var())',
...     'continue',
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p var.get()
42
(Pdb) print(await get_var())
42
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) print(await asyncio.create_task(set_var(100)))
100
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p var.get()
42
(Pdb) print(await set_var(99))
99
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) p var.get()
99
(Pdb) print(await get_var())
99
> <doctest test.test_pdb.test_pdb_await_contextvar[5]>(4)main()
-> await pdb.Pdb(nosigint=True, readrc=False).set_trace_async()
(Pdb) continue
Nr2   r2   r   r   test_pdb_await_contextvarr     r4   r   c                     R# )a  Testing skip unwinding stack on yield for coroutines for "next" command

>>> from test.support import run_yielding_async_fn, async_yield

>>> async def test_coro():
...     await async_yield(0)
...     await async_yield(0)
...     await async_yield(0)

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

>>> def test_function():
...     run_yielding_async_fn(test_main)
...     print("finished")

>>> with PdbTestInput(['step',
...                    'step',
...                    'step',
...                    'next',
...                    'next',
...                    'next',
...                    'step',
...                    'continue']):
...     test_function()
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(2)test_main()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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 async_yield(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(3)test_coro()
-> await async_yield(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(4)test_coro()
-> await async_yield(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
Nr2   r2   r   r   #test_pdb_next_command_for_coroutiner   	  r4   r   c                     R# )a  Testing skip unwinding stack on yield for coroutines for "next" command

>>> from test.support import run_yielding_async_fn, async_yield

>>> async def agen():
...     yield 1
...     await async_yield(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():
...     run_yielding_async_fn(test_main)
...     print("finished")

>>> with PdbTestInput(['step',
...                    'step',
...                    'step',
...                    'next',
...                    'next',
...                    'step',
...                    'next',
...                    'continue']):
...     test_function()
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[3]>(2)test_main()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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 async_yield(0)
(Pdb) continue
2
finished
Nr2   r2   r   r   "test_pdb_next_command_for_asyncgenr   J	  r4   r   c                     R# )a  Testing no unwinding 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',
...                    'step',
...                    'return',
...                    'step',
...                    'step',
...                    'continue']):
...     test_function()
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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
Nr2   r2   r   r   %test_pdb_return_command_for_generatorr   	  r4   r   c                     R# )a  Testing no unwinding stack on yield for coroutines for "return" command

>>> from test.support import run_yielding_async_fn, async_yield

>>> async def test_coro():
...     await async_yield(0)
...     await async_yield(0)
...     await async_yield(0)

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

>>> def test_function():
...     run_yielding_async_fn(test_main)
...     print("finished")

>>> with PdbTestInput(['step',
...                    'step',
...                    'step',
...                    'next',
...                    'continue']):
...     test_function()
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[2]>(2)test_main()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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 async_yield(0)
(Pdb) next
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(3)test_coro()
-> await async_yield(0)
(Pdb) continue
finished
Nr2   r2   r   r   %test_pdb_return_command_for_coroutiner   	  r4   r   c                     R# )a  Testing no unwinding 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',
...                    'step',
...                    'until 4',
...                    'step',
...                    'step',
...                    'continue']):
...     test_function()
> <doctest test.test_pdb.test_pdb_until_command_for_generator[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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
Nr2   r2   r   r   $test_pdb_until_command_for_generatorr   	  r4   r   c                     R# )a  Testing no unwinding stack for coroutines
for "until" command if target breakpoint is not reached

>>> from test.support import run_yielding_async_fn, async_yield

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

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

>>> def test_function():
...     run_yielding_async_fn(test_main)
...     print("finished")

>>> with PdbTestInput(['step',
...                    'step',
...                    'until 8',
...                    'continue']):
...     test_function()
> <doctest test.test_pdb.test_pdb_until_command_for_coroutine[2]>(2)test_main()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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
Nr2   r2   r   r   $test_pdb_until_command_for_coroutiner    
  r4   r   c                     R# )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

>>> 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]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break test_gen
Breakpoint 1 at <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>:2
(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
Nr2   r2   r   r   +test_pdb_next_command_in_generator_for_loopr   P
  r4   r   c                     R# )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',
...                    'step',
...                    'next',
...                    'next',
...                    'next',
...                    'continue']):
...     test_function()
> <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <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
Nr2   r2   r   r   !test_pdb_next_command_subiteratorr   y
  r4   r   c                     R# )aW  GH-132536: PY_THROW event should not be turned off

>>> def gen():
...    yield 0

>>> def test_function():
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
...     g = gen()
...     try:
...         g.throw(TypeError)
...     except TypeError:
...         pass

>>> with PdbTestInput([
...     'b 7',
...     'continue',
...     'clear 1',
...     'continue',
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_breakpoint_with_throw[1]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) b 7
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_with_throw[1]>:7
(Pdb) continue
> <doctest test.test_pdb.test_pdb_breakpoint_with_throw[1]>(7)test_function()
-> pass
(Pdb) clear 1
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_with_throw[1]>:7
(Pdb) continue
Nr2   r2   r   r   test_pdb_breakpoint_with_throwr   
  r4   r   c                     R# )a  Test for multiline statement

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'def f(x):',
...     '  return x * 2',
...     '',
...     'val = 2',
...     'if val > 0:',
...     '  val = f(val)',
...     '',
...     '',  # empty line should repeat the multi-line statement
...     'val',
...     'c'
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_multiline_statement[0]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) def f(x):
...     return x * 2
...
(Pdb) val = 2
(Pdb) if val > 0:
...     val = f(val)
...
(Pdb)
(Pdb) val
8
(Pdb) c
Nr2   r2   r   r   test_pdb_multiline_statementr   
  r4   r   c                     R# )a  Test for all expressions/statements that involve closure

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'k',
...     'g',
...     'y = y',
...     'global g; g',
...     'global g; (lambda: g)()',
...     '(lambda: x)()',
...     '(lambda: g)()',
...     'lst = [n for n in range(10) if (n % x) == 0]',
...     'lst',
...     'sum(n for n in lst if n > x)',
...     'x = 1; raise Exception()',
...     'x',
...     'def f():',
...     '  return x',
...     '',
...     'f()',
...     'c'
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_closure[2]>(4)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) k
0
(Pdb) g
3
(Pdb) y = y
*** NameError: name 'y' is not defined
(Pdb) global g; g
1
(Pdb) global g; (lambda: g)()
1
(Pdb) (lambda: x)()
2
(Pdb) (lambda: g)()
3
(Pdb) lst = [n for n in range(10) if (n % x) == 0]
(Pdb) lst
[0, 2, 4, 6, 8]
(Pdb) sum(n for n in lst if n > x)
18
(Pdb) x = 1; raise Exception()
*** Exception
(Pdb) x
1
(Pdb) def f():
...     return x
...
(Pdb) f()
1
(Pdb) c
Nr2   r2   r   r   test_pdb_closurer   
  r4   r   c                     R# )a  Test for expressions with command prefix

>>> def test_function():
...     n = lambda x: x
...     c = {"a": 1}
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'c["a"]',
...     'c.get("a")',
...     'n(1)',
...     'j=1',
...     'j+1',
...     'r"a"',
...     'next(iter([1]))',
...     'list((0, 1))',
...     'c'
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_show_attribute_and_item[0]>(4)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) c["a"]
1
(Pdb) c.get("a")
1
(Pdb) n(1)
1
(Pdb) j=1
(Pdb) j+1
2
(Pdb) r"a"
'a'
(Pdb) next(iter([1]))
1
(Pdb) list((0, 1))
[0, 1]
(Pdb) c
Nr2   r2   r   r    test_pdb_show_attribute_and_itemr   .  r4   r   c                     R# )a+  Hard-coded breakpoint() calls should invoke the same debugger instance

>>> def test_function():
...     x = 1
...     import pdb; pdb.Pdb().set_trace()
...     original_pdb_settrace()
...     x = 2

>>> with PdbTestInput(['display x',
...                    'n',
...                    'n',
...                    'n',
...                    'n',
...                    'undisplay',
...                    'c']):
...     test_function()
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(3)test_function()
-> import pdb; pdb.Pdb().set_trace()
(Pdb) display x
display x: 1
(Pdb) n
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(4)test_function()
-> original_pdb_settrace()
(Pdb) n
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(4)test_function()
-> original_pdb_settrace()
(Pdb) n
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(5)test_function()
-> x = 2
(Pdb) n
--Return--
> <doctest test.test_pdb.test_pdb_with_inline_breakpoint[0]>(5)test_function()->None
-> x = 2
display x: 2  [old: 1]
(Pdb) undisplay
(Pdb) c
Nr2   r2   r   r   test_pdb_with_inline_breakpointr   Z  r4   r   c                     R# )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]>(5)test_function()
-> sess.set_trace(sys._getframe())
(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>
Nr2   r2   r   r   test_pdb_issue_20766r     r4   r   c                     R# )a  echo 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)
>>> 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]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(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
Nr2   r2   r   r   test_pdb_issue_43318r     r4   r   c                     R# )a  See GH-91742

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


>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'step',
...     'step',
...     'next',
...     'next',
...     'jump 5',
...     'continue'
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(11)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(12)test_function()
-> about()
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(5)about()
-> def about():
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(7)about()
-> print(f"Author: {__author__!r}",
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(8)about()
-> f"Version: {__version__!r}",
(Pdb) jump 5
> <doctest test.test_pdb.test_pdb_issue_gh_91742[0]>(5)about()
-> def about():
(Pdb) continue
Author: 'pi' Version: '3.14'
Nr2   r2   r   r   test_pdb_issue_gh_91742r     r4   r   c                     R# )a  See GH-94215

Check that frame_setlineno() does not leak references.

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'step',
...     'step',
...     'next',
...     'next',
...     'jump 3',
...     'next',
...     'next',
...     'jump 3',
...     'next',
...     'next',
...     'jump 3',
...     'continue'
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(8)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) step
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(9)test_function()
-> func()
(Pdb) step
--Call--
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(2)func()
-> def func():
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
-> def inner(v): pass
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
-> inner(
(Pdb) jump 3
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
-> def inner(v): pass
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
-> inner(
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(5)func()
-> 42
(Pdb) jump 3
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
-> def inner(v): pass
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(4)func()
-> inner(
(Pdb) next
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(5)func()
-> 42
(Pdb) jump 3
> <doctest test.test_pdb.test_pdb_issue_gh_94215[0]>(3)func()
-> def inner(v): pass
(Pdb) continue
Nr2   r2   r   r   test_pdb_issue_gh_94215r     r4   r   c                     R# )a  See GH-101673

Make sure ll and switching frames 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',
...     'u',
...     'p a',
...     'd',
...     'p a',
...     'continue'
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_101673[0]>(3)test_function()
-> 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) u
> <doctest test.test_pdb.test_pdb_issue_gh_101673[1]>(11)<module>()
-> test_function()
(Pdb) p a
*** NameError: name 'a' is not defined
(Pdb) d
> <doctest test.test_pdb.test_pdb_issue_gh_101673[0]>(3)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) p a
2
(Pdb) continue
Nr2   r2   r   r   test_pdb_issue_gh_101673r   *  r4   r   c                     R# )a  See GH-103225

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'longlist',
...     'continue'
... ]):
...     a = 1
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
...     b = 2
> <doctest test.test_pdb.test_pdb_issue_gh_103225[0]>(6)<module>()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) longlist
  1     with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
  2         'longlist',
  3         'continue'
  4     ]):
  5         a = 1
  6 ->      import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
  7         b = 2
(Pdb) continue
Nr2   r2   r   r   test_pdb_issue_gh_103225r   T  r4   r   c                     R# )a  See GH-101517

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

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'continue'
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_101517[0]>(5)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
Nr2   r2   r   r   test_pdb_issue_gh_101517r   m  r4   r   c                     R# )a  See GH-108976
Make sure setting f_trace_opcodes = True won't crash pdb
>>> def test_function():
...     import sys
...     sys._getframe().f_trace_opcodes = True
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
...     a = 1
>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'continue'
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_108976[0]>(4)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
Nr2   r2   r   r   test_pdb_issue_gh_108976r     r4   r   c                     R# )a  See GH-127321
breakpoint() should stop at a opcode that has a line number
>>> def test_function():
...     import pdb; pdb_instance = pdb.Pdb(nosigint=True, readrc=False)
...     [1, 2] and pdb_instance.set_trace()
...     a = 1
>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'continue'
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_127321[0]>(4)test_function()
-> a = 1
(Pdb) continue
Nr2   r2   r   r   test_pdb_issue_gh_127321r     r4   r   c                     R# )ab  See GH-80731

pdb should correctly print exception info if in an except block.

>>> with PdbTestInput([  # doctest: +ELLIPSIS
...     'import sys',
...     'sys.exc_info()',
...     'continue'
... ]):
...     try:
...         raise ValueError('Correct')
...     except ValueError:
...         import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
> <doctest test.test_pdb.test_pdb_issue_gh_80731[0]>(9)<module>()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) import sys
(Pdb) sys.exc_info()
(<class 'ValueError'>, ValueError('Correct'), <traceback object at ...>)
(Pdb) continue
Nr2   r2   r   r   test_pdb_issue_gh_80731r     r4   r   c                     R# )aR  See GH-104301

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

>>> with PdbTestInput([
...     's',         # step to the print line
...     '! n = 42',  # disambiguated statement: reassign the name n
...     'n',         # advance the debugger into the print()
...     'continue'
... ]):
...     n = -1
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
...     print(f"The value of n is {n}")
> <doctest test.test_pdb.test_pdb_ambiguous_statements[0]>(8)<module>()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) s
> <doctest test.test_pdb.test_pdb_ambiguous_statements[0]>(9)<module>()
-> print(f"The value of n is {n}")
(Pdb) ! n = 42
(Pdb) n
The value of n is 42
> <doctest test.test_pdb.test_pdb_ambiguous_statements[0]>(1)<module>()
-> with PdbTestInput([
(Pdb) continue
Nr2   r2   r   r   test_pdb_ambiguous_statementsr     r4   r   c                     R# )aq  GH-80675

pdb should work even if f_trace_lines is set to False on some frames.

>>> def test_function():
...     import sys
...     frame = sys._getframe()
...     frame.f_trace_lines = False
...     import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
...     if frame.f_trace_lines != False:
...         print("f_trace_lines is not reset after continue!")

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'continue'
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_f_trace_lines[0]>(5)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
Nr2   r2   r   r   test_pdb_f_trace_linesr     r4   r   c                     R# )a  
pdb should not leak reference to frames

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

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

>>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
...     'continue',
...     'next',
...     'continue',
...     'return',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(4)frame_leaker()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) continue
1
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(4)frame_leaker()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) next
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()
-> pass
(Pdb) continue
1
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(4)frame_leaker()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) return
--Return--
> <doctest test.test_pdb.test_pdb_frame_refleak[0]>(5)frame_leaker()->None
-> pass
(Pdb) continue
1
Nr2   r2   r   r   test_pdb_frame_refleakr     r4   r   c                     R# )a  Testing the line number of break on function

>>> def foo(): pass

>>> def bar():
...
...     pass

>>> def boo():
...     # comments
...     global x
...     x = 1

>>> def gen():
...     yield 42

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

>>> with PdbTestInput([  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
...     'break foo',
...     'break bar',
...     'break boo',
...     'break gen',
...     'continue'
... ]):
...     test_function()
> <doctest test.test_pdb.test_pdb_function_break[4]>(2)test_function()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) break foo
Breakpoint ... at <doctest test.test_pdb.test_pdb_function_break[0]>:1
(Pdb) break bar
Breakpoint ... at <doctest test.test_pdb.test_pdb_function_break[1]>:3
(Pdb) break boo
Breakpoint ... at <doctest test.test_pdb.test_pdb_function_break[2]>:4
(Pdb) break gen
Breakpoint ... at <doctest test.test_pdb.test_pdb_function_break[3]>:2
(Pdb) continue
Nr2   r2   r   r   test_pdb_function_breakr     r4   r   c                     R# )aa  See GH-65052

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

>>> def test_function():
...     A()
>>> with PdbTestInput([  # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
...     's',
...     's',
...     'retval',
...     'continue',
...     'args',
...     'display self',
...     'display',
...     'continue',
... ]):
...    test_function()
> <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(3)__new__()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) s
> <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(4)__new__()
-> return object.__new__(cls)
(Pdb) s
--Return--
> <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(4)__new__()-><A instance at ...>
-> return object.__new__(cls)
(Pdb) retval
*** repr(retval) failed: AttributeError: 'A' object has no attribute 'a' ***
(Pdb) continue
> <doctest test.test_pdb.test_pdb_issue_gh_65052[0]>(6)__init__()
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
(Pdb) args
self = *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' ***
(Pdb) display self
display self: *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' ***
(Pdb) display
Currently displaying:
self: *** repr(self) failed: AttributeError: 'A' object has no attribute 'a' ***
(Pdb) continue
Nr2   r2   r   r   test_pdb_issue_gh_65052r   G  r4   r   c                     a  ] tR tRt o R t]P                  ! ]P                  P                  R4      RAR l4       t
RBR ltR tR tR	 tR
 tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR tR t R t!R t"R t#R t$R  t%R! t&R" t'R# t(R$ t)R% t*R& t+R' t,R( t-R) t.R* t/R+ t0R, t1R- t2R. t3R/ t4R0 t5R1 t6R2 t7R3 t8R4 t9R5 t:R6 t;]<Pz                  R7 4       t>R8 t?R9 t@R: tAR; tBR< tCR= tDR> tER? tFR@tGV tHR# )CPdbTestCasei{  c                N    \         P                  ! \         P                  4       R # r   r	   unlinkTESTFNr    s   &r   tearDownPdbTestCase.tearDown~      ))*r   'PYTHONSAFEPATH changes default sys.pathNc           	        V P                  \        P                  R 4       \        P                  RR.V,           pVe   \
        P                  V,          pM\
        P                  p\        P                  ! V\        P                  \        P                  \        P                  / VCRR/CR7      ;_uu_ 4       pVP                  \        P                  V4      4      w  rRRR4       \        X\        4      '       d   \        P                  V4      MTp\        X	\        4      '       d   \        P                  V	4      MT	p	V P!                  XP"                  VRV RV	 24       W3#   + '       g   i     L; i)	__pycache__-mr   NPYTHONIOENCODINGutf-8stdoutr   stderrenvUnexpected return code
stdout: 	
stderr: )
addCleanupr	   rmtreer   
executableosenviron
subprocessPopenPIPEcommunicatestrencode
isinstancebytesdecodeassertEqual
returncode)
r   pdb_argscommandsexpected_returncode	extra_envcmdr   procr   r   s
   &&&&&     r   _run_pdbPdbTestCase._run_pdb  s!   
 		((-8~~tU+h6 **y(C**C! oo!::0':
 
 !--cjj.BCNF
 *4FE)B)Bf%)3FE)B)Bf%OO.vhjI	

 ~
 
s   :'E))E9	c                   Rp\        VR4      ;_uu_ 4       p	V	P                  \        P                  ! V4      4       RRR4       Vec   \        RR4      ;_uu_ 4       p	V	P                  \        P                  ! V4      4       RRR4       V P	                  \
        P                  R4       V P	                  \
        P                  V4       \
        P                  ! 4       ;_uu_ 4       p
V'       d   V
P                  R4       Vf   . pV P                  V.V,           W#V4      w  rRRR4       W3#   + '       g   i     L; i  + '       g   i     L; i  + '       g   i     XX3# ; i)z3Run 'script' lines with pdb and the pdb 'commands'.main.pywN.pdbrcHOME)
openwritetextwrapdedentr   r	   r   EnvironmentVarGuardunsetr   )r   scriptr   r   r   script_argspdbrcremove_homefilenamefr   r   r   s   &&&&&&&&     r   run_pdb_scriptPdbTestCase.run_pdb_script  s    (C  AGGHOOF+, ! h$$./ %OOI,,h7	(((3**,,		&!" !]]H:+CXdmnNF - ~ !  %$
 -, v~s#   &D0&E(=E0E 	E	E)	c                x   RV n         \        P                  ! V P                   4       V P                   R,           pV P                   R,           p\        P                  ! V P                   4       \        VR4      ;_uu_ 4       p RRR4       \        VR4      ;_uu_ 4       pVP                  \        P                  ! V4      4       RRR4       V P                  \        P                  V P                   4       V P                  RV P                   .V4      #   + '       g   i     L; i  + '       g   i     Lk; i)z(Runs the script code as part of a modulet_main/__main__.py/__init__.pyr   Nr   )module_namer	   r   r   mkdirr  r  r  r  r   r   )r   r  r   	main_file	init_filer  s   &&&   r   run_pdb_modulePdbTestCase.run_pdb_module  s    #))*$$~5	$$~5	
!!")S!!Q ")S!!QGGHOOF+, "	(($*:*:;}}dD$4$45x@@ "!!!s   D &D)D&	)D9	c                d   \        \        P                  R 4      ;_uu_ 4       pVP                  V4       RRR4       V'       g   RM V^ ,          \        P                  V^,          3pV P	                  V\
        P                  ! V\        P                  4      4       R#   + '       g   i     Lr; i)wbN)r  r	   r   r  r   r   find_function)r   file_content	func_nameexpectedr  s   &&&& r   _assert_find_function!PdbTestCase._assert_find_function  s{    )""D))QGGL! *  (4QK))8A;.8c''	93C3CD	F *)s   BB/	c                ,    V P                  R RR4       R# )r   fooN)r  r    s   &r   test_find_function_empty_file)PdbTestCase.test_find_function_empty_file  s    ""3t4r   c                H    V P                  R P                  4       RR4       R# )u@   def foo():
    pass

def bœr():
    pass

def quux():
    pass
   bœrN)r&     r  r   r    s   &r   test_find_function_found$PdbTestCase.test_find_function_found  s$    ""	 FH	
r   c                J    V P                  R P                  R4      RR4       R# )uV   # coding: iso-8859-15
def foo():
    pass

def bœr():
    pass

def quux():
    pass
ziso-8859-15r&  N)r&     r(  r    s   &r   -test_find_function_found_with_encoding_cookie9PdbTestCase.test_find_function_found_with_encoding_cookie  s'    ""
 F=	
r   c                r    V P                  \        P                  R P                  4       ,           RR4       R# )u   def bœr():
    pass
r&  N)r&     )r  codecsBOM_UTF8r   r    s   &r   !test_find_function_found_with_bom-PdbTestCase.test_find_function_found_with_bom  s2    ""OO  FH 	
r   c                X    R pRpV P                  W4      w  r4V P                  RV4       R# )zJ
            import __main__
            print(__main__.__spec__)
        continueNoneNr  assertInr   r  r   r   _s   &    r   	test_specPdbTestCase.test_spec  s0    
 ''9	ff%r   c                    \         P                  ! R 4      P                  4       pV P                  VRR4       V P                  VRR4       V P                  VRR4       V P                  VRR	4       R# )
a              def foo(): pass

            def bar():
                pass  # line 4

            def baz():
                # comment
                pass  # line 8

            def mul():
                # code on multiple lines
                code = compile(   # line 12
                    'def f()',
                    '<string>',
                    'exec',
                )
        r"  barbazmulN)r"     )r?     )r@     )rA     )r  r  r   r  )r   codes   & r   (test_find_function_first_executable_line4PdbTestCase.test_find_function_first_executable_line  sk       " VX# 	& 	""4
;""4
;""4
;""4<r   c                   \        \        P                  R 4      ;_uu_ 4       pVP                  R4       RRR4       \        P
                  RR\        P                  .p\        P                  ! V\        P                  \        P                  \        P                  R7      pV P                  VP                  P                  4       VP                  R4      w  rEV P                  RVR4       R#   + '       g   i     L; i)	r  s   print("testing my pdb")
Nr   r   )r   r   r   s   quit
s   SyntaxErrorz0Got a syntax error running test script under PDB)r  r	   r   r  r   r   r   r   r   r   r   closer   assertNotInr   r  r   r   r   r   s   &     r   test_issue7964PdbTestCase.test_issue7964   s    )""D))QGG23 *~~tUI,<,<=??//??
 	))*)))4K	M *)s   C00D 	c                    R pRpV P                  W4      w  r4T;'       g    RT;'       g    R,           pV P                  RVR4       V P                  RVR4       R# )z
            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 errorN)r  rK  r9  )r   r  r   r   r   outputs   &     r   test_issue46434PdbTestCase.test_issue46434/  sg     ,,V>,,B6<<R0)6^	`SU[T	Vr   c                   R pRpRp\        RR4      ;_uu_ 4       pVP                  \        P                  ! V4      4       RRR4       V P	                  \
        P                  R4       V P                  W4      w  rVT P                  \        ;QJ d*    R VP                  4        4       F  '       g   K   RM	  RM! R VP                  4        4       4      R	4       R#   + '       g   i     L; i)
z
            from bar import bar

            def foo():
                bar()

            def nope():
                pass

            def foobar():
                foo()
                nope()

            foobar()
        z
            from bar import bar
            break bar
            continue
            step
            step
            quit
        z5
            def bar():
                pass
        bar.pyr   Nc              3   ,   "   T F
  pR V9   x  K  	  R# 5i)zmain.py(5)foo()->NoneNr2   .0ls   & r   	<genexpr>.PdbTestCase.test_issue13183.<locals>.<genexpr>e  s     J6I'1,6I   TFz+Fail to step into the caller after a return)r  r  r  r  r   r	   r   r  
assertTrueany
splitlines)r   r  r   r?  r  r   r   s   &      r   test_issue13183PdbTestCase.test_issue13183D  s     (C  AGGHOOC() !	(((3,,V>CJf6G6G6IJCCCJf6G6G6IJJ9	;	 ! s   &CC.	c           	     t   \        \        P                  R 4      ;_uu_ 4       pVP                  \        P
                  ! R4      P                  R4      4       RRR4       \        P                  R\        P                  .p\        P                  ! V\        P                  \        P                  \        P                  / \        P                  CRR/CR7      pV P                  VP                  P                   4       VP#                  R4      w  rEV P%                  R	VR
4       R#   + '       g   i     L; i)r  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()asciiN-ur   r   r   s   cont
   Error*Got an error running test script under PDBr  r	   r   r  r  r  r   r   r   r   r   r   r   r   r   r   rJ  r   rK  rL  s   &     r   test_issue13120PdbTestCase.test_issue13120h  s     )""D))QGGHOO 
% 
 %fWo
/ * ~~tY%5%56??//??;2::;17;	 	))*)))46E	G+ *)   5D''D7	c           	     t   \        \        P                  R 4      ;_uu_ 4       pVP                  \        P
                  ! R4      P                  R4      4       RRR4       \        P                  R\        P                  .p\        P                  ! V\        P                  \        P                  \        P                  / \        P                  CRR/CR7      pV P                  VP                  P                   4       VP#                  R4      w  rEV P%                  R	VR
4       R#   + '       g   i     L; i)r  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()rd  Nre  r   r   r   s
   cont
cont
rf  rg  rh  rL  s   &     r   test_issue36250PdbTestCase.test_issue36250  s    )""D))QGGHOO %  $VG_. *  ~~tY%5%56??//??=RZZ=!3W=	 	))*))/:6E	G3 *)rk  c                z    R pRpRpV P                  W4      w  rEV P                  W5RP                  W54      4       R# )zdef f: pass
rP  zSyntaxError:zE

Expected:
{}
Got:
{}
Fail to handle a syntax error in the debuggee.N)r  r9  format)r   r  r   r  r   r   s   &     r   test_issue16180PdbTestCase.test_issue16180  sE     !,,
 	h=VH%	'r   c                    R pRpV P                  W4      w  r4V P                  VP                  R4      ^4       V P                  VP                  R4      ^4       R# )z!import ast; ast.literal_eval('')
zA
            continue
            where
            quit
        zast.literal_eval('')N)r  r   countr   r  r   r   r   s   &    r   test_issue84583PdbTestCase.test_issue84583  sX    5
 ,,V>
 	&<=qA&<=qAr   c                    R pRpV P                  W4      w  r4RP                  VP                  4        Uu. uF  qUP                  4       NK  	  up4      pV P	                  VR4       V P	                  VR4       R# u upi )zprint('hello')z[
            continue
            run a b c
            run d e f
            quit
        
z#Restarting .* with arguments:
a b cz#Restarting .* with arguments:
d e fN)r  joinr`  stripassertRegex)r   r  r   r   r   xress   &      r   test_issue26053PdbTestCase.test_issue26053  sv    ! ,,V>iiF,=,=,?@,?q,?@ADEDE As   A:c                   R pRpRp\        RR4      ;_uu_ 4       pVP                  \        P                  ! V4      4       RRR4       V P	                  \
        P                  R4       V P                  W4      w  rVVP                  4       pV P                  RV4       V P                  RV4       R#   + '       g   i     Ly; i)z~
            import bar
            def foo():
                ret = bar.bar()
                pass
            foo()
        zv
            b bar.bar
            c
            b main.py:5
            c
            p ret
            quit
        z:
            def bar():
                return 42
        rV  r   N-> passz(Pdb) 42)
r  r  r  r  r   r	   r   r  r`  r9  )r   r  r   r?  r  r   r   liness   &       r   test_issue58956PdbTestCase.test_issue58956  s     (C  AGGHOOC() !	(((3,,V>!!#i'j%( ! s   &B22C	c                |    R pRpV P                  W4      w  r4V P                  RV4       V P                  RV4       R# )zx = 1zM
            step
            step
            step
            quit
        zThe program finishedzbdb.pyNr  r9  rK  r:  s   &    r   test_step_into_botframe#PdbTestCase.test_step_into_botframe  sC      ''9	,f56*r   c                    \         P                  ! R 4      p\         P                  ! R4      pV P                  VRVRR7      w  r4V P                  RV4       V P	                  RV4       V P	                  RV4       R# )	z-
            a = 1
            b = 2
        zU
            # Comments should be fine
            n
            p f"{a+8=}"
        q
Tr	  r
  SyntaxErrorza+8=9-> b = 2N)r  r  r  rK  r9  r   r  r	  r   r   s   &    r   test_pdbrc_basicPdbTestCase.test_pdbrc_basic  st     " 
  !  ,,VU%UY,Z/gv&j&)r   c                    \         P                  ! R4      p\         P                  ! R4      pV P                  VRVRR7      w  r4V P                  RV4       V P	                  RV4       R# )	z,Test that empty lines in .pdbrc are ignored.z?
            a = 1
            b = 2
            c = 3
        z
            n

        r  Tr  zb = 2zc = 3N)r  r  r  r9  rK  r  s   &    r   test_pdbrc_empty_line!PdbTestCase.test_pdbrc_empty_line
  sh      "   ! 
 ,,VU%UY,Zgv&&)r   c                    \         P                  ! R 4      p\         P                  ! R4      pV P                  VRVRR7      w  r4V P                  RV4       R# )
            class A:
                def __init__(self):
                    self.attr = 1
            a = A()
            b = 2
        z
            alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")
            until 6
            pi a
        r  Tr  z
a.attr = 1Nr  r  r  r9  r  s   &    r   test_pdbrc_aliasPdbTestCase.test_pdbrc_alias  sV     "   !  ,,VU%UY,ZlF+r   c                    \         P                  ! R 4      p\         P                  ! R4      pV P                  VRVRR7      w  r4V P                  RV4       R# )r  z
            b 5;;c;;n
        r  Tr  r  Nr  r  s   &    r   test_pdbrc_semicolon PdbTestCase.test_pdbrc_semicolon.  sV     "   !  ,,VU%UY,Zj&)r   c                    \         P                  ! R 4      p\         P                  ! R4      pV P                  VRVRR7      w  r4V P                  RV4       R# )r  zK
            b 6
            commands 1 ;; p a;; end
            c
        r  Tr  z<__main__.A object atNr  r  s   &    r   test_pdbrc_commandsPdbTestCase.test_pdbrc_commands>  sW     "   !  ,,VU%UY,Z-v6r   c                    \         P                  ! R 4      pV P                  VRRRR7      w  r#V P                  RV4       R# )z$
            print('hello')
        r  invalidTr  z(NameError: name 'invalid' is not definedNr  )r   r  r   r   s   &   r   test_readrc_kwargPdbTestCase.test_readrc_kwargP  sB     "  ,,VU)Y],^@&Ir   c                   \         P                  ! 4       ;_uu_ 4       pVP                  R 4       \         P                  ! 4       ;_uu_ 4       p\	        R4      ;_uu_ 4        \
        P                  P                  VR4      pV\
        P                  P                  n	        \        VR4      ;_uu_ 4       pVP                  R4       RRR4       V P                  \        P                  ! 4       P                  ^ ,          R4       RRR4       RRR4       RRR4       R#   + '       g   i     L`; i  + '       g   i     L5; i  + '       g   i     L@; i  + '       g   i     R# ; i)r   zos.path.expanduserr   r   r  N)r	   r  r  temp_dirr   r   pathrz  
expanduserreturn_valuer  r  r   r   r   rcLines)r   r   r  rc_pathr  s   &    r   test_readrc_homedirPdbTestCase.test_readrc_homedirX  s    **,,IIf##%%59M3N3N'',,x:29""/'3''1GGI& (  !2!21!5yA 4O% -,
 (' 4O3N%% -,,sT   /EE	!AD25D>D2E	ED/*D22E=E	EEE)	c                   \        4       pR p\        4       ;_uu_ 4       pVP                  \        RV4      4       VP                  \        P                  ! \
        P                  R4      4       R\
        P                  n        \
        P                  ! VR7       RRR4       V P                  VP                  4       VR,           4       R#   + '       g   i     L9; i)z"Nobody expects... blah, blah, blahz
sys.stdout	set_traceN)headerry  )r   r   enter_contextr   objectr   r   _last_pdb_instancer  r   getvalue)r   r   r  	resourcess   &   r   test_headerPdbTestCase.test_headerb  s    5[[I##E,$?@##ELL+$FG *.CGG&MM(  	*FTM: [s   A<CC	c                    R pRpV P                  W4      w  r4T P                  \        ;QJ d*    R VP                  4        4       F  '       g   K   RM	  RM! R VP                  4        4       4      V4       R# )zprint("SUCCESS")/
            continue
            quit
        c              3   ,   "   T F
  pR V9   x  K  	  R# 5iSUCCESSNr2   rX  s   & r   r[  .PdbTestCase.test_run_module.<locals>.<genexpr>w       H4GqIN4Gr]  TFNr  r^  r_  r`  ru  s   &    r   test_run_modulePdbTestCase.test_run_modulep  s]    ' ,,V>HF4E4E4GHHF4E4E4GHH&Qr   c                    R pRpV P                  W4      w  r4T P                  \        ;QJ d*    R VP                  4        4       F  '       g   K   RM	  RM! R VP                  4        4       4      V4       R# )zQ
            if __name__ == '__main__':
                print("SUCCESS")
        r  c              3   ,   "   T F
  pR V9   x  K  	  R# 5ir  r2   rX  s   & r   r[  9PdbTestCase.test_module_is_run_as_main.<locals>.<genexpr>  r  r]  TFNr  ru  s   &    r   test_module_is_run_as_main&PdbTestCase.test_module_is_run_as_mainy  s_     ,,V>HF4E4E4GHHF4E4E4GHH&Qr   c                    R pV P                  RR.V^R7       V P                  . ROV4      w  r#V P                  RV4       V P                  . ROV4      w  r#V P                  RV4       R# )z
            continue
        calendarr   r   DecemberN)r   r  1)r   r  z--typetext)r   r9  r   r   r   r;  s   &   r   test_run_module_with_args%PdbTestCase.test_run_module_with_args  sd     	z4((JMM"98D	j&)MM"FQ	j&)r   c                `    R pRpV P                  WRR.R7      w  r4V P                  RV4       R# )z@
            import sys
            print(sys.argv[1:])
        r  z--barr"  )r  z['--bar', 'foo']Nr8  ru  s   &    r   test_run_script_with_args%PdbTestCase.test_run_script_with_args  s>    
 ,,VGUZK[,\(&1r   c                   R pRpV P                  W4      w  r4T P                  \        ;QJ d*    R VP                  4        4       F  '       g   K   RM	  RM! R VP                  4        4       4      V4       T P                  \        ;QJ d*    R VP                  4        4       F  '       d   K   RM	  RM! R VP                  4        4       4      V4       R# )z{
            if __name__ == '__main__':
                pass
                print("SUCCESS")
                pass
        z*
            b 3
            quit
        c              3   ,   "   T F
  pR V9   x  K  	  R# 5i)zBreakpoint 1 atNr2   rX  s   & r   r[  .PdbTestCase.test_breakpoint.<locals>.<genexpr>       P<Oq-2<Or]  TFc              3   ,   "   T F
  pR V9  x  K  	  R# 5ir  r2   rX  s   & r   r[  r    s     L8K1IQ.8Kr]  N)r  r^  r_  r`  allru  s   &    r   test_breakpointPdbTestCase.test_breakpoint  s     ,,V>PF<M<M<OPPF<M<M<OPPRXYL8I8I8KLL8I8I8KLLfUr   c                    R pV P                  RR.V4      w  r#V P                  \        P                  VP	                  RR4      4       R# )z(
            c
            quit
        r   r   rP  N)r   r9  r   _usagereplace)r   r   r   r   s   &   r   test_run_pdb_with_pdb!PdbTestCase.test_run_pdb_with_pdb  sB     e}h?JJNN4$	
r   c                j   R p\         P                  ! V4       VR,           p\        P                  ! V4       \	        VR4      ;_uu_ 4         RRR4       V P                  \         P                  V4       V P                  RV.R^R7      w  r4V P                  RV4       R#   + '       g   i     L\; i)r  r  r   Nr   rP  r  z-ImportError: No module named t_main.__main__;)r	   r   r   r  r  r   r   r9  )r   r  r  r   r   s   &    r   test_module_without_a_main&PdbTestCase.test_module_without_a_main  s    %.0	
)S!! "	((+6; ' 
 	EvN "!s   B""B2	c                   R pRp\         P                  ! V4       VR,           V,           p\        P                  ! V4       \	        VR,           R4      ;_uu_ 4         RRR4       V P                  \         P                  V4       V P                  RVP                  RR4      .R^R	7      w  rEV P                  R
V4       R#   + '       g   i     Ll; i)t_pkgr  /r  r   Nr   .rP  r  z;'t_pkg.t_main' is a package and cannot be directly executed)	r	   r   r   makedirsr  r   r   r  r9  )r   pkg_namer  modpathr   r   s   &     r   test_package_without_a_main'PdbTestCase.test_package_without_a_main  s    "S.;.
G'N*C00 1	(((37??3,-rq ' 
 	I	 10s   CC	c                   \         P                  P                  \        P                  4      '       d   Q hV P                  R \        P                  .R^R7      w  rV P                  R\        P                   2V4       R# )r   rP  r  zImportError: No module named N)r   r  existsr	   r   r   r9  r   r   r   s   &  r   test_nonexistent_module#PdbTestCase.test_nonexistent_module  s`    77>>)"2"23333i.>.>'?YZ[5i6F6F5GH&Qr   c                    \         P                  ! 4       ;_uu_ 4       pV P                  V.R ^R7      w  r#V P                  RV R2V4       RRR4       R#   + '       g   i     R# ; i)rP  r  zError: z is a directoryN)r	   r  r   r9  )r   r  r   r   s   &   r   test_dir_as_scriptPdbTestCase.test_dir_as_script  sQ    !!X!]]H:rq]QNFMMGH:_=vF "!!!s   .AA'	c                   V P                  R .R^R7      w  rV P                  RVP                  R4      ^,          4       V P                  . ROR^R7      w  rV P                  RVP                  R4      ^,          4       R# )z-crP  r  z8pdb: error: argument -c/--command: expected one argumentry  z*pdb: error: unrecognized arguments: --spamN)z--spamr   r   )r   r9  splitr  s   &  r   test_invalid_cmd_line_options)PdbTestCase.test_invalid_cmd_line_options  ss    vrqIPSYS_S_`dSefgShi'>XYZBV\\RVEWXYEZ[r   c                    R pRpV P                  W4      w  r4T P                  \        ;QJ d*    R VP                  4        4       F  '       g   K   RM	  RM! R VP                  4        4       4      V4       R# )zY
                #This is a comment, on line 2

                print("SUCCESS")
        z
            quit
        c              3   ,   "   T F
  pR V9   x  K  	  R# 5i)z__main__.py(4)<module>()Nr2   rX  s   & r   r[  =PdbTestCase.test_blocks_at_first_code_line.<locals>.<genexpr>  s      ?*=Q 7 !*=r]  TFNr  ru  s   &    r   test_blocks_at_first_code_line*PdbTestCase.test_blocks_at_first_code_line  so    
 ,,V> ?*0*;*;*=? ?*0*;*;*=? ?@F	Hr   c                |    R pRpV P                  W4      w  r4V P                  RV4       V P                  RV4       R# )$
            print("hello")
        z
            filename = $_frame.f_code.co_filename
            f = open(filename, "w")
            f.write("print('goodbye')")
            import time; time.sleep(1)
            f.close()
            ll
        WARNING:
was editedNr8  ru  s   &    r   "test_file_modified_after_execution.PdbTestCase.test_file_modified_after_execution  s@    
 ,,V>j&)lF+r   c                |    R pRpV P                  W4      w  r4V P                  RV4       V P                  RV4       R# )r  z
            filename = $_frame.f_code.co_filename
            f = open(filename, "w")
            f.write("print('goodbye')")
            import time; time.sleep(1)
            f.close()
            restart
        r  r   N)r  rK  ru  s   &    r   ,test_file_modified_and_immediately_restarted8PdbTestCase.test_file_modified_and_immediately_restarted  sD    
 ,,V>V,v.r   c           	     f   R pRpRp\        VR4      ;_uu_ 4       pVP                  \        P                  ! V4      4       RRR4       V P	                  \
        P                  V4       V P	                  \
        P                  R4       \        P                  V.p\        P                  ! V\        P                  \        P                  \        P                  / \        P                  CRR/CR7      ;_uu_ 4       pVP                  \         P#                  V4      4      w  rxRRR4       X;'       d    \$        P'                  V4      pV P)                  XP*                  ^ 4       V P-                  R	V4       V P-                  R
V4       R#   + '       g   i     ELT; i  + '       g   i     L; i)z
            import pdb; pdb.Pdb().set_trace()
            with open(__file__, "w") as f:
                f.write("print('goodbye')\n" * 5)
                import time; time.sleep(1)
            import pdb; pdb.Pdb().set_trace()
        z3
            continue
            continue
        r   r   Nr   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   r9  )	r   r  r   r  r  r   r   r   r;  s	   &        r   :test_file_modified_after_execution_with_multiple_instancesFPdbTestCase.test_file_modified_after_execution_with_multiple_instances  s9   
 (C  AGGHOOF+, !	(((3	((-8~~x(! oo!AA%7A
 
 ((H)=>IF
 00ELL0!,j&)lF+# !  

 
s   &F<'F F	 F0	c                    R pRpV P                  W4      w  r4V P                  RV4       V P                  RV4       V P                  RV4       R# )z
            import random
            # Any code with a source to step into so this script is not checked
            # for changes when it's being changed
            random.randint(1, 4)
            print("hello")
        aL  
            ll
            n
            s
            filename = $_frame.f_back.f_code.co_filename
            def change_file(content, filename):
                with open(filename, "w") as f:
                    f.write(f"print({content})")

            change_file('world', filename)
            restart
            ll
        helloworldr  Nr  ru  s   &    r   /test_file_modified_after_execution_with_restart;PdbTestCase.test_file_modified_after_execution_with_restart;  sR     ,,V>gv&gv& 	V,r   c                X    R pRpV P                  W4      w  r4V P                  RV4       R# )zZ
            def foo():
                raise ValueError("foo")
            foo()
        zX
            continue
            restart
            continue
            quit
        
RestartingNr8  ru  s   &    r   test_post_mortem_restart$PdbTestCase.test_post_mortem_restartZ  s2     ,,V>lF+r   c                   R V n         \        P                  ! V P                   4       V P                   R,           pV P                   R,           pV P                   R,           pV P                  \        P                  V P                   4       \        P
                  ! V P                   4       \        VR4      ;_uu_ 4       pVP                  \        P                  ! R4      4       RRR4       \        VR4      ;_uu_ 4       pVP                  \        P                  ! R4      4       RRR4       \        VR4      ;_uu_ 4       pVP                  \        P                  ! R4      4       RRR4       R	pV P                  R
V P                   .V4      w  rgT P                  \        ;QJ d*    R VP                  4        4       F  '       g   K   RM	  RM! R VP                  4        4       4      V4       T P                  \        ;QJ d*    R VP                  4        4       F  '       g   K   RM	  RM! R VP                  4        4       4      4       T P                  \        ;QJ d6    R VP                  4        4       F  '       g   K   R4       R# 	  R4       R# ! R VP                  4        4       4      4       R#   + '       g   i     EL; i  + '       g   i     EL; i  + '       g   i     EL; i)r  r  r  
/module.pyr   6
                top_var = "VAR from top"
            Nz
                from . import top_var
                from .module import var
                from . import module
                pass # We'll stop here and print the vars
            zY
                var = "VAR from module"
                var2 = "second var"
            zz
            b 5
            c
            p top_var
            p var
            p module.var2
            quit
        r   c              3   ,   "   T F
  pR V9   x  K  	  R# 5izVAR from moduleNr2   rX  s   & r   r[  4PdbTestCase.test_relative_imports.<locals>.<genexpr>  r  r]  TFc              3   ,   "   T F
  pR V9   x  K  	  R# 5i)zVAR from topNr2   rX  s   & r   r[  r    s     M9LANa/9Lr]  c              3   ,   "   T F
  pR V9   x  K  	  R# 5i)z
second varNr2   rX  s   & r   r[  r    s     K7J!LA-7Jr]  r  r	   r   r   r   r  r  r  r  r  r   r^  r_  r`  r   r  r  module_filer  r   r   r;  s   &       r   test_relative_imports!PdbTestCase.test_relative_importsk  s   #))*$$~5	$$~5	&&5	(($*:*:;
!!")S!!QGGHOO %   " )S!!QGGHOO %   " +s##qGGHOO %   $
 MM4)9)9":HE	PF<M<M<OPPF<M<M<OPPRXYM9J9J9LMM9J9J9LMMNKv7H7H7JKLLKv7H7H7JKKL7 "!! "!! $##s$   ?&J?&K&K'?K	K$	'K8	c                l   R V n         \        P                  ! V P                   4       V P                   R,           pV P                   R,           pV P                   R,           pV P                  \        P                  V P                   4       \        P
                  ! V P                   4       \        VR4      ;_uu_ 4       pVP                  \        P                  ! R4      4       RRR4       \        VR4      ;_uu_ 4       pVP                  \        P                  ! R4      4       RRR4       \        VR4      ;_uu_ 4       pVP                  \        P                  ! R4      4       RRR4       R	pV P                  R
V P                   R,           .V4      w  rgT P                  \        ;QJ d*    R VP                  4        4       F  '       g   K   RM	  RM! R VP                  4        4       4      V4       R#   + '       g   i     EL ; i  + '       g   i     L; i  + '       g   i     L; i)r  z	/runme.pyr  r  r   r  Nzl
                from . import module
                pass # We'll stop here and print the vars
            z5
                var = "VAR from module"
            zQ
            b 3
            c
            p module.var
            quit
        r   z.runmec              3   ,   "   T F
  pR V9   x  K  	  R# 5ir  r2   rX  s   & r   r[  DPdbTestCase.test_relative_imports_on_plain_module.<locals>.<genexpr>  r  r]  TFr  r  s   &       r   %test_relative_imports_on_plain_module1PdbTestCase.test_relative_imports_on_plain_module  s   #))*$${2	$$~5	&&5	(($*:*:;
!!")S!!QGGHOO %   " )S!!QGGHOO %   "
 +s##qGGHOO %   $ MM4)9)9H)D"ExP	PF<M<M<OPPF<M<M<OPPRXY) "!! "!
 $#s$   ?&G<&H&H#<H	H 	#H3	c                    R P                  . RO4      pV P                  RVR ,           4      w  r#V P                  VP                  4       R,          . RO4       R# )ry  passrB  NNN)zprint(]zdebug print(zdebug doesnotexistc)
r  zU(Pdb) *** SyntaxError: closing parenthesis ']' does not match opening parenthesis '('!(Pdb) ENTERING RECURSIVE DEBUGGERz%*** SyntaxError: '(' was never closedLEAVING RECURSIVE DEBUGGERr(  z> <string>(1)<module>()z9((Pdb)) *** NameError: name 'doesnotexist' is not definedr)  (Pdb) rz  r  r   r`  r  s   &   r   test_errors_in_command"PdbTestCase.test_errors_in_command  sR    99 
  ''4@	**,R0 3
 	r   c                8   a  V 3R lpV! RR4       V! RR4       R# )z.do_run handles exceptions from parsing its argc                    < R P                  RV  2R.4      pSP                  RVR ,           4      w  r4SP                  VP                  4       R,          RRV  RV 2R.4       R	# )
ry  zrun qr%  r&  r  z(Pdb) *** Cannot run z: r*  Nr+  )bad_argmsgr   r   r;  r   s   &&   r   check*PdbTestCase.test_issue34266.<locals>.check  sv    yywi " H ++FHtODIFV..04'y3%87 r   \zNo escaped character"zNo closing quotationNr2   )r   r3  s   f r   test_issue34266PdbTestCase.test_issue34266  s     
	 	d*+c)*r   c                   \         P                  ! R4      pRp\        P                  ! 4       ;_uu_ 4       pR\        P
                  P                  V4       2pV P                  W4      w  rVV P                  VP                  R4      ^,          P                  R4      V4       RRR4       R#   + '       g   i     R# ; i)zkWhen running `python foo.py` sys.path[0] is an absolute path. `python -m pdb foo.py` should behave the sameQ
            import sys
            print('sys.path[0] is', sys.path[0])
        c
q(Pdb) sys.path[0] is ry  r  N)r  r  r	   temp_cwdr   r  realpathr  r   r  rstrip)r   r  r   cwdr  r   r   s   &      r   test_issue42384PdbTestCase.test_issue42384  s     "  !!S.rww/?/?/D.EFH!00BNFV\\$/299$?J "!!!s   A-B--B>	c           	        \         P                  ! R4      pRp\        P                  ! 4       ;_uu_ 4       p\        P
                  P                  V4      p\        P
                  P                  VR4      p\        P
                  P                  VR4      pRV 2p\        P                  ! V4       \        \        P
                  P                  VR4      R4      ;_uu_ 4       pVP                  V4       RRR4       \        P                  ! V4       \        P                  ! \        P
                  P                  VR4      \        P
                  P                  VR4      4       V P                  \        P
                  P                  RR4      .V4      w  rV P                  VP                  R	4      ^,          P                  R
4      V4       RRR4       R#   + '       g   i     L; i  + '       g   i     R# ; i)ziWhen running `python foo.py` sys.path[0] resolves symlinks. `python -m pdb foo.py` should behave the samer:  r;  dir_onedir_twor<  foo.pyr   Nry  r  )r  r  r	   r=  r   r  r>  rz  r  r  r  symlinkr   r   r  r?  )
r   r  r   r@  rD  rE  r  r  r   r   s
   &         r   test_issue42384_symlink#PdbTestCase.test_issue42384_symlink  sT     "  !!S''""3'Cggll3	2Gggll3	2G.wi8HHHWbggll7H5s;;q <HHWJJrww||GX6Wh8WX!]]BGGLLH,M+NPXYNFV\\$/299$?J "! <; "!!s%   B-G-#G	5CG-G*%G--G>	c                >   \         P                  ! R4      pRp\        P                  ! 4       ;_uu_ 4       pV P	                  WRR/R7      w  rER\
        P                  P                  V4       2pV P                  Wd4       RRR4       R#   + '       g   i     R# ; i)z5With safe_path set, pdb should not mangle sys.path[0]zk
            import sys
            import random
            print('sys.path[0] is', sys.path[0])
        zc
PYTHONSAFEPATHr  )r   zsys.path[0] is N)	r  r  r	   r=  r  r   r  r>  rK  )r   r  r   r@  r   r;  
unexpecteds   &      r   test_safe_pathPdbTestCase.test_safe_path   s      " 
  !!S++FIY[^H_+`IF*277+;+;C+@*ABJZ0	 "!!!s   ABB	c           	     \   \         P                  ! 4       ;_uu_ 4       p\        R R4      ;_uu_ 4       p\        P                  ! R4      pVP                  V4       RRR4       \        P                  P                  VR4      p\        P                  ! V4       \        P                  ! \        P                  P                  VR4      4       \        P                  P                  VR 4      p\        VR4      ;_uu_ 4       pVP                  R4       RRR4       V P                  R .R4      w  rgRpV P                  VP                  R4      ^,          P                  R	4      V4       RRR4       R#   + '       g   i     EL!; i  + '       g   i     L|; i  + '       g   i     R# ; i)
rF  r   z
                    print('The correct file was executed')

                    import os
                    os.chdir("subdir")
                Nsubdirz$print("The wrong file was executed")zc
c
qz#(Pdb) The correct file was executedry  r  )r	   r=  r  r  r  r  r   r  rz  r  r   r   r  r?  )	r   r@  r  srP  
wrong_filer   r   r  s	   &        r   test_issue42383PdbTestCase.test_issue42383  s$   !!Sh$$OO %  
 % WW\\#x0FHHVHHRWW\\&(34fh7Jj#&&!>? ' "]]H:yANF<HV\\$/299$?J) "!$$$ '& "!!s<   F(E3	B&FF	AF3F>	FFFF+	c                ~    R p\         P                  ! R4      pV P                  W4      w  r4V P                  V4       R# )z            def func():
                def inner(v): pass
                inner(
                    42
                )
            func()
        zj
            break func
            continue
            next
            next
            jump 2
        N)r  r  r  assertFalseru  s   &    r   test_gh_94215_crashPdbTestCase.test_gh_94215_crash(  s@     ?? $  ,,V> r   c                   R pRpRpRp\        RR4      ;_uu_ 4       pVP                  \        P                  ! V4      4       RRR4       \        RR4      ;_uu_ 4       pVP                  \        P                  ! V4      4       RRR4       V P	                  \
        P                  R4       V P	                  \
        P                  R4       W43 FQ  pV P                  R.V4      w  rxV P                  RVR	4       V P                  R
VR4       V P                  RVR4       KS  	  R#   + '       g   i     L; i  + '       g   i     L; i)za
        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()
        zz
            break 20
            continue
            step
            break 4
            list
            quit
        z~
            break 20
            continue
            step
            break 4
            longlist
            quit
        z
gh93696.pyr   Nzgh93696_host.pyz"x = "Sentinel string for gh-93696"zSentinel statement not foundz4 Bzbreakpoint not foundz-> def func():zstack entry not found)	r  r  r  r  r   r	   r   r   r9  )	r   
frozen_srchost_programcommands_listcommands_longlistr  r   r   r;  s	   &        r   test_gh_93696_frozen_list%PdbTestCase.test_gh_93696_frozen_list;  s   

* ,$$GGHOOJ/0 % #S))QGGHOOL12 * 		((,7	((*;< ':H'8&98DIFMM>HfgMM%)?@MM*F4KL	 ; %$ *)s   &D'&D:'D7	:E
	c                    R pRpV P                  W4      w  r4V P                  RV4       V P                  W4      w  r4V P                  RV4       R# )rP  r  z
main.py(0)z__main__.py(0)N)r  r9  r  r:  s   &    r   test_empty_filePdbTestCase.test_empty_filew  sO     ''9	lF+''9	&/r   c                T   \         P                  P                  \         P                  P                  \        4      R 4      p\         P
                  ! V4       FL  pVP                  R4      '       g   K  V P                  \         P                  P                  W4      .R4       KN  	  R# )encoded_modulesz.pyr0  N)r   r  rz  dirname__file__listdirendswithr   )r   
script_dirr  s   &  r   test_non_utf8_encoding"PdbTestCase.test_non_utf8_encoding  sf    WW\\"''//(";=NO


:.H  ''rww||JABCH /r   c           	     D   \         P                  ! 4       ;_uu_ 4       p\        P                  ! \        P                  P                  VR 4      4       \        P                  ! R4      p\        \        P                  P                  VR R4      R4      ;_uu_ 4       pVP                  V4       RRR4       \        P                  ! \        P                  P                  VR 4      \        P                  P                  VR4      4       V P                  \        P                  P                  VR4      .RP                  . R	O4      4      w  rEV P                  RV4       V P                  RV4       RRR4       R#   + '       g   i     L; i  + '       g   i     R# ; i)
sourcezg
                def f(x):
                    return x + 1
                f(21 + 21)
                z__main__.pyr   Nz
zipapp.pyzry  42zreturn x + 1)zb fr'  zp xr0  )r	   r  r   r  r  rz  r  r  r  r  zipappcreate_archiver   r9  )r   r  r  r  r   r;  s   &     r   test_zipappPdbTestCase.test_zipapp  s   !!XHHRWW\\(H56__F bggll8X}EsKKq L!!"'',,x"B"$'',,x"FHrww||Hl'K&Ldii Y O IF MM$'MM.&1) "! LK "!!s%   A>FE;	.CF;FFF	c                   \         P                  ! 4       ;_uu_ 4       p\        P                  ! \        P                  P                  VR 4      4       \        P                  ! R4      p\        P                  ! R\        \        P                  P                  VR4      4       R24      p\        P                  ! \        P                  P                  VR4      R4      ;_uu_ 4       pVP                  RV4       RRR4       \        \        P                  P                  VR4      R4      ;_uu_ 4       pVP                  V4       RRR4       V P                  \        P                  P                  VR4      .R	P                  . RO4      4      w  rgV P                  R
V4       RRR4       R#   + '       g   i     L; i  + '       g   i     L; i  + '       g   i     R# ; i)rm  zE
                def bar():
                    pass
                z0
                import sys; sys.path.insert(0, zzipmodule.zipzG)
                import foo
                foo.bar()
                r   rF  Nz	script.pyry  zbreak in bar)nrt  z	b foo.barr'  z&p f"break in {$_frame.f_code.co_name}"r0  )r	   r  r   r  r  rz  r  r  reprzipfileZipFilewritestrr  r  r   r9  )r   r  	zipmoduler  zfr  r   r;  s   &       r   test_zipimportPdbTestCase.test_zipimport  sP   !!XHHRWW\\(H56 I __004RWW\\(O5\0]/^ _F h!H#NNRTHi0 Obggll8[93??1 @ rww||Hk'J&KTYY X N IF MM.&1; "!  ON??% "!!s=   C	G'F.	::G4G	AG.F>9GGGG%	)r  r   N)r   NNNF)Ir(   r)   r*   r+   r   unittestskipIfr   flags	safe_pathr   r  r  r  r#  r)  r-  r3  r<  rG  rM  rS  ra  ri  rm  rq  rv  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  r  r  r"  r,  r7  rA  r	   skip_unless_symlinkrH  rM  rS  rW  r^  ra  rj  rq  r{  r-   r.   r/   s   @r   r   r   {  s    + __SYY((>@@42AF5
 
"

&=2MV*";HG8G<'B F)<+*"*$,$* 7$JB;R
R
*2V	
O R
G
\H,&/&!,F->,"#MJZ>2+ K ""K #K01"K.!&:Mx0I2.2 2r   r   c                   >   a  ] tR tRt o R tR tR tR tR tRt	V t
R# )	ChecklineTestsi  c                0    \         P                  ! 4        R # r   )	linecache
clearcacher    s   &r   setUpChecklineTests.setUp  s    r   c                N    \         P                  ! \         P                  4       R # r   r   r    s   &r   r   ChecklineTests.tearDown  r   r   c                .   \        \        P                  R 4      ;_uu_ 4       pVP                  R4       RRR4       \        P
                  ! 4       pV P                  VP                  \        P                  ^4      ^4       R#   + '       g   i     LW; ir   z
print(123)N)r  r	   r   r  r   r   r   	checkliner   r  dbs   &  r   test_checkline_before_debugging.ChecklineTests.test_checkline_before_debugging  s]    )""C((AGGL! )WWYi&6&6:A> )(s   BB	c                N   \        \        P                  R 4      ;_uu_ 4       pVP                  R4       RRR4       \        P
                  ! 4       pVP                  4        V P                  VP                  \        P                  ^4      ^4       R#   + '       g   i     Lg; ir  )	r  r	   r   r  r   r   resetr   r  r  s   &  r   test_checkline_after_reset)ChecklineTests.test_checkline_after_reset  sf    )""C((AGGL! )WWY

i&6&6:A>	 )(s   BB$	c           	     ,   \         P                  ! R 4      p\        \        P                  R4      ;_uu_ 4       pVP                  V4       RRR4       \        VP                  4       4      ^,           p\        \        4       4      ;_uu_ 4        \        P                  ! 4       p\        V4       F2  pV P                  VP                  \        P                  V4      4       K4  	  RRR4       R#   + '       g   i     L; i  + '       g   i     R# ; i)z\
            # Comment
            """ docstring """
            ''' docstring '''

        r   N)r  r  r  r	   r   r  lenr`  r   r   r   r   rangerV  r  )r   rQ  r  	num_linesr  linenos   &     r    test_checkline_is_not_executable/ChecklineTests.test_checkline_is_not_executable  s    OO   )""C((AGGAJ )'!+	XZ((B	*  i.>.>!GH + )( )( )((s   C/AD/C?	D	r2   N)r(   r)   r*   r+   r  r   r  r  r  r-   r.   r/   s   @r   r  r    s%     +??I Ir   r  c                      a  ] tR tRt o ]P
                  ! ]P                  P                  R4      R	R l4       t	R t
R tR tRtV tR# )
PdbTestInlinei  r   Nc           	        V P                  \        P                  R 4       Rp\        VR4      ;_uu_ 4       pVP	                  \
        P                  ! V4      4       RRR4       V P                  \        P                  V4       \
        P                  ! V4      p\        P                  R.pVe   \        P                  V,          pM\        P                  p\        P                  ! V\        P                  \        P                  \        P                  / VCRR/CR7      ;_uu_ 4       p	V	P                  \         P#                  V4      4      w  rRRR4       \%        X
\&        4      '       d   \&        P)                  V
4      MT
p
\%        X\&        4      '       d   \&        P)                  V4      MTpV P+                  X	P,                  VRV
 RV 24       W3#   + '       g   i     EL; i  + '       g   i     L; i)	r   r   r   Nr   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   )r   r  r   r   r   r  r  r   r   r   r   r   s   &&&&&       r   _run_scriptPdbTestInline._run_script  sv   
 		((-8(C  AGGHOOF+, !	(((3??8,~~y) **y(C**C! oo!::0':
 
 !--cjj.BCNF
 *4FE)B)Bf%)3FE)B)Bf%OO.vhjI	

 ~5 !  
 
s   &G,'G/G,	/G?	c                
   R pRpV P                  W^R7      w  r4V P                  RV4       V P                  RV4       V P                  RV4       V P                  VR4       V P                  VP	                  R4      ^4       R# )4
            x = 1
            breakpoint()
        z[
            quit
            n
            p x + 1
            quit
            y
        r  2Quit anywayz--rP  N)r  r9  rK  r   rt  ru  s   &    r   	test_quitPdbTestInline.test_quit	  s    
 ))&PQ)Rc6"mV, 	v&$m4a8r   c                    RpRpV P                  W^R7      w  r4V P                  VR4       V P                  VP                  R4      ^4       V P                  RV4       R# )z
interact command will set sys.ps1 temporarily, we need to make sure
that it's restored and pdb does not believe it's in interactive mode
after interact is done.
r  zM
            interact
            quit()
            q
            y
        r  rP  r  BdbQuitN)r  r   rt  rK  ru  s   &    r   test_quit_after_interact&PdbTestInline.test_quit_after_interact#  sc    
 ))&PQ)R$m4a8F+r   c                    \         P                  ! R4      pRpV P                  W4      w  r4V P                  RV4       R# )aQ  GH-82897
Inline set_trace() should break unconditionally. This example is a
bit oversimplified, but as `pdb.set_trace()` uses the previous Pdb
instance, it's possible that we had a previous pdb instance with
skip values when we use `pdb.set_trace()` - it would be confusing
to users when such inline breakpoints won't break immediately.
z
            import pdb
            def foo():
                x = 40 + 2
                pdb.Pdb(skip=['__main__']).set_trace()
            foo()
        z'
            p x
            c
        rn  N)r  r  r  r9  r:  s   &    r   test_set_trace_with_skip&PdbTestInline.test_set_trace_with_skip=  s@      "  $$V6	dF#r   r2   r}  )r(   r)   r*   r+   r~  r  r   r  r  r  r  r  r  r-   r.   r/   s   @r   r  r    sF     __SYY((>@@B94,4$ $r   r  c                   8   a  ] tR tRt o R tR tR tR tRtV t	R# )PdbTestColorizeiT  c                H    \         P                  V n        R  \         n        R# )c                      R # )Tr2   )argskwargss   *,r   <lambda>'PdbTestColorize.setUp.<locals>.<lambda>Z  s    r   N)	_colorizecan_colorize_original_can_colorizer    s   &r   r  PdbTestColorize.setUpV  s    &/&<&<# ">	r   c                0    V P                   \        n        R # r   )r  r  r  r    s   &r   r   PdbTestColorize.tearDown\  s    !%!<!<	r   c                J   \         P                  ! 4       p\        P                  ! VR R7      pVP	                  RR.R7       V P                  RVP                  4       4       \         P                  ! 4       p\        P                  ! VRR7      pVP	                  RR.R7       V P                  RVP                  4       4       \         P                  ! 4       p\        P                  ! VR7      pVP	                  RR.R7       V P                  RVP                  4       4       R# )	Tr   colorizellr'  r   F)r   N)ior   r   r   r  r9  r  rK  r   rR  ps   &  r   test_code_display!PdbTestColorize.test_code_display_  s    GG6D1	dC[)ffoo/0GG6E2	dC[)!23GG6"	dC[)!23r   c                    \         P                  ! 4       p\        P                  ! VR R7      pVP	                  RR.R7       V P                  RVP                  4       4       R# )Tr  r   r'  r  r  N)r  r   r   r   r  r9  r  r  s   &  r   test_stack_entry PdbTestColorize.test_stack_entryo  sD    GG6D1	c3Z(ffoo/0r   )r  N)
r(   r)   r*   r+   r  r   r  r  r-   r.   r/   s   @r   r  r  T  s     >=4 1 1r   r  c                   &   a  ] tR tRt o R tRtV tR# )TestREPLSessioniv  c                `   ^ RI Hp V! 4       pRpVP                  P                  \        P
                  ! V4      4       \        V4      pV P                  RV4       V P                  RV4       V P                  RV4       V P                  RV4       V P                  VP                  ^ 4       R# )r   )
spawn_replz
            x = 'Spam'
            import pdb
            pdb.set_trace(commands=['x + "During"', 'q'])
            x + 'After'
        
SpamDuringr  r  	SpamAfterN)test.test_replr  r   r  r  r  r   r9  rK  r   r   )r   r  r  
user_inputrR  s   &    r   $test_return_from_inline_mode_to_REPL4TestREPLSession.test_return_from_inline_mode_to_REPLy  s     	.L
 	
hooj12QlF+/i(k6*q)r   r2   N)r(   r)   r*   r+   r  r-   r.   r/   s   @r   r  r  v  s     * *r   r  c                   "  a  ] tR tRt o ]R 4       tR tR tR tR t	R t
]P                  ! ]P                  P                  R4      R	4      R
 4       tR t]P                  ! ]P                  P                  R4      R	4      R 4       tR tRtV tR# )PdbTestReadlinei  c                j    \        R 4      pVP                  R8X  d   \        P                  ! R4      hR# )readlineeditlinez)libedit readline is not supported for pdbN)r
   backendr~  SkipTest)clsr  s   & r   
setUpClassPdbTestReadline.setUpClass  s3     !,z)##$OPP *r   c                    \         P                  ! R 4      pRp\        W4      pV P                  RV4       V P                  RV4       V P                  RV4       V P                  RV4       R# )z
            import pdb; pdb.Pdb().set_trace()
            # Concatenate strings so that the output doesn't appear in the source
            print('hello' + '!')
        s
   co		ntin	
s   commandss	   conditions   continues   hello!Nr  r  r   r9  r   r  r   rR  s   &   r   test_basic_completion%PdbTestReadline.test_basic_completion  s^     "  "'k6*lF+k6*i(r   c                    \         P                  ! R 4      pRpVR,          pVR,          pVR,          p\        W4      pV P                  RV4       V P                  RV4       V P                  RV4       R# )	S
            value = "speci"
            import pdb; pdb.Pdb().set_trace()
           val	 + 'al'
s   p val	 + 'es'
s   $_fra	
   c
   specials   speciess   $_frameNr  r  s   &   r   test_expression_completion*PdbTestReadline.test_expression_completion  sn     "  "$$'j&)j&)j&)r   c                    \         P                  ! R 4      pRpVR,          p\        W4      pV P                  RV4       R# )r  s   pri	val	 + 'al')
r  r  Nr  r  s   &   r   test_builtin_completion'PdbTestReadline.test_builtin_completion  s?     "  ( 	'j&)r   c                    \         P                  ! R 4      pRpVR,          pVR,          p\        W4      pV P                  RV4       V P                  RV4       R# )7
            import pdb; pdb.Pdb().set_trace()
        s   $_fram	
s   $_frame.f_line	 + 100
r  s   <frame at 0xs   102Nr  r  s   &   r   test_convvar_completion'PdbTestReadline.test_convvar_completion  sZ     " 
  	,, 	'ov.ff%r   c                    \         P                  ! R 4      pRpVR,          p\        W4      pV P                  RV4       R# )z
            def f():
                original = "I live Pythin"
                import pdb; pdb.Pdb().set_trace()
            f()
        s   orig	.repl	('i', 'o')
r  s   I love PythonNr  r  s   &   r   test_local_namespace$PdbTestReadline.test_local_namespace  s@     "  - 	'&/r   freebsdz/\x08 is not interpreted as backspace on FreeBSDc                    \         P                  ! R 4      pRpVR,          pVR,          pVR,          pVR,          pVR,          pVR,          pVR,          pVR	,          p\        W4      pV P                  R
V4       R# )r  s
   def f(x):
s
   if x > 0:
s   x += 1
s	   return x
s
   else:
s
   return -x
   
s
   f(-21-21)
r     42Nr  r  s   &   r   test_multiline_auto_indent*PdbTestReadline.test_multiline_auto_indent  s      "  ++'eV$r   c                    \         P                  ! R 4      pRpVR,          pVR,          pVR,          pVR,          p\        W4      pV P                  RV4       R# )r  s   def func():
s   ret	 40 + 2
r  s   fun	()
r  r  Nr  r  s   &   r   test_multiline_completion)PdbTestReadline.test_multiline_completion  s]     "  ! 	""'eV$r   c                    \         P                  ! R 4      p\         P                  ! R4      P                  4       p\        W4      pV P	                  RV4       V P                  RV4       R# )r  z            def func():
            a = 1
            	a += 1
            	a += 1
            	a += 1
            	if a > 0:
            a += 1
            return a

            func()
            c
           5rf  N)r  r  r   r   r9  rK  r  s   &   r    test_multiline_indent_completion0PdbTestReadline.test_multiline_indent_completion  sb      "   !  VX 	 'dF#6*r   c                H   \         P                  ! R 4      pRpVR,          pVR,          pVR,          pVR,          pVR,          pVR,          pVR,          pVR	,          p\        W4      pV P                  R
V4       V P                  RV4       V P                  RV4       R# )r  s	   interact
s   disp	
r  s	   def f():
s   	return 42
r  s   f() * 2
s   exit()
r  s   'disp' is not definedr  s   84Nr  r  s   &   r   test_interact_completion(PdbTestReadline.test_interact_completion:  s     "  ""!!'.7j&)eV$r   r2   N)r(   r)   r*   r+   classmethodr  r  r  r  r  r  r~  r  r   platform
startswithr  r  r  r  r-   r.   r/   s   @r   r  r    s      Q Q)$*** &&0$ __S\\,,Y7GI%I%(%$ __S\\,,Y7GI+I+6% %r   r  c                     ^ RI Hp R pR pVP                  \        P                  ! VV! R4      VR7      4       VP                  \        P                  ! VV! R4      VR7      4       V# )r   )test_pdbc                    a  V 3R  lpV# )c                 4   < ^ RI pVP                  ! S4       R# r}  )r   set_default_backend)testr   r  s   & r   r  2load_tests.<locals>.setUpPdbBackend.<locals>.setUp[  s    ##G,r   r2   )r  r  s   f r   setUpPdbBackend#load_tests.<locals>.setUpPdbBackendZ  s    	- r   c                 <   \        R 4       ^ R IpVP                  P                  4        \        P
                  P                  '       d>   \        P
                  P                  P                  4        R \        P
                  n        \        P                  ! 4        R # r   )
r   bdb
BreakpointclearBreakpointsr   r   r  
stop_tracegccollect)r  r  s   & r   r   load_tests.<locals>.tearDown`  s`     	t$ 	'') 77%%%GG&&113)-CGG& 	

r   
monitoring)r  r   r$   )r  r
  addTestdoctestDocTestSuite)loadertestspatternr
  r  r   s   &&&   r   
load_testsr!  W  sj    2 
MM!,/	
 
MM!*-	
 Lr   __main__)r  r  r  r  r   r   r   typesr1  r~  r   r  r  ro  rv  asyncio.eventsr   
contextlibr   r   r   r  r   test.supportr   r	   test.support.import_helperr
   test.support.pty_helperr   r   test.support.script_helperr   unittest.mockr   SKIP_CORO_TESTSr  r   r3   r6   r8   r:   r<   r>   r@   rB   rD   rF   rH   rJ   rL   rP   rR   rT   rV   rX   rZ   r\   r^   r  no_siter`   rb   rd   rf   rh   rj   rl   rn   rp   rr   rt   rv   rx   
ModuleTypemodexec__dict__r{   r}   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  original_pdb_settracer   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   force_not_colorized_test_classrequires_subprocessTestCaser   r  r  force_colorized_test_classr  r  r  r!  r(   mainr2   r   r   <module>r7     s     	 	 	 
 
         1 1   6 4 6 2 *6 *"8WrBH'R D,\B'R@D"H4@	aF'R=~GRYv*	 yy2hYxNb5pGT"J"J*bJ?D0f4!J '( =s|| L,^+\?
 ,=~=~ 	.>	@.	`;	z7r<|9v )V.` .`'R1fB D=~&T  %N08.`CJ(T2("".6,1f'R1h 	''2(## 2  (2D""IX&& "IJ 	l$H%% l$ l$^ 	##1h'' 1 $1B 	''*h'' *  (** 	''E%h'' E%  (E%P0f zMMO r   