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, 0 insertions, 341 deletions
diff --git a/lib/python2.7/test/test_trace.py b/lib/python2.7/test/test_trace.py deleted file mode 100644 index 2292ad6..0000000 --- a/lib/python2.7/test/test_trace.py +++ /dev/null @@ -1,341 +0,0 @@ -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() |