def test_numpy_random():
code = """\
import numpy as np
x = np.random.normal(size=3)
"""
tracer = TraceRunner()
original_report = tracer.trace_code(code)
for _ in range(5):
report = tracer.trace_code(code)
assert original_report == report
def test_error():
code = """\
from __future__ import print_function
class Foo(object):
def __repr__(self):
raise RuntimeError('Bad representation.')
def create_foo():
return Foo()
print('Start.')
foo = create_foo()
print('End.')
"""
expected_report = """\
return <Foo object>
print('Start.')
print('End.')
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert trim_report(expected_report) == trim_report(report)
def test_chained_function(self):
# SETUP
code = """\
def foo(x):
return x + 10
def bar(y):
return foo(y) - 2
n = bar(3)
"""
expected_report = """\
x = 3
return 13
y = 3
return 11
n = 11 """
tracer = TraceRunner()
# EXEC
report = tracer.trace_code(code)
# VERIFY
self.assertReportEqual(expected_report, report)
def test_repr_call():
code = """\
class Dog(object):
def __init__(self, name):
self.name = name
def __repr__(self):
return 'Dog(%r)' % self.name
dog1 = Dog('Spot')
dog2 = Dog('Fido')
s = repr(dog2)
"""
expected_report = """\
name = 'Spot' | name = 'Fido'
self.name = 'Spot' | self.name = 'Fido'
return "Dog('Fido')"
dog1 = Dog('Spot')
dog2 = Dog('Fido')
s = "Dog('Fido')"
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert trim_report(expected_report) == trim_report(report)
def test_incomplete_iterator():
code = """\
def gen(n):
state = 'Starting'
try:
for i in range(n):
yield i
finally:
state = 'Done'
g = gen(999)
x = next(g)
"""
expected_report = """\
n = 999
state = 'Starting'
i = 0
yield 0 GeneratorExit
state = 'Done'
x = 0"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert report == expected_report
def test_incomplete_iterator_prints():
code = """\
def gen(n):
print('Starting')
try:
for i in range(n):
yield i
finally:
print('Done')
g = gen(999)
x = next(g)
"""
expected_report = """\
n = 999
print('Starting')
i = 0
yield 0 GeneratorExit
print('Done')
x = 0"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert report == expected_report
def test_nested_reraise():
code = """\
x = 2
try:
try:
raise RuntimeError('Bad stuff happened.')
except:
raise
except:
raise
"""
expected_report = """\
x = 2
RuntimeError: Bad stuff happened.
RuntimeError: Bad stuff happened.
RuntimeError: Bad stuff happened.
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert expected_report == trim_report(report)
def test_recursion_exception(self):
# SETUP
code = """\
def f(n):
m = n - 1
if m == 0:
raise RuntimeError('Invalid n.')
return f(m)
r = f(2)
"""
expected_report = """\
n = 2 | n = 1
m = 1 | m = 0
|
| RuntimeError: Invalid n.
RuntimeError: Invalid n. |
RuntimeError: Invalid n. """
tracer = TraceRunner()
# EXEC
report = tracer.trace_code(code)
# VERIFY
self.assertReportEqual(expected_report, report)
def test_recursion(self):
# SETUP
code = """\
def f(n):
r = 1
for i in range(n):
r += f(i)
return r
r = f(2)
"""
expected_report = """\
n = 2 | n = 0 | n = 1 | n = 0
r = 1 | r = 1 | r = 1 | r = 1
i = 0 | i = 1 | | i = 0 |
r = 2 | r = 4 | | r = 2 |
return 4 | return 1 | return 2 | return 1
r = 4 """
tracer = TraceRunner()
# EXEC
report = tracer.trace_code(code)
# VERIFY
self.assertReportEqual(expected_report, report)
def test_function(self):
# SETUP
code = """\
def foo(x):
a = x
b = x + 1
return b
m = 2
n = foo(m)
"""
expected_report = """\
x = 2
a = 2
b = 3
return 3
m = 2
n = 3 """
tracer = TraceRunner()
# EXEC
report = tracer.trace_code(code)
# VERIFY
self.assertReportEqual(expected_report, report)
def test_repr_return():
code = """\
class Foo:
def __init__(self, x):
self.x = x
def __repr__(self):
return 'Foo({!r})'.format(self.x)
def bar(x):
return Foo(x)
y = bar(23)
"""
expected_report = """\
x = 23
self.x = 23
x = 23
return Foo(23)
y = Foo(23)
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert trim_report(expected_report) == trim_report(report)
def test_repr():
code = """\
class Dog(object):
def __init__(self, name):
self.name = name
def __repr__(self):
return 'Dog(%r)' % self.name
dog = Dog('Spot')
animal = dog
"""
expected_report = """\
name = 'Spot'
self.name = 'Spot'
dog = Dog('Spot')
animal = Dog('Spot') """
tracer = TraceRunner()
report = tracer.trace_code(code)
assert trim_report(expected_report) == trim_report(report)
def test_loop_target_list_attribute_complex():
code = """\
class Foo:
def do_foo(self, x):
self.state = [None]
for self.state[0] in range(x):
print(self.state)
foo = Foo()
foo.do_foo(3)
"""
expected_report = """\
x = 3
self.state = [None]
| |
print('[0]') | print('[1]') | print('[2]')
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert report == expected_report
def test_yield(self):
# SETUP
code = """\
def foo(x):
a = x
yield a
a += 2
yield a
n = foo(10)
s = sum(n)
"""
expected_report = """\
x = 10
a = 10
yield 10
a = 12
yield 12
s = 22 """
tracer = TraceRunner()
# EXEC
report = tracer.trace_code(code)
# VERIFY
self.assertReportEqual(expected_report, report)
def test_infinite_loop_in_repr(self):
# SETUP
# __repr__() doesn't display messages, so message counter doesn't change.
code = """\
class Foo(object):
def __repr__(self):
while True:
x = 42
s = Foo()
s2 = 'x'
"""
# The infinite loop fails silently inside __repr__().
expected_report = """\
s2 = 'x'
"""
tracer = TraceRunner()
# EXEC
report = tracer.trace_code(code)
# VERIFY
self.assertReportEqual(expected_report, report)
def test_repr_lambda():
code = """\
class Foo:
def __init__(self, x):
self.x = x
def __repr__(self):
return 'Foo({!r})'.format(self.x)
y = list(map(lambda n: Foo(n), range(2)))
"""
expected_report = """\
x = 0 | x = 1
self.x = 0 | self.x = 1
(0 => Foo(0)) | (1 => Foo(1)) | y = [Foo(0), Foo(1)]
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert trim_report(expected_report) == trim_report(report)
def test_repr_yield_tuple():
code = """\
class Foo:
def __init__(self, x):
self.x = x
def __repr__(self):
return 'Foo({!r})'.format(self.x)
def bar(x):
yield x, Foo(x)
y = list(bar(23))
"""
expected_report = """\
x = 23
self.x = 23
x = 23
yield (23, Foo(23))
y = [(23, Foo(23))]
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert trim_report(expected_report) == trim_report(report)
def test_infinite_loop_pass_in_function():
code = """\
def foo():
while True:
pass
foo()
"""
expected_report1 = """\
RuntimeError: live coding message limit exceeded
RuntimeError: live coding message limit exceeded"""
expected_report2 = """\
RuntimeError: live coding message limit exceeded
RuntimeError: live coding message limit exceeded"""
tracer = TraceRunner()
tracer.message_limit = 3
report = tracer.trace_code(code)
assert report in (expected_report1, expected_report2)
def test_assign_assignment():
code = """\
a = b = 2
"""
expected_report = """\
a = b = 2
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert expected_report == trim_report(report)
def test_docstring():
code = """\
''
"""
expected_report = """\
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert expected_report == trim_report(report)
def test_assign_generator_unpacked():
code = """\
a, b = (3*i for i in range(2))
"""
expected_report = """\
(a, b) = (0, 3)
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert expected_report == trim_report(report)
def test_assign_tuple_list():
code = """\
a, [b, c] = (1, (2, 3))
"""
expected_report = """\
(a, (b, c)) = (1, (2, 3))
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert expected_report == trim_report(report)
def test_loop_target_list():
code = """\
for a,b in [(1,2)]:
c = a + b
"""
expected_report = """\
a = 1 | b = 2
c = 3"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert report == expected_report
def test_infinite_loop_pass():
code = """\
while True:
pass
"""
expected_report = """\
RuntimeError: live coding message limit exceeded"""
tracer = TraceRunner()
tracer.message_limit = 3
report = tracer.trace_code(code)
assert report in (expected_report + '\n', '\n' + expected_report)
def test_runtime_error():
code = """\
x = 2
raise RuntimeError('Bad stuff happened.')
"""
expected_report = """\
x = 2
RuntimeError: Bad stuff happened.
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert expected_report == trim_report(report)
def test_assign_starred():
code = """\
a, *b = (1, 2, 3)
print(b)
"""
expected_report = """\
(a, *b) = (1, 2, 3)
print('[2, 3]')
"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert expected_report == trim_report(report)
def test_call_on_literal(self):
# SETUP
code = """\
s = 'abc'.replace('a', 'A')
"""
expected_report = """\
s = 'Abc' """
tracer = TraceRunner()
# EXEC
report = tracer.trace_code(code)
# VERIFY
self.assertReportEqual(expected_report, report)
def test_lambda(self):
# SETUP
code = """\
f = lambda n: n + 1
x = f(10)
"""
expected_report = """\
(10 => 11)
x = 11 """
tracer = TraceRunner()
# EXEC
report = tracer.trace_code(code)
# VERIFY
self.assertReportEqual(expected_report, report)
def test_print():
code = """\
s = 'x'
print(s)
"""
expected_report_python = """\
s = 'x'
print('x')
"""
expected_report = expected_report_python
tracer = TraceRunner()
report = tracer.trace_code(code)
assert expected_report == trim_report(report)
def test_loop_starred_target_list():
code = """\
words = ['foo', 'bar']
for (head, *tail) in words:
print(head, tail)
"""
expected_report = """\
words = ['foo', 'bar']
head = 'f' | tail = ['o', 'o'] | head = 'b' | tail = ['a', 'r']
print("f ['o', 'o']") | print("b ['a', 'r']")"""
tracer = TraceRunner()
report = tracer.trace_code(code)
assert report == expected_report
