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