Skip to content

C
cpython
Commit c60eca06 authored by Serhiy Storchaka's avatar Serhiy Storchaka Committed by GitHub
Browse files
Options

[2.7] bpo-32416: Refactor tests for the f_lineno setter and add new tests. (GH-4991). (#5017) 

(cherry picked from commit 53f91356)
parent 8b9995f2
Hide whitespace changes
Inline Side-by-side
Showing with 395 additions and 235 deletions
Lib/test/test_sys_settrace.py
View file @ c60eca06
...@@ -5,6 +5,19 @@ import unittest ...@@ -5,6 +5,19 @@ import unittest
import sys import sys
import difflib import difflib
import gc import gc
from functools import wraps
class tracecontext:
"""Contex manager that traces its enter and exit."""
def __init__(self, output, value):
self.output = output
self.value = value
def __enter__(self):
self.output.append(self.value)
def __exit__(self, *exc_info):
self.output.append(-self.value)
# A very basic example. If this fails, we're in deep trouble. # A very basic example. If this fails, we're in deep trouble.
def basic(): def basic():
...@@ -467,14 +480,12 @@ class RaisingTraceFuncTestCase(unittest.TestCase): ...@@ -467,14 +480,12 @@ class RaisingTraceFuncTestCase(unittest.TestCase):
# command (aka. "Set next statement"). # command (aka. "Set next statement").
class JumpTracer: class JumpTracer:
"""Defines a trace function that jumps from one place to another, """Defines a trace function that jumps from one place to another."""
with the source and destination lines of the jump being defined by
the 'jump' property of the function under test."""
def __init__(self, function): def __init__(self, function, jumpFrom, jumpTo):
self.function = function self.function = function
self.jumpFrom = function.jump[0] self.jumpFrom = jumpFrom
self.jumpTo = function.jump[1] self.jumpTo = jumpTo
self.done = False self.done = False
def trace(self, frame, event, arg): def trace(self, frame, event, arg):
...@@ -490,288 +501,441 @@ class JumpTracer: ...@@ -490,288 +501,441 @@ class JumpTracer:
self.done = True self.done = True
return self.trace return self.trace
# The first set of 'jump' tests are for things that are allowed: # This verifies the line-numbers-must-be-integers rule.
def no_jump_to_non_integers(output):
try:
output.append(2)
except ValueError as e:
output.append('integer' in str(e))
# This verifies that you can't set f_lineno via _getframe or similar
# trickery.
def no_jump_without_trace_function():
try:
previous_frame = sys._getframe().f_back
previous_frame.f_lineno = previous_frame.f_lineno
except ValueError as e:
# This is the exception we wanted; make sure the error message
# talks about trace functions.
if 'trace' not in str(e):
raise
else:
# Something's wrong - the expected exception wasn't raised.
raise AssertionError("Trace-function-less jump failed to fail")
def jump_simple_forwards(output):
output.append(1)
output.append(2)
output.append(3)
jump_simple_forwards.jump = (1, 3) class JumpTestCase(unittest.TestCase):
jump_simple_forwards.output = [3] def setUp(self):
self.addCleanup(sys.settrace, sys.gettrace())
sys.settrace(None)
def jump_simple_backwards(output): def compare_jump_output(self, expected, received):
output.append(1) if received != expected:
output.append(2) self.fail( "Outputs don't match:\n" +
"Expected: " + repr(expected) + "\n" +
"Received: " + repr(received))
jump_simple_backwards.jump = (2, 1) def run_test(self, func, jumpFrom, jumpTo, expected, error=None):
jump_simple_backwards.output = [1, 1, 2] tracer = JumpTracer(func, jumpFrom, jumpTo)
sys.settrace(tracer.trace)
output = []
if error is None:
func(output)
else:
with self.assertRaisesRegexp(*error):
func(output)
sys.settrace(None)
self.compare_jump_output(expected, output)
def jump_test(jumpFrom, jumpTo, expected, error=None):
"""Decorator that creates a test that makes a jump
from one place to another in the following code.
"""
def decorator(func):
@wraps(func)
def test(self):
# +1 to compensate a decorator line
self.run_test(func, jumpFrom+1, jumpTo+1, expected, error)
return test
return decorator
## The first set of 'jump' tests are for things that are allowed:
@jump_test(1, 3, [3])
def test_jump_simple_forwards(output):
output.append(1)
output.append(2)
output.append(3)
def jump_out_of_block_forwards(output): @jump_test(2, 1, [1, 1, 2])
for i in 1, 2: def test_jump_simple_backwards(output):
output.append(1)
output.append(2) output.append(2)
for j in [3]: # Also tests jumping over a block
output.append(4)
output.append(5)
jump_out_of_block_forwards.jump = (3, 5) @jump_test(3, 5, [2, 5])
jump_out_of_block_forwards.output = [2, 5] def test_jump_out_of_block_forwards(output):
for i in 1, 2:
output.append(2)
for j in [3]: # Also tests jumping over a block
output.append(4)
output.append(5)
@jump_test(6, 1, [1, 3, 5, 1, 3, 5, 6, 7])
def test_jump_out_of_block_backwards(output):
output.append(1)
for i in [1]:
output.append(3)
for j in [2]: # Also tests jumping over a block
output.append(5)
output.append(6)
output.append(7)
def jump_out_of_block_backwards(output): @jump_test(1, 2, [3])
output.append(1) def test_jump_to_codeless_line(output):
for i in [1]: output.append(1)
# Jumping to this line should skip to the next one.
output.append(3) output.append(3)
for j in [2]: # Also tests jumping over a block
output.append(5)
output.append(6)
output.append(7)
jump_out_of_block_backwards.jump = (6, 1) @jump_test(2, 2, [1, 2, 3])
jump_out_of_block_backwards.output = [1, 3, 5, 1, 3, 5, 6, 7] def test_jump_to_same_line(output):
output.append(1)
output.append(2)
output.append(3)
def jump_to_codeless_line(output): # Tests jumping within a finally block, and over one.
output.append(1) @jump_test(4, 9, [2, 9])
# Jumping to this line should skip to the next one. def test_jump_in_nested_finally(output):
output.append(3) try:
output.append(2)
finally:
output.append(4)
try:
output.append(6)
finally:
output.append(8)
output.append(9)
@jump_test(6, 7, [2, 7], (ZeroDivisionError, ''))
def test_jump_in_nested_finally_2(output):
try:
output.append(2)
1/0
return
finally:
output.append(6)
output.append(7)
output.append(8)
jump_to_codeless_line.jump = (1, 2) @jump_test(6, 11, [2, 11], (ZeroDivisionError, ''))
jump_to_codeless_line.output = [3] def test_jump_in_nested_finally_3(output):
try:
output.append(2)
1/0
return
finally:
output.append(6)
try:
output.append(8)
finally:
output.append(10)
output.append(11)
output.append(12)
@jump_test(3, 4, [1, 4])
def test_jump_infinite_while_loop(output):
output.append(1)
while True:
output.append(3)
output.append(4)
def jump_to_same_line(output): @jump_test(2, 3, [1, 3])
output.append(1) def test_jump_forwards_out_of_with_block(output):
output.append(2) with tracecontext(output, 1):
output.append(3) output.append(2)
output.append(3)
jump_to_same_line.jump = (2, 2) @jump_test(3, 1, [1, 2, 1, 2, 3, -2])
jump_to_same_line.output = [1, 2, 3] def test_jump_backwards_out_of_with_block(output):
output.append(1)
with tracecontext(output, 2):
output.append(3)
# Tests jumping within a finally block, and over one. @jump_test(2, 5, [5])
def jump_in_nested_finally(output): def test_jump_forwards_out_of_try_finally_block(output):
try:
output.append(2)
finally:
output.append(4)
try: try:
output.append(6) output.append(2)
finally: finally:
output.append(8) output.append(4)
output.append(9) output.append(5)
jump_in_nested_finally.jump = (4, 9)
jump_in_nested_finally.output = [2, 9]
def jump_infinite_while_loop(output): @jump_test(3, 1, [1, 1, 3, 5])
output.append(1) def test_jump_backwards_out_of_try_finally_block(output):
while 1: output.append(1)
output.append(2) try:
output.append(3) output.append(3)
finally:
output.append(5)
jump_infinite_while_loop.jump = (3, 4) @jump_test(2, 6, [6])
jump_infinite_while_loop.output = [1, 3] def test_jump_forwards_out_of_try_except_block(output):
try:
output.append(2)
except:
output.append(4)
raise
output.append(6)
# The second set of 'jump' tests are for things that are not allowed: @jump_test(3, 1, [1, 1, 3])
def test_jump_backwards_out_of_try_except_block(output):
output.append(1)
try:
output.append(3)
except:
output.append(5)
raise
def no_jump_too_far_forwards(output): @jump_test(5, 7, [4, 7, 8])
try: def test_jump_between_except_blocks(output):
output.append(2) try:
output.append(3) 1/0
except ValueError, e: except ZeroDivisionError:
output.append('after' in str(e)) output.append(4)
output.append(5)
except FloatingPointError:
output.append(7)
output.append(8)
no_jump_too_far_forwards.jump = (3, 6) @jump_test(5, 6, [4, 6, 7])
no_jump_too_far_forwards.output = [2, True] def test_jump_within_except_block(output):
try:
1/0
except:
output.append(4)
output.append(5)
output.append(6)
output.append(7)
def no_jump_too_far_backwards(output): @jump_test(8, 11, [1, 3, 5, 11, 12])
try: def test_jump_out_of_complex_nested_blocks(output):
output.append(2) output.append(1)
output.append(3) for i in [1]:
except ValueError, e: output.append(3)
output.append('before' in str(e)) for j in [1, 2]:
output.append(5)
try:
for k in [1, 2]:
output.append(8)
finally:
output.append(10)
output.append(11)
output.append(12)
@jump_test(3, 5, [1, 2, 5])
def test_jump_out_of_with_assignment(output):
output.append(1)
with tracecontext(output, 2) \
as x:
output.append(4)
output.append(5)
no_jump_too_far_backwards.jump = (3, -1) @jump_test(3, 6, [1, 6, 8, 9])
no_jump_too_far_backwards.output = [2, True] def test_jump_over_return_in_try_finally_block(output):
output.append(1)
try:
output.append(3)
if not output: # always false
return
output.append(6)
finally:
output.append(8)
output.append(9)
# Test each kind of 'except' line. @jump_test(5, 8, [1, 3, 8, 10, 11, 13])
def no_jump_to_except_1(output): def test_jump_over_break_in_try_finally_block(output):
try: output.append(1)
while True:
output.append(3)
try:
output.append(5)
if not output: # always false
break
output.append(8)
finally:
output.append(10)
output.append(11)
break
output.append(13)
# The second set of 'jump' tests are for things that are not allowed:
@jump_test(2, 3, [1], (ValueError, 'after'))
def test_no_jump_too_far_forwards(output):
output.append(1)
output.append(2) output.append(2)
except:
e = sys.exc_info()[1]
output.append('except' in str(e))
no_jump_to_except_1.jump = (2, 3)
no_jump_to_except_1.output = [True]
def no_jump_to_except_2(output): @jump_test(2, -2, [1], (ValueError, 'before'))
try: def test_no_jump_too_far_backwards(output):
output.append(1)
output.append(2) output.append(2)
except ValueError:
e = sys.exc_info()[1]
output.append('except' in str(e))
no_jump_to_except_2.jump = (2, 3) # Test each kind of 'except' line.
no_jump_to_except_2.output = [True] @jump_test(2, 3, [4], (ValueError, 'except'))
def test_no_jump_to_except_1(output):
try:
output.append(2)
except:
output.append(4)
raise
@jump_test(2, 3, [4], (ValueError, 'except'))
def test_no_jump_to_except_2(output):
try:
output.append(2)
except ValueError:
output.append(4)
raise
def no_jump_to_except_3(output): @jump_test(2, 3, [4], (ValueError, 'except'))
try: def test_no_jump_to_except_3(output):
output.append(2) try:
except ValueError, e: output.append(2)
output.append('except' in str(e)) except ValueError as e:
output.append(4)
raise e
no_jump_to_except_3.jump = (2, 3) @jump_test(2, 3, [4], (ValueError, 'except'))
no_jump_to_except_3.output = [True] def test_no_jump_to_except_4(output):
try:
output.append(2)
except (ValueError, RuntimeError) as e:
output.append(4)
raise e
def no_jump_to_except_4(output): @jump_test(1, 3, [], (ValueError, 'into'))
try: def test_no_jump_forwards_into_for_block(output):
output.append(2) output.append(1)
except (ValueError, RuntimeError), e: for i in 1, 2:
output.append('except' in str(e)) output.append(3)
no_jump_to_except_4.jump = (2, 3) @jump_test(3, 2, [2, 2], (ValueError, 'into'))
no_jump_to_except_4.output = [True] def test_no_jump_backwards_into_for_block(output):
for i in 1, 2:
output.append(2)
output.append(3)
def no_jump_forwards_into_block(output): @jump_test(2, 4, [], (ValueError, 'into'))
try: def test_no_jump_forwards_into_while_block(output):
i = 1
output.append(2) output.append(2)
for i in 1, 2: while i <= 2:
output.append(4) output.append(4)
except ValueError, e: i += 1
output.append('into' in str(e))
no_jump_forwards_into_block.jump = (2, 4) @jump_test(5, 3, [3, 3], (ValueError, 'into'))
no_jump_forwards_into_block.output = [True] def test_no_jump_backwards_into_while_block(output):
i = 1
while i <= 2:
output.append(3)
i += 1
output.append(5)
def no_jump_backwards_into_block(output): @jump_test(1, 3, [], (ValueError, 'into'))
try: def test_no_jump_forwards_into_with_block(output):
for i in 1, 2: output.append(1)
with tracecontext(output, 2):
output.append(3) output.append(3)
output.append(4)
except ValueError, e:
output.append('into' in str(e))
no_jump_backwards_into_block.jump = (4, 3) @jump_test(3, 2, [1, 2, -1], (ValueError, 'into'))
no_jump_backwards_into_block.output = [3, 3, True] def test_no_jump_backwards_into_with_block(output):
with tracecontext(output, 1):
output.append(2)
output.append(3)
def no_jump_into_finally_block(output): @jump_test(1, 3, [], (ValueError, 'into'))
try: def test_no_jump_forwards_into_try_finally_block(output):
output.append(1)
try: try:
output.append(3) output.append(3)
x = 1
finally: finally:
output.append(6) output.append(5)
except ValueError, e:
output.append('finally' in str(e))
no_jump_into_finally_block.jump = (4, 6) @jump_test(5, 2, [2, 4], (ValueError, 'into'))
no_jump_into_finally_block.output = [3, 6, True] # The 'finally' still runs def test_no_jump_backwards_into_try_finally_block(output):
try:
output.append(2)
finally:
output.append(4)
output.append(5)
def no_jump_out_of_finally_block(output): @jump_test(1, 3, [], (ValueError, 'into'))
try: def test_no_jump_forwards_into_try_except_block(output):
output.append(1)
try: try:
output.append(3) output.append(3)
finally: except:
output.append(5) output.append(5)
output.append(6) raise
except ValueError, e:
output.append('finally' in str(e))
no_jump_out_of_finally_block.jump = (5, 1) @jump_test(6, 2, [2], (ValueError, 'into'))
no_jump_out_of_finally_block.output = [3, True] def test_no_jump_backwards_into_try_except_block(output):
try:
output.append(2)
except:
output.append(4)
raise
output.append(6)
# This verifies the line-numbers-must-be-integers rule. @jump_test(3, 6, [2, 5, 6], (ValueError, 'finally'))
def no_jump_to_non_integers(output): def test_no_jump_into_finally_block(output):
try: try:
output.append(2) output.append(2)
except ValueError, e: output.append(3)
output.append('integer' in str(e)) finally: # still executed if the jump is failed
output.append(5)
output.append(6)
output.append(7)
no_jump_to_non_integers.jump = (2, "Spam") @jump_test(1, 5, [], (ValueError, 'finally'))
no_jump_to_non_integers.output = [True] def test_no_jump_into_finally_block_2(output):
output.append(1)
try:
output.append(3)
finally:
output.append(5)
def jump_across_with(output): @jump_test(5, 1, [1, 3], (ValueError, 'finally'))
with open(test_support.TESTFN, "wb") as fp: def test_no_jump_out_of_finally_block(output):
pass output.append(1)
with open(test_support.TESTFN, "wb") as fp: try:
pass output.append(3)
jump_across_with.jump = (1, 3) finally:
jump_across_with.output = [] output.append(5)
# This verifies that you can't set f_lineno via _getframe or similar @jump_test(2, 4, [1, 4, 5, -4])
# trickery. def test_jump_across_with(output):
def no_jump_without_trace_function(): output.append(1)
try: with tracecontext(output, 2):
previous_frame = sys._getframe().f_back output.append(3)
previous_frame.f_lineno = previous_frame.f_lineno with tracecontext(output, 4):
except ValueError, e: output.append(5)
# This is the exception we wanted; make sure the error message
# talks about trace functions.
if 'trace' not in str(e):
raise
else:
# Something's wrong - the expected exception wasn't raised.
raise RuntimeError, "Trace-function-less jump failed to fail"
@jump_test(3, 5, [1, 2, -2], (ValueError, 'into'))
def test_jump_across_with_2(output):
output.append(1)
with tracecontext(output, 2):
output.append(3)
with tracecontext(output, 4):
output.append(5)
class JumpTestCase(unittest.TestCase): def test_no_jump_to_non_integers(self):
def compare_jump_output(self, expected, received): self.run_test(no_jump_to_non_integers, 2, "Spam", [True])
if received != expected:
self.fail( "Outputs don't match:\n" +
"Expected: " + repr(expected) + "\n" +
"Received: " + repr(received))
def run_test(self, func): def test_no_jump_without_trace_function(self):
tracer = JumpTracer(func) # Must set sys.settrace(None) in setUp(), else condition is not
sys.settrace(tracer.trace) # triggered.
output = []
func(output)
sys.settrace(None)
self.compare_jump_output(func.output, output)
def test_01_jump_simple_forwards(self):
self.run_test(jump_simple_forwards)
def test_02_jump_simple_backwards(self):
self.run_test(jump_simple_backwards)
def test_03_jump_out_of_block_forwards(self):
self.run_test(jump_out_of_block_forwards)
def test_04_jump_out_of_block_backwards(self):
self.run_test(jump_out_of_block_backwards)
def test_05_jump_to_codeless_line(self):
self.run_test(jump_to_codeless_line)
def test_06_jump_to_same_line(self):
self.run_test(jump_to_same_line)
def test_07_jump_in_nested_finally(self):
self.run_test(jump_in_nested_finally)
def test_jump_infinite_while_loop(self):
self.run_test(jump_infinite_while_loop)
def test_08_no_jump_too_far_forwards(self):
self.run_test(no_jump_too_far_forwards)
def test_09_no_jump_too_far_backwards(self):
self.run_test(no_jump_too_far_backwards)
def test_10_no_jump_to_except_1(self):
self.run_test(no_jump_to_except_1)
def test_11_no_jump_to_except_2(self):
self.run_test(no_jump_to_except_2)
def test_12_no_jump_to_except_3(self):
self.run_test(no_jump_to_except_3)
def test_13_no_jump_to_except_4(self):
self.run_test(no_jump_to_except_4)
def test_14_no_jump_forwards_into_block(self):
self.run_test(no_jump_forwards_into_block)
def test_15_no_jump_backwards_into_block(self):
self.run_test(no_jump_backwards_into_block)
def test_16_no_jump_into_finally_block(self):
self.run_test(no_jump_into_finally_block)
def test_17_no_jump_out_of_finally_block(self):
self.run_test(no_jump_out_of_finally_block)
def test_18_no_jump_to_non_integers(self):
self.run_test(no_jump_to_non_integers)
def test_19_no_jump_without_trace_function(self):
no_jump_without_trace_function() no_jump_without_trace_function()
def test_jump_across_with(self):
self.addCleanup(test_support.unlink, test_support.TESTFN)
self.run_test(jump_across_with)
def test_20_large_function(self): def test_large_function(self):
d = {} d = {}
exec("""def f(output): # line 0 exec("""def f(output): # line 0
x = 0 # line 1 x = 0 # line 1
...@@ -783,10 +947,7 @@ class JumpTestCase(unittest.TestCase): ...@@ -783,10 +947,7 @@ class JumpTestCase(unittest.TestCase):
output.append(x) # line 1007 output.append(x) # line 1007
return""" % ('\n' * 1000,), d) return""" % ('\n' * 1000,), d)
f = d['f'] f = d['f']
self.run_test(f, 2, 1007, [0])
f.jump = (2, 1007)
f.output = [0]
self.run_test(f)
def test_jump_to_firstlineno(self): def test_jump_to_firstlineno(self):
# This tests that PDB can jump back to the first line in a # This tests that PDB can jump back to the first line in a
...@@ -800,8 +961,7 @@ output.append(4) ...@@ -800,8 +961,7 @@ output.append(4)
""", "<fake module>", "exec") """, "<fake module>", "exec")
class fake_function: class fake_function:
func_code = code func_code = code
jump = (2, 0) tracer = JumpTracer(fake_function, 2, 0)
tracer = JumpTracer(fake_function)
sys.settrace(tracer.trace) sys.settrace(tracer.trace)
namespace = {"output": []} namespace = {"output": []}
exec code in namespace exec code in namespace
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7