import os | |
import sys | |
from test.test_support import (run_unittest, TESTFN, rmtree, unlink, | |
captured_stdout) | |
import unittest | |
import trace | |
from trace import CoverageResults, Trace | |
from test.tracedmodules import testmod | |
#------------------------------- Utilities -----------------------------------# | |
def fix_ext_py(filename): | |
"""Given a .pyc/.pyo filename converts it to the appropriate .py""" | |
if filename.endswith(('.pyc', '.pyo')): | |
filename = filename[:-1] | |
return filename | |
def my_file_and_modname(): | |
"""The .py file and module name of this file (__file__)""" | |
modname = os.path.splitext(os.path.basename(__file__))[0] | |
return fix_ext_py(__file__), modname | |
def get_firstlineno(func): | |
return func.__code__.co_firstlineno | |
#-------------------- Target functions for tracing ---------------------------# | |
# | |
# The relative line numbers of lines in these functions matter for verifying | |
# tracing. Please modify the appropriate tests if you change one of the | |
# functions. Absolute line numbers don't matter. | |
# | |
def traced_func_linear(x, y): | |
a = x | |
b = y | |
c = a + b | |
return c | |
def traced_func_loop(x, y): | |
c = x | |
for i in range(5): | |
c += y | |
return c | |
def traced_func_importing(x, y): | |
return x + y + testmod.func(1) | |
def traced_func_simple_caller(x): | |
c = traced_func_linear(x, x) | |
return c + x | |
def traced_func_importing_caller(x): | |
k = traced_func_simple_caller(x) | |
k += traced_func_importing(k, x) | |
return k | |
def traced_func_generator(num): | |
c = 5 # executed once | |
for i in range(num): | |
yield i + c | |
def traced_func_calling_generator(): | |
k = 0 | |
for i in traced_func_generator(10): | |
k += i | |
def traced_doubler(num): | |
return num * 2 | |
def traced_caller_list_comprehension(): | |
k = 10 | |
mylist = [traced_doubler(i) for i in range(k)] | |
return mylist | |
class TracedClass(object): | |
def __init__(self, x): | |
self.a = x | |
def inst_method_linear(self, y): | |
return self.a + y | |
def inst_method_calling(self, x): | |
c = self.inst_method_linear(x) | |
return c + traced_func_linear(x, c) | |
@classmethod | |
def class_method_linear(cls, y): | |
return y * 2 | |
@staticmethod | |
def static_method_linear(y): | |
return y * 2 | |
#------------------------------ Test cases -----------------------------------# | |
class TestLineCounts(unittest.TestCase): | |
"""White-box testing of line-counting, via runfunc""" | |
def setUp(self): | |
self.tracer = Trace(count=1, trace=0, countfuncs=0, countcallers=0) | |
self.my_py_filename = fix_ext_py(__file__) | |
def test_traced_func_linear(self): | |
result = self.tracer.runfunc(traced_func_linear, 2, 5) | |
self.assertEqual(result, 7) | |
# all lines are executed once | |
expected = {} | |
firstlineno = get_firstlineno(traced_func_linear) | |
for i in range(1, 5): | |
expected[(self.my_py_filename, firstlineno + i)] = 1 | |
self.assertEqual(self.tracer.results().counts, expected) | |
def test_traced_func_loop(self): | |
self.tracer.runfunc(traced_func_loop, 2, 3) | |
firstlineno = get_firstlineno(traced_func_loop) | |
expected = { | |
(self.my_py_filename, firstlineno + 1): 1, | |
(self.my_py_filename, firstlineno + 2): 6, | |
(self.my_py_filename, firstlineno + 3): 5, | |
(self.my_py_filename, firstlineno + 4): 1, | |
} | |
self.assertEqual(self.tracer.results().counts, expected) | |
def test_traced_func_importing(self): | |
self.tracer.runfunc(traced_func_importing, 2, 5) | |
firstlineno = get_firstlineno(traced_func_importing) | |
expected = { | |
(self.my_py_filename, firstlineno + 1): 1, | |
(fix_ext_py(testmod.__file__), 2): 1, | |
(fix_ext_py(testmod.__file__), 3): 1, | |
} | |
self.assertEqual(self.tracer.results().counts, expected) | |
def test_trace_func_generator(self): | |
self.tracer.runfunc(traced_func_calling_generator) | |
firstlineno_calling = get_firstlineno(traced_func_calling_generator) | |
firstlineno_gen = get_firstlineno(traced_func_generator) | |
expected = { | |
(self.my_py_filename, firstlineno_calling + 1): 1, | |
(self.my_py_filename, firstlineno_calling + 2): 11, | |
(self.my_py_filename, firstlineno_calling + 3): 10, | |
(self.my_py_filename, firstlineno_gen + 1): 1, | |
(self.my_py_filename, firstlineno_gen + 2): 11, | |
(self.my_py_filename, firstlineno_gen + 3): 10, | |
} | |
self.assertEqual(self.tracer.results().counts, expected) | |
def test_trace_list_comprehension(self): | |
self.tracer.runfunc(traced_caller_list_comprehension) | |
firstlineno_calling = get_firstlineno(traced_caller_list_comprehension) | |
firstlineno_called = get_firstlineno(traced_doubler) | |
expected = { | |
(self.my_py_filename, firstlineno_calling + 1): 1, | |
(self.my_py_filename, firstlineno_calling + 2): 11, | |
(self.my_py_filename, firstlineno_calling + 3): 1, | |
(self.my_py_filename, firstlineno_called + 1): 10, | |
} | |
self.assertEqual(self.tracer.results().counts, expected) | |
def test_linear_methods(self): | |
# XXX todo: later add 'static_method_linear' and 'class_method_linear' | |
# here, once issue1764286 is resolved | |
# | |
for methname in ['inst_method_linear',]: | |
tracer = Trace(count=1, trace=0, countfuncs=0, countcallers=0) | |
traced_obj = TracedClass(25) | |
method = getattr(traced_obj, methname) | |
tracer.runfunc(method, 20) | |
firstlineno = get_firstlineno(method) | |
expected = { | |
(self.my_py_filename, firstlineno + 1): 1, | |
} | |
self.assertEqual(tracer.results().counts, expected) | |
class TestRunExecCounts(unittest.TestCase): | |
"""A simple sanity test of line-counting, via runctx (exec)""" | |
def setUp(self): | |
self.my_py_filename = fix_ext_py(__file__) | |
def test_exec_counts(self): | |
self.tracer = Trace(count=1, trace=0, countfuncs=0, countcallers=0) | |
code = r'''traced_func_loop(2, 5)''' | |
code = compile(code, __file__, 'exec') | |
self.tracer.runctx(code, globals(), vars()) | |
firstlineno = get_firstlineno(traced_func_loop) | |
expected = { | |
(self.my_py_filename, firstlineno + 1): 1, | |
(self.my_py_filename, firstlineno + 2): 6, | |
(self.my_py_filename, firstlineno + 3): 5, | |
(self.my_py_filename, firstlineno + 4): 1, | |
} | |
# When used through 'run', some other spurious counts are produced, like | |
# the settrace of threading, which we ignore, just making sure that the | |
# counts fo traced_func_loop were right. | |
# | |
for k in expected.keys(): | |
self.assertEqual(self.tracer.results().counts[k], expected[k]) | |
class TestFuncs(unittest.TestCase): | |
"""White-box testing of funcs tracing""" | |
def setUp(self): | |
self.tracer = Trace(count=0, trace=0, countfuncs=1) | |
self.filemod = my_file_and_modname() | |
def test_simple_caller(self): | |
self.tracer.runfunc(traced_func_simple_caller, 1) | |
expected = { | |
self.filemod + ('traced_func_simple_caller',): 1, | |
self.filemod + ('traced_func_linear',): 1, | |
} | |
self.assertEqual(self.tracer.results().calledfuncs, expected) | |
def test_loop_caller_importing(self): | |
self.tracer.runfunc(traced_func_importing_caller, 1) | |
expected = { | |
self.filemod + ('traced_func_simple_caller',): 1, | |
self.filemod + ('traced_func_linear',): 1, | |
self.filemod + ('traced_func_importing_caller',): 1, | |
self.filemod + ('traced_func_importing',): 1, | |
(fix_ext_py(testmod.__file__), 'testmod', 'func'): 1, | |
} | |
self.assertEqual(self.tracer.results().calledfuncs, expected) | |
def test_inst_method_calling(self): | |
obj = TracedClass(20) | |
self.tracer.runfunc(obj.inst_method_calling, 1) | |
expected = { | |
self.filemod + ('TracedClass.inst_method_calling',): 1, | |
self.filemod + ('TracedClass.inst_method_linear',): 1, | |
self.filemod + ('traced_func_linear',): 1, | |
} | |
self.assertEqual(self.tracer.results().calledfuncs, expected) | |
class TestCallers(unittest.TestCase): | |
"""White-box testing of callers tracing""" | |
def setUp(self): | |
self.tracer = Trace(count=0, trace=0, countcallers=1) | |
self.filemod = my_file_and_modname() | |
def test_loop_caller_importing(self): | |
self.tracer.runfunc(traced_func_importing_caller, 1) | |
expected = { | |
((os.path.splitext(trace.__file__)[0] + '.py', 'trace', 'Trace.runfunc'), | |
(self.filemod + ('traced_func_importing_caller',))): 1, | |
((self.filemod + ('traced_func_simple_caller',)), | |
(self.filemod + ('traced_func_linear',))): 1, | |
((self.filemod + ('traced_func_importing_caller',)), | |
(self.filemod + ('traced_func_simple_caller',))): 1, | |
((self.filemod + ('traced_func_importing_caller',)), | |
(self.filemod + ('traced_func_importing',))): 1, | |
((self.filemod + ('traced_func_importing',)), | |
(fix_ext_py(testmod.__file__), 'testmod', 'func')): 1, | |
} | |
self.assertEqual(self.tracer.results().callers, expected) | |
# Created separately for issue #3821 | |
class TestCoverage(unittest.TestCase): | |
def tearDown(self): | |
rmtree(TESTFN) | |
unlink(TESTFN) | |
def _coverage(self, tracer, | |
cmd='from test import test_pprint; test_pprint.test_main()'): | |
tracer.run(cmd) | |
r = tracer.results() | |
r.write_results(show_missing=True, summary=True, coverdir=TESTFN) | |
def test_coverage(self): | |
tracer = trace.Trace(trace=0, count=1) | |
with captured_stdout() as stdout: | |
self._coverage(tracer) | |
stdout = stdout.getvalue() | |
self.assertTrue("pprint.py" in stdout) | |
self.assertTrue("case.py" in stdout) # from unittest | |
files = os.listdir(TESTFN) | |
self.assertTrue("pprint.cover" in files) | |
self.assertTrue("unittest.case.cover" in files) | |
def test_coverage_ignore(self): | |
# Ignore all files, nothing should be traced nor printed | |
libpath = os.path.normpath(os.path.dirname(os.__file__)) | |
# sys.prefix does not work when running from a checkout | |
tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix, libpath], | |
trace=0, count=1) | |
with captured_stdout() as stdout: | |
self._coverage(tracer) | |
if os.path.exists(TESTFN): | |
files = os.listdir(TESTFN) | |
self.assertEqual(files, []) | |
def test_issue9936(self): | |
tracer = trace.Trace(trace=0, count=1) | |
modname = 'test.tracedmodules.testmod' | |
# Ensure that the module is executed in import | |
if modname in sys.modules: | |
del sys.modules[modname] | |
cmd = ("import test.tracedmodules.testmod as t;" | |
"t.func(0); t.func2();") | |
with captured_stdout() as stdout: | |
self._coverage(tracer, cmd) | |
stdout.seek(0) | |
stdout.readline() | |
coverage = {} | |
for line in stdout: | |
lines, cov, module = line.split()[:3] | |
coverage[module] = (int(lines), int(cov[:-1])) | |
# XXX This is needed to run regrtest.py as a script | |
modname = trace.fullmodname(sys.modules[modname].__file__) | |
self.assertIn(modname, coverage) | |
self.assertEqual(coverage[modname], (5, 100)) | |
def test_main(): | |
run_unittest(__name__) | |
if __name__ == '__main__': | |
test_main() |