1676 lines
53 KiB
Python
1676 lines
53 KiB
Python
# A test suite for pdb; not very comprehensive at the moment.
|
|
|
|
import doctest
|
|
import os
|
|
import pdb
|
|
import sys
|
|
import types
|
|
import codecs
|
|
import unittest
|
|
import subprocess
|
|
import textwrap
|
|
|
|
from contextlib import ExitStack
|
|
from io import StringIO
|
|
from test.support import os_helper
|
|
# This little helper class is essential for testing pdb under doctest.
|
|
from test.test_doctest import _FakeInput
|
|
from unittest.mock import patch
|
|
|
|
|
|
class PdbTestInput(object):
|
|
"""Context manager that makes testing Pdb in doctests easier."""
|
|
|
|
def __init__(self, input):
|
|
self.input = input
|
|
|
|
def __enter__(self):
|
|
self.real_stdin = sys.stdin
|
|
sys.stdin = _FakeInput(self.input)
|
|
self.orig_trace = sys.gettrace() if hasattr(sys, 'gettrace') else None
|
|
|
|
def __exit__(self, *exc):
|
|
sys.stdin = self.real_stdin
|
|
if self.orig_trace:
|
|
sys.settrace(self.orig_trace)
|
|
|
|
|
|
def test_pdb_displayhook():
|
|
"""This tests the custom displayhook for pdb.
|
|
|
|
>>> def test_function(foo, bar):
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... pass
|
|
|
|
>>> with PdbTestInput([
|
|
... 'foo',
|
|
... 'bar',
|
|
... 'for i in range(5): print(i)',
|
|
... 'continue',
|
|
... ]):
|
|
... test_function(1, None)
|
|
> <doctest test.test_pdb.test_pdb_displayhook[0]>(3)test_function()
|
|
-> pass
|
|
(Pdb) foo
|
|
1
|
|
(Pdb) bar
|
|
(Pdb) for i in range(5): print(i)
|
|
0
|
|
1
|
|
2
|
|
3
|
|
4
|
|
(Pdb) continue
|
|
"""
|
|
|
|
|
|
def test_pdb_basic_commands():
|
|
"""Test the basic commands of pdb.
|
|
|
|
>>> def test_function_2(foo, bar='default'):
|
|
... print(foo)
|
|
... for i in range(5):
|
|
... print(i)
|
|
... print(bar)
|
|
... for i in range(10):
|
|
... never_executed
|
|
... print('after for')
|
|
... print('...')
|
|
... return foo.upper()
|
|
|
|
>>> def test_function3(arg=None, *, kwonly=None):
|
|
... pass
|
|
|
|
>>> def test_function4(a, b, c, /):
|
|
... pass
|
|
|
|
>>> def test_function():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... ret = test_function_2('baz')
|
|
... test_function3(kwonly=True)
|
|
... test_function4(1, 2, 3)
|
|
... print(ret)
|
|
|
|
>>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
|
|
... 'step', # entering the function call
|
|
... 'args', # display function args
|
|
... 'list', # list function source
|
|
... 'bt', # display backtrace
|
|
... 'up', # step up to test_function()
|
|
... 'down', # step down to test_function_2() again
|
|
... 'next', # stepping to print(foo)
|
|
... 'next', # stepping to the for loop
|
|
... 'step', # stepping into the for loop
|
|
... 'until', # continuing until out of the for loop
|
|
... 'next', # executing the print(bar)
|
|
... 'jump 8', # jump over second for loop
|
|
... 'return', # return out of function
|
|
... 'retval', # display return value
|
|
... 'next', # step to test_function3()
|
|
... 'step', # stepping into test_function3()
|
|
... 'args', # display function args
|
|
... 'return', # return out of function
|
|
... 'next', # step to test_function4()
|
|
... 'step', # stepping to test_function4()
|
|
... 'args', # display function args
|
|
... 'continue',
|
|
... ]):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
|
|
-> ret = test_function_2('baz')
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
|
|
-> def test_function_2(foo, bar='default'):
|
|
(Pdb) args
|
|
foo = 'baz'
|
|
bar = 'default'
|
|
(Pdb) list
|
|
1 -> def test_function_2(foo, bar='default'):
|
|
2 print(foo)
|
|
3 for i in range(5):
|
|
4 print(i)
|
|
5 print(bar)
|
|
6 for i in range(10):
|
|
7 never_executed
|
|
8 print('after for')
|
|
9 print('...')
|
|
10 return foo.upper()
|
|
[EOF]
|
|
(Pdb) bt
|
|
...
|
|
<doctest test.test_pdb.test_pdb_basic_commands[4]>(25)<module>()
|
|
-> test_function()
|
|
<doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
|
|
-> ret = test_function_2('baz')
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
|
|
-> def test_function_2(foo, bar='default'):
|
|
(Pdb) up
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(3)test_function()
|
|
-> ret = test_function_2('baz')
|
|
(Pdb) down
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
|
|
-> def test_function_2(foo, bar='default'):
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(2)test_function_2()
|
|
-> print(foo)
|
|
(Pdb) next
|
|
baz
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(3)test_function_2()
|
|
-> for i in range(5):
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(4)test_function_2()
|
|
-> print(i)
|
|
(Pdb) until
|
|
0
|
|
1
|
|
2
|
|
3
|
|
4
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(5)test_function_2()
|
|
-> print(bar)
|
|
(Pdb) next
|
|
default
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(6)test_function_2()
|
|
-> for i in range(10):
|
|
(Pdb) jump 8
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(8)test_function_2()
|
|
-> print('after for')
|
|
(Pdb) return
|
|
after for
|
|
...
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[0]>(10)test_function_2()->'BAZ'
|
|
-> return foo.upper()
|
|
(Pdb) retval
|
|
'BAZ'
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(4)test_function()
|
|
-> test_function3(kwonly=True)
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[1]>(1)test_function3()
|
|
-> def test_function3(arg=None, *, kwonly=None):
|
|
(Pdb) args
|
|
arg = None
|
|
kwonly = True
|
|
(Pdb) return
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[1]>(2)test_function3()->None
|
|
-> pass
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[3]>(5)test_function()
|
|
-> test_function4(1, 2, 3)
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_basic_commands[2]>(1)test_function4()
|
|
-> def test_function4(a, b, c, /):
|
|
(Pdb) args
|
|
a = 1
|
|
b = 2
|
|
c = 3
|
|
(Pdb) continue
|
|
BAZ
|
|
"""
|
|
|
|
|
|
def test_pdb_breakpoint_commands():
|
|
"""Test basic commands related to breakpoints.
|
|
|
|
>>> def test_function():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... print(1)
|
|
... print(2)
|
|
... print(3)
|
|
... print(4)
|
|
|
|
First, need to clear bdb state that might be left over from previous tests.
|
|
Otherwise, the new breakpoints might get assigned different numbers.
|
|
|
|
>>> from bdb import Breakpoint
|
|
>>> Breakpoint.next = 1
|
|
>>> Breakpoint.bplist = {}
|
|
>>> Breakpoint.bpbynumber = [None]
|
|
|
|
Now test the breakpoint commands. NORMALIZE_WHITESPACE is needed because
|
|
the breakpoint list outputs a tab for the "stop only" and "ignore next"
|
|
lines, which we don't want to put in here.
|
|
|
|
>>> with PdbTestInput([ # doctest: +NORMALIZE_WHITESPACE
|
|
... 'break 3',
|
|
... 'disable 1',
|
|
... 'ignore 1 10',
|
|
... 'condition 1 1 < 2',
|
|
... 'break 4',
|
|
... 'break 4',
|
|
... 'break',
|
|
... 'clear 3',
|
|
... 'break',
|
|
... 'condition 1',
|
|
... 'enable 1',
|
|
... 'clear 1',
|
|
... 'commands 2',
|
|
... 'p "42"',
|
|
... 'print("42", 7*6)', # Issue 18764 (not about breakpoints)
|
|
... 'end',
|
|
... 'continue', # will stop at breakpoint 2 (line 4)
|
|
... 'clear', # clear all!
|
|
... 'y',
|
|
... 'tbreak 5',
|
|
... 'continue', # will stop at temporary breakpoint
|
|
... 'break', # make sure breakpoint is gone
|
|
... 'continue',
|
|
... ]):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(3)test_function()
|
|
-> print(1)
|
|
(Pdb) break 3
|
|
Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
|
|
(Pdb) disable 1
|
|
Disabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
|
|
(Pdb) ignore 1 10
|
|
Will ignore next 10 crossings of breakpoint 1.
|
|
(Pdb) condition 1 1 < 2
|
|
New condition set for breakpoint 1.
|
|
(Pdb) break 4
|
|
Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
|
|
(Pdb) break 4
|
|
Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
|
|
(Pdb) break
|
|
Num Type Disp Enb Where
|
|
1 breakpoint keep no at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
|
|
stop only if 1 < 2
|
|
ignore next 10 hits
|
|
2 breakpoint keep yes at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
|
|
3 breakpoint keep yes at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
|
|
(Pdb) clear 3
|
|
Deleted breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
|
|
(Pdb) break
|
|
Num Type Disp Enb Where
|
|
1 breakpoint keep no at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
|
|
stop only if 1 < 2
|
|
ignore next 10 hits
|
|
2 breakpoint keep yes at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
|
|
(Pdb) condition 1
|
|
Breakpoint 1 is now unconditional.
|
|
(Pdb) enable 1
|
|
Enabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
|
|
(Pdb) clear 1
|
|
Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
|
|
(Pdb) commands 2
|
|
(com) p "42"
|
|
(com) print("42", 7*6)
|
|
(com) end
|
|
(Pdb) continue
|
|
1
|
|
'42'
|
|
42 42
|
|
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(4)test_function()
|
|
-> print(2)
|
|
(Pdb) clear
|
|
Clear all breaks? y
|
|
Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
|
|
(Pdb) tbreak 5
|
|
Breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
|
|
(Pdb) continue
|
|
2
|
|
Deleted breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
|
|
> <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(5)test_function()
|
|
-> print(3)
|
|
(Pdb) break
|
|
(Pdb) continue
|
|
3
|
|
4
|
|
"""
|
|
|
|
|
|
def do_nothing():
|
|
pass
|
|
|
|
def do_something():
|
|
print(42)
|
|
|
|
def test_list_commands():
|
|
"""Test the list and source commands of pdb.
|
|
|
|
>>> def test_function_2(foo):
|
|
... import test.test_pdb
|
|
... test.test_pdb.do_nothing()
|
|
... 'some...'
|
|
... 'more...'
|
|
... 'code...'
|
|
... 'to...'
|
|
... 'make...'
|
|
... 'a...'
|
|
... 'long...'
|
|
... 'listing...'
|
|
... 'useful...'
|
|
... '...'
|
|
... '...'
|
|
... return foo
|
|
|
|
>>> def test_function():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... ret = test_function_2('baz')
|
|
|
|
>>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
|
|
... 'list', # list first function
|
|
... 'step', # step into second function
|
|
... 'list', # list second function
|
|
... 'list', # continue listing to EOF
|
|
... 'list 1,3', # list specific lines
|
|
... 'list x', # invalid argument
|
|
... 'next', # step to import
|
|
... 'next', # step over import
|
|
... 'step', # step into do_nothing
|
|
... 'longlist', # list all lines
|
|
... 'source do_something', # list all lines of function
|
|
... 'source fooxxx', # something that doesn't exit
|
|
... 'continue',
|
|
... ]):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_list_commands[1]>(3)test_function()
|
|
-> ret = test_function_2('baz')
|
|
(Pdb) list
|
|
1 def test_function():
|
|
2 import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
3 -> ret = test_function_2('baz')
|
|
[EOF]
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_list_commands[0]>(1)test_function_2()
|
|
-> def test_function_2(foo):
|
|
(Pdb) list
|
|
1 -> def test_function_2(foo):
|
|
2 import test.test_pdb
|
|
3 test.test_pdb.do_nothing()
|
|
4 'some...'
|
|
5 'more...'
|
|
6 'code...'
|
|
7 'to...'
|
|
8 'make...'
|
|
9 'a...'
|
|
10 'long...'
|
|
11 'listing...'
|
|
(Pdb) list
|
|
12 'useful...'
|
|
13 '...'
|
|
14 '...'
|
|
15 return foo
|
|
[EOF]
|
|
(Pdb) list 1,3
|
|
1 -> def test_function_2(foo):
|
|
2 import test.test_pdb
|
|
3 test.test_pdb.do_nothing()
|
|
(Pdb) list x
|
|
*** ...
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_list_commands[0]>(2)test_function_2()
|
|
-> import test.test_pdb
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_list_commands[0]>(3)test_function_2()
|
|
-> test.test_pdb.do_nothing()
|
|
(Pdb) step
|
|
--Call--
|
|
> ...test_pdb.py(...)do_nothing()
|
|
-> def do_nothing():
|
|
(Pdb) longlist
|
|
... -> def do_nothing():
|
|
... pass
|
|
(Pdb) source do_something
|
|
... def do_something():
|
|
... print(42)
|
|
(Pdb) source fooxxx
|
|
*** ...
|
|
(Pdb) continue
|
|
"""
|
|
|
|
def test_pdb_whatis_command():
|
|
"""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()
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_whatis_command[3]>(2)test_function()->None
|
|
-> import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
(Pdb) whatis myvar
|
|
<class 'tuple'>
|
|
(Pdb) whatis myfunc
|
|
Function myfunc
|
|
(Pdb) whatis MyClass
|
|
Class test.test_pdb.MyClass
|
|
(Pdb) whatis MyClass()
|
|
<class 'test.test_pdb.MyClass'>
|
|
(Pdb) whatis MyClass.mymethod
|
|
Function mymethod
|
|
(Pdb) whatis MyClass().mymethod
|
|
Method mymethod
|
|
(Pdb) continue
|
|
"""
|
|
|
|
def test_post_mortem():
|
|
"""Test post mortem traceback debugging.
|
|
|
|
>>> def test_function_2():
|
|
... try:
|
|
... 1/0
|
|
... finally:
|
|
... print('Exception!')
|
|
|
|
>>> def test_function():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... test_function_2()
|
|
... print('Not reached.')
|
|
|
|
>>> with PdbTestInput([ # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
|
|
... 'next', # step over exception-raising call
|
|
... 'bt', # get a backtrace
|
|
... 'list', # list code of test_function()
|
|
... 'down', # step into test_function_2()
|
|
... 'list', # list code of test_function_2()
|
|
... 'continue',
|
|
... ]):
|
|
... try:
|
|
... test_function()
|
|
... except ZeroDivisionError:
|
|
... print('Correctly reraised.')
|
|
> <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
|
|
-> test_function_2()
|
|
(Pdb) next
|
|
Exception!
|
|
ZeroDivisionError: division by zero
|
|
> <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
|
|
-> test_function_2()
|
|
(Pdb) bt
|
|
...
|
|
<doctest test.test_pdb.test_post_mortem[2]>(10)<module>()
|
|
-> test_function()
|
|
> <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
|
|
-> test_function_2()
|
|
<doctest test.test_pdb.test_post_mortem[0]>(3)test_function_2()
|
|
-> 1/0
|
|
(Pdb) list
|
|
1 def test_function():
|
|
2 import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
3 -> test_function_2()
|
|
4 print('Not reached.')
|
|
[EOF]
|
|
(Pdb) down
|
|
> <doctest test.test_pdb.test_post_mortem[0]>(3)test_function_2()
|
|
-> 1/0
|
|
(Pdb) list
|
|
1 def test_function_2():
|
|
2 try:
|
|
3 >> 1/0
|
|
4 finally:
|
|
5 -> print('Exception!')
|
|
[EOF]
|
|
(Pdb) continue
|
|
Correctly reraised.
|
|
"""
|
|
|
|
|
|
def test_pdb_skip_modules():
|
|
"""This illustrates the simple case of module skipping.
|
|
|
|
>>> def skip_module():
|
|
... import string
|
|
... import pdb; pdb.Pdb(skip=['stri*'], nosigint=True, readrc=False).set_trace()
|
|
... string.capwords('FOO')
|
|
|
|
>>> with PdbTestInput([
|
|
... 'step',
|
|
... 'continue',
|
|
... ]):
|
|
... skip_module()
|
|
> <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()
|
|
-> string.capwords('FOO')
|
|
(Pdb) step
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()->None
|
|
-> string.capwords('FOO')
|
|
(Pdb) continue
|
|
"""
|
|
|
|
|
|
# Module for testing skipping of module that makes a callback
|
|
mod = types.ModuleType('module_to_skip')
|
|
exec('def foo_pony(callback): x = 1; callback(); return None', mod.__dict__)
|
|
|
|
|
|
def test_pdb_skip_modules_with_callback():
|
|
"""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',
|
|
... 'continue',
|
|
... ]):
|
|
... skip_module()
|
|
... pass # provides something to "step" to
|
|
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(5)skip_module()
|
|
-> mod.foo_pony(callback)
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(2)callback()
|
|
-> def callback():
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(3)callback()
|
|
-> return None
|
|
(Pdb) step
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(3)callback()->None
|
|
-> return None
|
|
(Pdb) step
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(5)skip_module()->None
|
|
-> mod.foo_pony(callback)
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_skip_modules_with_callback[1]>(10)<module>()
|
|
-> pass # provides something to "step" to
|
|
(Pdb) continue
|
|
"""
|
|
|
|
|
|
def test_pdb_continue_in_bottomframe():
|
|
"""Test that "continue" and "next" work properly in bottom frame (issue #5294).
|
|
|
|
>>> def test_function():
|
|
... import pdb, sys; inst = pdb.Pdb(nosigint=True, readrc=False)
|
|
... inst.set_trace()
|
|
... inst.botframe = sys._getframe() # hackery to get the right botframe
|
|
... print(1)
|
|
... print(2)
|
|
... print(3)
|
|
... print(4)
|
|
|
|
>>> with PdbTestInput([ # doctest: +ELLIPSIS
|
|
... 'next',
|
|
... 'break 7',
|
|
... 'continue',
|
|
... 'next',
|
|
... 'continue',
|
|
... 'continue',
|
|
... ]):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(4)test_function()
|
|
-> inst.botframe = sys._getframe() # hackery to get the right botframe
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(5)test_function()
|
|
-> print(1)
|
|
(Pdb) break 7
|
|
Breakpoint ... at <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>:7
|
|
(Pdb) continue
|
|
1
|
|
2
|
|
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(7)test_function()
|
|
-> print(3)
|
|
(Pdb) next
|
|
3
|
|
> <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(8)test_function()
|
|
-> print(4)
|
|
(Pdb) continue
|
|
4
|
|
"""
|
|
|
|
|
|
def pdb_invoke(method, arg):
|
|
"""Run pdb.method(arg)."""
|
|
getattr(pdb.Pdb(nosigint=True, readrc=False), method)(arg)
|
|
|
|
|
|
def test_pdb_run_with_incorrect_argument():
|
|
"""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
|
|
"""
|
|
|
|
|
|
def test_pdb_run_with_code_object():
|
|
"""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
|
|
"""
|
|
|
|
def test_next_until_return_at_return_event():
|
|
"""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
|
|
|
|
>>> from bdb import Breakpoint
|
|
>>> Breakpoint.next = 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]>(3)test_function()
|
|
-> test_function_2()
|
|
(Pdb) break test_function_2
|
|
Breakpoint 1 at <doctest test.test_pdb.test_next_until_return_at_return_event[0]>:1
|
|
(Pdb) continue
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
|
|
-> x = 1
|
|
(Pdb) return
|
|
--Return--
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
|
|
-> x = 2
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(4)test_function()
|
|
-> test_function_2()
|
|
(Pdb) continue
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
|
|
-> x = 1
|
|
(Pdb) return
|
|
--Return--
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
|
|
-> x = 2
|
|
(Pdb) until
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(5)test_function()
|
|
-> test_function_2()
|
|
(Pdb) continue
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(2)test_function_2()
|
|
-> x = 1
|
|
(Pdb) return
|
|
--Return--
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[0]>(3)test_function_2()->None
|
|
-> x = 2
|
|
(Pdb) return
|
|
> <doctest test.test_pdb.test_next_until_return_at_return_event[1]>(6)test_function()
|
|
-> end = 1
|
|
(Pdb) continue
|
|
"""
|
|
|
|
def test_pdb_next_command_for_generator():
|
|
"""Testing skip unwindng stack on yield for generators for "next" command
|
|
|
|
>>> def test_gen():
|
|
... yield 0
|
|
... return 1
|
|
... yield 2
|
|
|
|
>>> def test_function():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... it = test_gen()
|
|
... try:
|
|
... if next(it) != 0:
|
|
... raise AssertionError
|
|
... next(it)
|
|
... except StopIteration as ex:
|
|
... if ex.value != 1:
|
|
... raise AssertionError
|
|
... print("finished")
|
|
|
|
>>> with PdbTestInput(['step',
|
|
... 'step',
|
|
... 'step',
|
|
... 'next',
|
|
... 'next',
|
|
... 'step',
|
|
... 'step',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(3)test_function()
|
|
-> it = test_gen()
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(4)test_function()
|
|
-> try:
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(5)test_function()
|
|
-> if next(it) != 0:
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(1)test_gen()
|
|
-> def test_gen():
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(2)test_gen()
|
|
-> yield 0
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(3)test_gen()
|
|
-> return 1
|
|
(Pdb) step
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_generator[0]>(3)test_gen()->1
|
|
-> return 1
|
|
(Pdb) step
|
|
StopIteration: 1
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_generator[1]>(7)test_function()
|
|
-> next(it)
|
|
(Pdb) continue
|
|
finished
|
|
"""
|
|
|
|
def test_pdb_next_command_for_coroutine():
|
|
"""Testing skip unwindng stack on yield for coroutines for "next" command
|
|
|
|
>>> import asyncio
|
|
|
|
>>> async def test_coro():
|
|
... await asyncio.sleep(0)
|
|
... await asyncio.sleep(0)
|
|
... await asyncio.sleep(0)
|
|
|
|
>>> async def test_main():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... await test_coro()
|
|
|
|
>>> def test_function():
|
|
... loop = asyncio.new_event_loop()
|
|
... loop.run_until_complete(test_main())
|
|
... loop.close()
|
|
... asyncio.set_event_loop_policy(None)
|
|
... print("finished")
|
|
|
|
>>> with PdbTestInput(['step',
|
|
... 'step',
|
|
... 'next',
|
|
... 'next',
|
|
... 'next',
|
|
... 'step',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()
|
|
-> await test_coro()
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(1)test_coro()
|
|
-> async def test_coro():
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(2)test_coro()
|
|
-> await asyncio.sleep(0)
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(3)test_coro()
|
|
-> await asyncio.sleep(0)
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[1]>(4)test_coro()
|
|
-> await asyncio.sleep(0)
|
|
(Pdb) next
|
|
Internal StopIteration
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()
|
|
-> await test_coro()
|
|
(Pdb) step
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_coroutine[2]>(3)test_main()->None
|
|
-> await test_coro()
|
|
(Pdb) continue
|
|
finished
|
|
"""
|
|
|
|
def test_pdb_next_command_for_asyncgen():
|
|
"""Testing skip unwindng stack on yield for coroutines for "next" command
|
|
|
|
>>> import asyncio
|
|
|
|
>>> async def agen():
|
|
... yield 1
|
|
... await asyncio.sleep(0)
|
|
... yield 2
|
|
|
|
>>> async def test_coro():
|
|
... async for x in agen():
|
|
... print(x)
|
|
|
|
>>> async def test_main():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... await test_coro()
|
|
|
|
>>> def test_function():
|
|
... loop = asyncio.new_event_loop()
|
|
... loop.run_until_complete(test_main())
|
|
... loop.close()
|
|
... asyncio.set_event_loop_policy(None)
|
|
... print("finished")
|
|
|
|
>>> with PdbTestInput(['step',
|
|
... 'step',
|
|
... 'next',
|
|
... 'next',
|
|
... 'step',
|
|
... 'next',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[3]>(3)test_main()
|
|
-> await test_coro()
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(1)test_coro()
|
|
-> async def test_coro():
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(2)test_coro()
|
|
-> async for x in agen():
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(3)test_coro()
|
|
-> print(x)
|
|
(Pdb) next
|
|
1
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[2]>(2)test_coro()
|
|
-> async for x in agen():
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[1]>(2)agen()
|
|
-> yield 1
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_next_command_for_asyncgen[1]>(3)agen()
|
|
-> await asyncio.sleep(0)
|
|
(Pdb) continue
|
|
2
|
|
finished
|
|
"""
|
|
|
|
def test_pdb_return_command_for_generator():
|
|
"""Testing no unwindng stack on yield for generators
|
|
for "return" command
|
|
|
|
>>> def test_gen():
|
|
... yield 0
|
|
... return 1
|
|
... yield 2
|
|
|
|
>>> def test_function():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... it = test_gen()
|
|
... try:
|
|
... if next(it) != 0:
|
|
... raise AssertionError
|
|
... next(it)
|
|
... except StopIteration as ex:
|
|
... if ex.value != 1:
|
|
... raise AssertionError
|
|
... print("finished")
|
|
|
|
>>> with PdbTestInput(['step',
|
|
... 'step',
|
|
... 'step',
|
|
... 'return',
|
|
... 'step',
|
|
... 'step',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(3)test_function()
|
|
-> it = test_gen()
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(4)test_function()
|
|
-> try:
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(5)test_function()
|
|
-> if next(it) != 0:
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_generator[0]>(1)test_gen()
|
|
-> def test_gen():
|
|
(Pdb) return
|
|
StopIteration: 1
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(7)test_function()
|
|
-> next(it)
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(8)test_function()
|
|
-> except StopIteration as ex:
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_generator[1]>(9)test_function()
|
|
-> if ex.value != 1:
|
|
(Pdb) continue
|
|
finished
|
|
"""
|
|
|
|
def test_pdb_return_command_for_coroutine():
|
|
"""Testing no unwindng stack on yield for coroutines for "return" command
|
|
|
|
>>> import asyncio
|
|
|
|
>>> async def test_coro():
|
|
... await asyncio.sleep(0)
|
|
... await asyncio.sleep(0)
|
|
... await asyncio.sleep(0)
|
|
|
|
>>> async def test_main():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... await test_coro()
|
|
|
|
>>> def test_function():
|
|
... loop = asyncio.new_event_loop()
|
|
... loop.run_until_complete(test_main())
|
|
... loop.close()
|
|
... asyncio.set_event_loop_policy(None)
|
|
... print("finished")
|
|
|
|
>>> with PdbTestInput(['step',
|
|
... 'step',
|
|
... 'next',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[2]>(3)test_main()
|
|
-> await test_coro()
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(1)test_coro()
|
|
-> async def test_coro():
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(2)test_coro()
|
|
-> await asyncio.sleep(0)
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_return_command_for_coroutine[1]>(3)test_coro()
|
|
-> await asyncio.sleep(0)
|
|
(Pdb) continue
|
|
finished
|
|
"""
|
|
|
|
def test_pdb_until_command_for_generator():
|
|
"""Testing no unwindng stack on yield for generators
|
|
for "until" command if target breakpoint is not reached
|
|
|
|
>>> def test_gen():
|
|
... yield 0
|
|
... yield 1
|
|
... yield 2
|
|
|
|
>>> def test_function():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... for i in test_gen():
|
|
... print(i)
|
|
... print("finished")
|
|
|
|
>>> with PdbTestInput(['step',
|
|
... 'until 4',
|
|
... 'step',
|
|
... 'step',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_until_command_for_generator[1]>(3)test_function()
|
|
-> for i in test_gen():
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(1)test_gen()
|
|
-> def test_gen():
|
|
(Pdb) until 4
|
|
0
|
|
1
|
|
> <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(4)test_gen()
|
|
-> yield 2
|
|
(Pdb) step
|
|
--Return--
|
|
> <doctest test.test_pdb.test_pdb_until_command_for_generator[0]>(4)test_gen()->2
|
|
-> yield 2
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_until_command_for_generator[1]>(4)test_function()
|
|
-> print(i)
|
|
(Pdb) continue
|
|
2
|
|
finished
|
|
"""
|
|
|
|
def test_pdb_until_command_for_coroutine():
|
|
"""Testing no unwindng stack for coroutines
|
|
for "until" command if target breakpoint is not reached
|
|
|
|
>>> import asyncio
|
|
|
|
>>> async def test_coro():
|
|
... print(0)
|
|
... await asyncio.sleep(0)
|
|
... print(1)
|
|
... await asyncio.sleep(0)
|
|
... print(2)
|
|
... await asyncio.sleep(0)
|
|
... print(3)
|
|
|
|
>>> async def test_main():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... await test_coro()
|
|
|
|
>>> def test_function():
|
|
... loop = asyncio.new_event_loop()
|
|
... loop.run_until_complete(test_main())
|
|
... loop.close()
|
|
... asyncio.set_event_loop_policy(None)
|
|
... print("finished")
|
|
|
|
>>> with PdbTestInput(['step',
|
|
... 'until 8',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_until_command_for_coroutine[2]>(3)test_main()
|
|
-> await test_coro()
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_until_command_for_coroutine[1]>(1)test_coro()
|
|
-> async def test_coro():
|
|
(Pdb) until 8
|
|
0
|
|
1
|
|
2
|
|
> <doctest test.test_pdb.test_pdb_until_command_for_coroutine[1]>(8)test_coro()
|
|
-> print(3)
|
|
(Pdb) continue
|
|
3
|
|
finished
|
|
"""
|
|
|
|
def test_pdb_next_command_in_generator_for_loop():
|
|
"""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]>(3)test_function()
|
|
-> for i in test_gen():
|
|
(Pdb) break test_gen
|
|
Breakpoint 6 at <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>:1
|
|
(Pdb) continue
|
|
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>(2)test_gen()
|
|
-> yield 0
|
|
(Pdb) next
|
|
value 0
|
|
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[0]>(3)test_gen()
|
|
-> return 1
|
|
(Pdb) next
|
|
Internal StopIteration: 1
|
|
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[1]>(3)test_function()
|
|
-> for i in test_gen():
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_next_command_in_generator_for_loop[1]>(5)test_function()
|
|
-> x = 123
|
|
(Pdb) continue
|
|
"""
|
|
|
|
def test_pdb_next_command_subiterator():
|
|
"""The next command in a generator with a subiterator.
|
|
|
|
>>> def test_subgenerator():
|
|
... yield 0
|
|
... return 1
|
|
|
|
>>> def test_gen():
|
|
... x = yield from test_subgenerator()
|
|
... return x
|
|
|
|
>>> def test_function():
|
|
... import pdb; pdb.Pdb(nosigint=True, readrc=False).set_trace()
|
|
... for i in test_gen():
|
|
... print('value', i)
|
|
... x = 123
|
|
|
|
>>> with PdbTestInput(['step',
|
|
... 'step',
|
|
... 'next',
|
|
... 'next',
|
|
... 'next',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(3)test_function()
|
|
-> for i in test_gen():
|
|
(Pdb) step
|
|
--Call--
|
|
> <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(1)test_gen()
|
|
-> def test_gen():
|
|
(Pdb) step
|
|
> <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(2)test_gen()
|
|
-> x = yield from test_subgenerator()
|
|
(Pdb) next
|
|
value 0
|
|
> <doctest test.test_pdb.test_pdb_next_command_subiterator[1]>(3)test_gen()
|
|
-> return x
|
|
(Pdb) next
|
|
Internal StopIteration: 1
|
|
> <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(3)test_function()
|
|
-> for i in test_gen():
|
|
(Pdb) next
|
|
> <doctest test.test_pdb.test_pdb_next_command_subiterator[2]>(5)test_function()
|
|
-> x = 123
|
|
(Pdb) continue
|
|
"""
|
|
|
|
def test_pdb_issue_20766():
|
|
"""Test for reference leaks when the SIGINT handler is set.
|
|
|
|
>>> def test_function():
|
|
... i = 1
|
|
... while i <= 2:
|
|
... sess = pdb.Pdb()
|
|
... sess.set_trace(sys._getframe())
|
|
... print('pdb %d: %s' % (i, sess._previous_sigint_handler))
|
|
... i += 1
|
|
|
|
>>> with PdbTestInput(['continue',
|
|
... 'continue']):
|
|
... test_function()
|
|
> <doctest test.test_pdb.test_pdb_issue_20766[0]>(6)test_function()
|
|
-> print('pdb %d: %s' % (i, sess._previous_sigint_handler))
|
|
(Pdb) continue
|
|
pdb 1: <built-in function default_int_handler>
|
|
> <doctest test.test_pdb.test_pdb_issue_20766[0]>(5)test_function()
|
|
-> sess.set_trace(sys._getframe())
|
|
(Pdb) continue
|
|
pdb 2: <built-in function default_int_handler>
|
|
"""
|
|
|
|
|
|
class PdbTestCase(unittest.TestCase):
|
|
def tearDown(self):
|
|
os_helper.unlink(os_helper.TESTFN)
|
|
|
|
def _run_pdb(self, pdb_args, commands):
|
|
self.addCleanup(os_helper.rmtree, '__pycache__')
|
|
cmd = [sys.executable, '-m', 'pdb'] + pdb_args
|
|
with subprocess.Popen(
|
|
cmd,
|
|
stdout=subprocess.PIPE,
|
|
stdin=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
env = {**os.environ, 'PYTHONIOENCODING': 'utf-8'}
|
|
) as proc:
|
|
stdout, stderr = proc.communicate(str.encode(commands))
|
|
stdout = stdout and bytes.decode(stdout)
|
|
stderr = stderr and bytes.decode(stderr)
|
|
return stdout, stderr
|
|
|
|
def run_pdb_script(self, script, commands):
|
|
"""Run 'script' lines with pdb and the pdb 'commands'."""
|
|
filename = 'main.py'
|
|
with open(filename, 'w') as f:
|
|
f.write(textwrap.dedent(script))
|
|
self.addCleanup(os_helper.unlink, filename)
|
|
return self._run_pdb([filename], commands)
|
|
|
|
def run_pdb_module(self, script, commands):
|
|
"""Runs the script code as part of a module"""
|
|
self.module_name = 't_main'
|
|
os_helper.rmtree(self.module_name)
|
|
main_file = self.module_name + '/__main__.py'
|
|
init_file = self.module_name + '/__init__.py'
|
|
os.mkdir(self.module_name)
|
|
with open(init_file, 'w') as f:
|
|
pass
|
|
with open(main_file, 'w') as f:
|
|
f.write(textwrap.dedent(script))
|
|
self.addCleanup(os_helper.rmtree, self.module_name)
|
|
return self._run_pdb(['-m', self.module_name], commands)
|
|
|
|
def _assert_find_function(self, file_content, func_name, expected):
|
|
with open(os_helper.TESTFN, 'wb') as f:
|
|
f.write(file_content)
|
|
|
|
expected = None if not expected else (
|
|
expected[0], os_helper.TESTFN, expected[1])
|
|
self.assertEqual(
|
|
expected, pdb.find_function(func_name, os_helper.TESTFN))
|
|
|
|
def test_find_function_empty_file(self):
|
|
self._assert_find_function(b'', 'foo', None)
|
|
|
|
def test_find_function_found(self):
|
|
self._assert_find_function(
|
|
"""\
|
|
def foo():
|
|
pass
|
|
|
|
def bœr():
|
|
pass
|
|
|
|
def quux():
|
|
pass
|
|
""".encode(),
|
|
'bœr',
|
|
('bœr', 4),
|
|
)
|
|
|
|
def test_find_function_found_with_encoding_cookie(self):
|
|
self._assert_find_function(
|
|
"""\
|
|
# coding: iso-8859-15
|
|
def foo():
|
|
pass
|
|
|
|
def bœr():
|
|
pass
|
|
|
|
def quux():
|
|
pass
|
|
""".encode('iso-8859-15'),
|
|
'bœr',
|
|
('bœr', 5),
|
|
)
|
|
|
|
def test_find_function_found_with_bom(self):
|
|
self._assert_find_function(
|
|
codecs.BOM_UTF8 + """\
|
|
def bœr():
|
|
pass
|
|
""".encode(),
|
|
'bœr',
|
|
('bœr', 1),
|
|
)
|
|
|
|
def test_issue7964(self):
|
|
# open the file as binary so we can force \r\n newline
|
|
with open(os_helper.TESTFN, 'wb') as f:
|
|
f.write(b'print("testing my pdb")\r\n')
|
|
cmd = [sys.executable, '-m', 'pdb', os_helper.TESTFN]
|
|
proc = subprocess.Popen(cmd,
|
|
stdout=subprocess.PIPE,
|
|
stdin=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
)
|
|
self.addCleanup(proc.stdout.close)
|
|
stdout, stderr = proc.communicate(b'quit\n')
|
|
self.assertNotIn(b'SyntaxError', stdout,
|
|
"Got a syntax error running test script under PDB")
|
|
|
|
def test_issue13183(self):
|
|
script = """
|
|
from bar import bar
|
|
|
|
def foo():
|
|
bar()
|
|
|
|
def nope():
|
|
pass
|
|
|
|
def foobar():
|
|
foo()
|
|
nope()
|
|
|
|
foobar()
|
|
"""
|
|
commands = """
|
|
from bar import bar
|
|
break bar
|
|
continue
|
|
step
|
|
step
|
|
quit
|
|
"""
|
|
bar = """
|
|
def bar():
|
|
pass
|
|
"""
|
|
with open('bar.py', 'w') as f:
|
|
f.write(textwrap.dedent(bar))
|
|
self.addCleanup(os_helper.unlink, 'bar.py')
|
|
stdout, stderr = self.run_pdb_script(script, commands)
|
|
self.assertTrue(
|
|
any('main.py(5)foo()->None' in l for l in stdout.splitlines()),
|
|
'Fail to step into the caller after a return')
|
|
|
|
def test_issue13120(self):
|
|
# Invoking "continue" on a non-main thread triggered an exception
|
|
# inside signal.signal.
|
|
|
|
with open(os_helper.TESTFN, 'wb') as f:
|
|
f.write(textwrap.dedent("""
|
|
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()""").encode('ascii'))
|
|
cmd = [sys.executable, '-u', os_helper.TESTFN]
|
|
proc = subprocess.Popen(cmd,
|
|
stdout=subprocess.PIPE,
|
|
stdin=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
env={**os.environ, 'PYTHONIOENCODING': 'utf-8'}
|
|
)
|
|
self.addCleanup(proc.stdout.close)
|
|
stdout, stderr = proc.communicate(b'cont\n')
|
|
self.assertNotIn(b'Error', stdout,
|
|
"Got an error running test script under PDB")
|
|
|
|
def test_issue36250(self):
|
|
|
|
with open(os_helper.TESTFN, 'wb') as f:
|
|
f.write(textwrap.dedent("""
|
|
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()""").encode('ascii'))
|
|
cmd = [sys.executable, '-u', os_helper.TESTFN]
|
|
proc = subprocess.Popen(cmd,
|
|
stdout=subprocess.PIPE,
|
|
stdin=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
env = {**os.environ, 'PYTHONIOENCODING': 'utf-8'}
|
|
)
|
|
self.addCleanup(proc.stdout.close)
|
|
stdout, stderr = proc.communicate(b'cont\ncont\n')
|
|
self.assertNotIn(b'Error', stdout,
|
|
"Got an error running test script under PDB")
|
|
|
|
def test_issue16180(self):
|
|
# A syntax error in the debuggee.
|
|
script = "def f: pass\n"
|
|
commands = ''
|
|
expected = "SyntaxError:"
|
|
stdout, stderr = self.run_pdb_script(script, commands)
|
|
self.assertIn(expected, stdout,
|
|
'\n\nExpected:\n{}\nGot:\n{}\n'
|
|
'Fail to handle a syntax error in the debuggee.'
|
|
.format(expected, stdout))
|
|
|
|
|
|
def test_readrc_kwarg(self):
|
|
script = textwrap.dedent("""
|
|
import pdb; pdb.Pdb(readrc=False).set_trace()
|
|
|
|
print('hello')
|
|
""")
|
|
|
|
save_home = os.environ.pop('HOME', None)
|
|
try:
|
|
with os_helper.temp_cwd():
|
|
with open('.pdbrc', 'w') as f:
|
|
f.write("invalid\n")
|
|
|
|
with open('main.py', 'w') as f:
|
|
f.write(script)
|
|
|
|
cmd = [sys.executable, 'main.py']
|
|
proc = subprocess.Popen(
|
|
cmd,
|
|
stdout=subprocess.PIPE,
|
|
stdin=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
)
|
|
with proc:
|
|
stdout, stderr = proc.communicate(b'q\n')
|
|
self.assertNotIn(b"NameError: name 'invalid' is not defined",
|
|
stdout)
|
|
|
|
finally:
|
|
if save_home is not None:
|
|
os.environ['HOME'] = save_home
|
|
|
|
def test_readrc_homedir(self):
|
|
save_home = os.environ.pop("HOME", None)
|
|
with os_helper.temp_dir() as temp_dir, patch("os.path.expanduser"):
|
|
rc_path = os.path.join(temp_dir, ".pdbrc")
|
|
os.path.expanduser.return_value = rc_path
|
|
try:
|
|
with open(rc_path, "w") as f:
|
|
f.write("invalid")
|
|
self.assertEqual(pdb.Pdb().rcLines[0], "invalid")
|
|
finally:
|
|
if save_home is not None:
|
|
os.environ["HOME"] = save_home
|
|
|
|
def test_header(self):
|
|
stdout = StringIO()
|
|
header = 'Nobody expects... blah, blah, blah'
|
|
with ExitStack() as resources:
|
|
resources.enter_context(patch('sys.stdout', stdout))
|
|
resources.enter_context(patch.object(pdb.Pdb, 'set_trace'))
|
|
pdb.set_trace(header=header)
|
|
self.assertEqual(stdout.getvalue(), header + '\n')
|
|
|
|
def test_run_module(self):
|
|
script = """print("SUCCESS")"""
|
|
commands = """
|
|
continue
|
|
quit
|
|
"""
|
|
stdout, stderr = self.run_pdb_module(script, commands)
|
|
self.assertTrue(any("SUCCESS" in l for l in stdout.splitlines()), stdout)
|
|
|
|
def test_module_is_run_as_main(self):
|
|
script = """
|
|
if __name__ == '__main__':
|
|
print("SUCCESS")
|
|
"""
|
|
commands = """
|
|
continue
|
|
quit
|
|
"""
|
|
stdout, stderr = self.run_pdb_module(script, commands)
|
|
self.assertTrue(any("SUCCESS" in l for l in stdout.splitlines()), stdout)
|
|
|
|
def test_breakpoint(self):
|
|
script = """
|
|
if __name__ == '__main__':
|
|
pass
|
|
print("SUCCESS")
|
|
pass
|
|
"""
|
|
commands = """
|
|
b 3
|
|
quit
|
|
"""
|
|
stdout, stderr = self.run_pdb_module(script, commands)
|
|
self.assertTrue(any("Breakpoint 1 at" in l for l in stdout.splitlines()), stdout)
|
|
self.assertTrue(all("SUCCESS" not in l for l in stdout.splitlines()), stdout)
|
|
|
|
def test_run_pdb_with_pdb(self):
|
|
commands = """
|
|
c
|
|
quit
|
|
"""
|
|
stdout, stderr = self._run_pdb(["-m", "pdb"], commands)
|
|
self.assertIn(
|
|
pdb._usage,
|
|
stdout.replace('\r', '') # remove \r for windows
|
|
)
|
|
|
|
def test_module_without_a_main(self):
|
|
module_name = 't_main'
|
|
os_helper.rmtree(module_name)
|
|
init_file = module_name + '/__init__.py'
|
|
os.mkdir(module_name)
|
|
with open(init_file, 'w') as f:
|
|
pass
|
|
self.addCleanup(os_helper.rmtree, module_name)
|
|
stdout, stderr = self._run_pdb(['-m', module_name], "")
|
|
self.assertIn("ImportError: No module named t_main.__main__",
|
|
stdout.splitlines())
|
|
|
|
def test_blocks_at_first_code_line(self):
|
|
script = """
|
|
#This is a comment, on line 2
|
|
|
|
print("SUCCESS")
|
|
"""
|
|
commands = """
|
|
quit
|
|
"""
|
|
stdout, stderr = self.run_pdb_module(script, commands)
|
|
self.assertTrue(any("__main__.py(4)<module>()"
|
|
in l for l in stdout.splitlines()), stdout)
|
|
|
|
def test_relative_imports(self):
|
|
self.module_name = 't_main'
|
|
os_helper.rmtree(self.module_name)
|
|
main_file = self.module_name + '/__main__.py'
|
|
init_file = self.module_name + '/__init__.py'
|
|
module_file = self.module_name + '/module.py'
|
|
self.addCleanup(os_helper.rmtree, self.module_name)
|
|
os.mkdir(self.module_name)
|
|
with open(init_file, 'w') as f:
|
|
f.write(textwrap.dedent("""
|
|
top_var = "VAR from top"
|
|
"""))
|
|
with open(main_file, 'w') as f:
|
|
f.write(textwrap.dedent("""
|
|
from . import top_var
|
|
from .module import var
|
|
from . import module
|
|
pass # We'll stop here and print the vars
|
|
"""))
|
|
with open(module_file, 'w') as f:
|
|
f.write(textwrap.dedent("""
|
|
var = "VAR from module"
|
|
var2 = "second var"
|
|
"""))
|
|
commands = """
|
|
b 5
|
|
c
|
|
p top_var
|
|
p var
|
|
p module.var2
|
|
quit
|
|
"""
|
|
stdout, _ = self._run_pdb(['-m', self.module_name], commands)
|
|
self.assertTrue(any("VAR from module" in l for l in stdout.splitlines()), stdout)
|
|
self.assertTrue(any("VAR from top" in l for l in stdout.splitlines()))
|
|
self.assertTrue(any("second var" in l for l in stdout.splitlines()))
|
|
|
|
def test_relative_imports_on_plain_module(self):
|
|
# Validates running a plain module. See bpo32691
|
|
self.module_name = 't_main'
|
|
os_helper.rmtree(self.module_name)
|
|
main_file = self.module_name + '/runme.py'
|
|
init_file = self.module_name + '/__init__.py'
|
|
module_file = self.module_name + '/module.py'
|
|
self.addCleanup(os_helper.rmtree, self.module_name)
|
|
os.mkdir(self.module_name)
|
|
with open(init_file, 'w') as f:
|
|
f.write(textwrap.dedent("""
|
|
top_var = "VAR from top"
|
|
"""))
|
|
with open(main_file, 'w') as f:
|
|
f.write(textwrap.dedent("""
|
|
from . import module
|
|
pass # We'll stop here and print the vars
|
|
"""))
|
|
with open(module_file, 'w') as f:
|
|
f.write(textwrap.dedent("""
|
|
var = "VAR from module"
|
|
"""))
|
|
commands = """
|
|
b 3
|
|
c
|
|
p module.var
|
|
quit
|
|
"""
|
|
stdout, _ = self._run_pdb(['-m', self.module_name + '.runme'], commands)
|
|
self.assertTrue(any("VAR from module" in l for l in stdout.splitlines()), stdout)
|
|
|
|
def test_errors_in_command(self):
|
|
commands = "\n".join([
|
|
'print(',
|
|
'debug print(',
|
|
'debug doesnotexist',
|
|
'c',
|
|
])
|
|
stdout, _ = self.run_pdb_script('pass', commands + '\n')
|
|
|
|
self.assertEqual(stdout.splitlines()[1:], [
|
|
'-> pass',
|
|
'(Pdb) *** SyntaxError: unexpected EOF while parsing',
|
|
|
|
'(Pdb) ENTERING RECURSIVE DEBUGGER',
|
|
'*** SyntaxError: unexpected EOF while parsing',
|
|
'LEAVING RECURSIVE DEBUGGER',
|
|
|
|
'(Pdb) ENTERING RECURSIVE DEBUGGER',
|
|
'> <string>(1)<module>()',
|
|
"((Pdb)) *** NameError: name 'doesnotexist' is not defined",
|
|
'LEAVING RECURSIVE DEBUGGER',
|
|
'(Pdb) ',
|
|
])
|
|
|
|
def load_tests(*args):
|
|
from test import test_pdb
|
|
suites = [
|
|
unittest.makeSuite(PdbTestCase),
|
|
doctest.DocTestSuite(test_pdb)
|
|
]
|
|
return unittest.TestSuite(suites)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|