diff options
Diffstat (limited to 'lib/python2.7/test/test_trace.py')
| -rw-r--r-- | lib/python2.7/test/test_trace.py | 341 |
1 files changed, 341 insertions, 0 deletions
diff --git a/lib/python2.7/test/test_trace.py b/lib/python2.7/test/test_trace.py new file mode 100644 index 0000000..2292ad6 --- /dev/null +++ b/lib/python2.7/test/test_trace.py @@ -0,0 +1,341 @@ +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() |