diff options
Diffstat (limited to 'Lib/test/test_pdb.py')
| -rw-r--r-- | Lib/test/test_pdb.py | 1472 |
1 files changed, 127 insertions, 1345 deletions
diff --git a/Lib/test/test_pdb.py b/Lib/test/test_pdb.py index fcb7e4e..b98fe19 100644 --- a/Lib/test/test_pdb.py +++ b/Lib/test/test_pdb.py @@ -1,20 +1,84 @@ -# A test suite for pdb; not very comprehensive at the moment. +# A test suite for pdb; at the moment, this only validates skipping of +# specified test modules (RFE #5142). -import doctest -import os -import pdb +import imp import sys -import types +import os import unittest import subprocess import textwrap -from contextlib import ExitStack -from io import StringIO -from test import support +from test import test_support # This little helper class is essential for testing pdb under doctest. -from test.test_doctest import _FakeInput -from unittest.mock import patch +from test_doctest import _FakeInput + + +class PdbTestCase(unittest.TestCase): + + def run_pdb(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(test_support.unlink, filename) + cmd = [sys.executable, '-m', 'pdb', filename] + stdout = stderr = None + proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + stderr=subprocess.STDOUT, + ) + stdout, stderr = proc.communicate(commands) + proc.stdout.close() + proc.stdin.close() + return stdout, stderr + + 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(test_support.unlink, 'bar.py') + self.addCleanup(test_support.unlink, 'bar.pyc') + stdout, stderr = self.run_pdb(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_issue16180(self): + # A syntax error in the debuggee. + script = "def f: pass\n" + commands = '' + expected = "SyntaxError:" + stdout, stderr = self.run_pdb(script, commands) + self.assertIn(expected, stdout, + '\n\nExpected:\n{}\nGot:\n{}\n' + 'Fail to handle a syntax error in the debuggee.' + .format(expected, stdout)) class PdbTestInput(object): @@ -26,25 +90,25 @@ class PdbTestInput(object): 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 write(x): + print x + 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() + ... import pdb; pdb.Pdb().set_trace() ... pass >>> with PdbTestInput([ ... 'foo', ... 'bar', - ... 'for i in range(5): print(i)', + ... 'for i in range(5): write(i)', ... 'continue', ... ]): ... test_function(1, None) @@ -53,7 +117,7 @@ def test_pdb_displayhook(): (Pdb) foo 1 (Pdb) bar - (Pdb) for i in range(5): print(i) + (Pdb) for i in range(5): write(i) 0 1 2 @@ -62,162 +126,11 @@ def test_pdb_displayhook(): (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() + ... import pdb; pdb.Pdb().set_trace() ... print(1) ... print(2) ... print(3) @@ -249,8 +162,7 @@ def test_pdb_breakpoint_commands(): ... 'enable 1', ... 'clear 1', ... 'commands 2', - ... 'p "42"', - ... 'print("42", 7*6)', # Issue 18764 (not about breakpoints) + ... 'print 42', ... 'end', ... 'continue', # will stop at breakpoint 2 (line 4) ... 'clear', # clear all! @@ -266,11 +178,9 @@ def test_pdb_breakpoint_commands(): (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 @@ -283,7 +193,7 @@ def test_pdb_breakpoint_commands(): 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 + Deleted breakpoint 3 (Pdb) break Num Type Disp Enb Where 1 breakpoint keep no at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3 @@ -293,27 +203,23 @@ def test_pdb_breakpoint_commands(): (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 + Deleted breakpoint 1 (Pdb) commands 2 - (com) p "42" - (com) print("42", 7*6) + (com) print 42 (com) end (Pdb) continue 1 - '42' - 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 + Deleted breakpoint 4 > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(5)test_function() -> print(3) (Pdb) break @@ -323,177 +229,13 @@ def test_pdb_breakpoint_commands(): """ -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_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') + ... import pdb; pdb.Pdb(skip=['string*']).set_trace() + ... string.lower('FOO') >>> with PdbTestInput([ ... 'step', @@ -501,18 +243,18 @@ def test_pdb_skip_modules(): ... ]): ... skip_module() > <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module() - -> string.capwords('FOO') + -> string.lower('FOO') (Pdb) step --Return-- > <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()->None - -> string.capwords('FOO') + -> string.lower('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__) +mod = imp.new_module('module_to_skip') +exec 'def foo_pony(callback): x = 1; callback(); return None' in mod.__dict__ def test_pdb_skip_modules_with_callback(): @@ -521,7 +263,7 @@ def test_pdb_skip_modules_with_callback(): >>> def skip_module(): ... def callback(): ... return None - ... import pdb; pdb.Pdb(skip=['module_to_skip*'], nosigint=True, readrc=False).set_trace() + ... import pdb; pdb.Pdb(skip=['module_to_skip*']).set_trace() ... mod.foo_pony(callback) >>> with PdbTestInput([ @@ -562,7 +304,7 @@ 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) + ... import pdb, sys; inst = pdb.Pdb() ... inst.set_trace() ... inst.botframe = sys._getframe() # hackery to get the right botframe ... print(1) @@ -570,7 +312,15 @@ def test_pdb_continue_in_bottomframe(): ... print(3) ... print(4) - >>> with PdbTestInput([ # doctest: +ELLIPSIS + 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] + + >>> with PdbTestInput([ ... 'next', ... 'break 7', ... 'continue', @@ -585,7 +335,7 @@ def test_pdb_continue_in_bottomframe(): > <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 + Breakpoint 1 at <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>:7 (Pdb) continue 1 2 @@ -599,1006 +349,38 @@ def test_pdb_continue_in_bottomframe(): 4 """ +class ModuleInitTester(unittest.TestCase): -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): - support.unlink(support.TESTFN) - - def _run_pdb(self, pdb_args, commands): - self.addCleanup(support.rmtree, '__pycache__') - cmd = [sys.executable, '-m', 'pdb'] + pdb_args - with subprocess.Popen( - cmd, - stdout=subprocess.PIPE, - stdin=subprocess.PIPE, - stderr=subprocess.STDOUT, - ) 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(support.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' - support.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(support.rmtree, self.module_name) - return self._run_pdb(['-m', self.module_name], commands) - - def _assert_find_function(self, file_content, func_name, expected): - file_content = textwrap.dedent(file_content) - - with open(support.TESTFN, 'w') as f: - f.write(file_content) - - expected = None if not expected else ( - expected[0], support.TESTFN, expected[1]) - self.assertEqual( - expected, pdb.find_function(func_name, support.TESTFN)) - - def test_find_function_empty_file(self): - self._assert_find_function('', 'foo', None) - - def test_find_function_found(self): - self._assert_find_function( - """\ - def foo(): - pass - - def bar(): - pass - - def quux(): - pass - """, - 'bar', - ('bar', 4), - ) - - def test_issue7964(self): - # open the file as binary so we can force \r\n newline - with open(support.TESTFN, 'wb') as f: - f.write(b'print("testing my pdb")\r\n') - cmd = [sys.executable, '-m', 'pdb', support.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 + def test_filename_correct(self): """ - bar = """ - def bar(): - pass + In issue 7750, it was found that if the filename has a sequence that + resolves to an escape character in a Python string (such as \t), it + will be treated as the escaped character. """ - with open('bar.py', 'w') as f: - f.write(textwrap.dedent(bar)) - self.addCleanup(support.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(support.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', support.TESTFN] + # the test_fn must contain something like \t + # on Windows, this will create 'test_mod.py' in the current directory. + # on Unix, this will create '.\test_mod.py' in the current directory. + test_fn = '.\\test_mod.py' + code = 'print("testing pdb")' + with open(test_fn, 'w') as f: + f.write(code) + self.addCleanup(os.remove, test_fn) + cmd = [sys.executable, '-m', 'pdb', test_fn,] proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.STDOUT, ) - self.addCleanup(proc.stdout.close) - stdout, stderr = proc.communicate(b'cont\n') - self.assertNotIn('Error', stdout.decode(), - "Got an error running test script under PDB") - - def test_issue36250(self): - - with open(support.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() + stdout, stderr = proc.communicate('quit\n') + self.assertIn(code, stdout, "pdb munged the filename") - t = threading.Thread(target=start_pdb) - t.start() - pdb.Pdb(readrc=False).set_trace() - evt.set() - t.join()""").encode('ascii')) - cmd = [sys.executable, '-u', support.TESTFN] - proc = subprocess.Popen(cmd, - stdout=subprocess.PIPE, - stdin=subprocess.PIPE, - stderr=subprocess.STDOUT, - ) - self.addCleanup(proc.stdout.close) - stdout, stderr = proc.communicate(b'cont\ncont\n') - self.assertNotIn('Error', stdout.decode(), - "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 support.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("NameError: name 'invalid' is not defined", - stdout.decode()) - - 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 support.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' - support.rmtree(module_name) - init_file = module_name + '/__init__.py' - os.mkdir(module_name) - with open(init_file, 'w') as f: - pass - self.addCleanup(support.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' - support.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(support.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' - support.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(support.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('', commands + '\n') - - self.assertEqual(stdout.splitlines()[1:], [ - '(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): +def test_main(): from test import test_pdb - suites = [ - unittest.makeSuite(PdbTestCase), - doctest.DocTestSuite(test_pdb) - ] - return unittest.TestSuite(suites) - + test_support.run_doctest(test_pdb, verbosity=True) + test_support.run_unittest( + PdbTestCase, + ModuleInitTester) if __name__ == '__main__': - unittest.main() + test_main() |