class TestFuncs(unittest.TestCase): """White-box testing of funcs tracing""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) self.tracer = Trace(count=0, trace=0, countfuncs=1) self.filemod = my_file_and_modname() self._saved_tracefunc = sys.gettrace() def tearDown(self): if self._saved_tracefunc is not None: sys.settrace(self._saved_tracefunc) 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) @unittest.skipIf( hasattr(sys, 'gettrace') and sys.gettrace(), 'pre-existing trace function throws off measurements') 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) def test_traced_decorated_function(self): self.tracer.runfunc(traced_decorated_function) expected = { self.filemod + ('traced_decorated_function', ): 1, self.filemod + ('decorator_fabric', ): 1, self.filemod + ('decorator2', ): 1, self.filemod + ('decorator1', ): 1, self.filemod + ('func', ): 1, } self.assertEqual(self.tracer.results().calledfuncs, expected)
class TestFuncs(unittest.TestCase): """White-box testing of funcs tracing""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) self.tracer = Trace(count=0, trace=0, countfuncs=1) self.filemod = my_file_and_modname() self._saved_tracefunc = sys.gettrace() def tearDown(self): if self._saved_tracefunc is not None: sys.settrace(self._saved_tracefunc) 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) @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(), 'pre-existing trace function throws off measurements') 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) def test_traced_decorated_function(self): self.tracer.runfunc(traced_decorated_function) expected = { self.filemod + ('traced_decorated_function',): 1, self.filemod + ('decorator_fabric',): 1, self.filemod + ('decorator2',): 1, self.filemod + ('decorator1',): 1, self.filemod + ('func',): 1, } self.assertEqual(self.tracer.results().calledfuncs, expected)
class TestFuncs(unittest.TestCase): """White-box testing of funcs tracing""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) self.tracer = Trace(count=0, trace=0, countfuncs=1) self.filemod = my_file_and_modname() self._saved_tracefunc = sys.gettrace() def tearDown(self): if self._saved_tracefunc is not None: sys.settrace(self._saved_tracefunc) 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_arg_errors(self): res = self.tracer.runfunc(traced_capturer, 1, 2, self=3, func=4) self.assertEqual(res, ((1, 2), {'self': 3, 'func': 4})) res = self.tracer.runfunc(func=traced_capturer, arg=1) self.assertEqual(res, ((), {'arg': 1})) with self.assertRaises(TypeError): self.tracer.runfunc() 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) @unittest.skipIf( hasattr(sys, 'gettrace') and sys.gettrace(), 'pre-existing trace function throws off measurements') 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)
def generate_sequential_function_calls(self): """generate sequential function calls for tracing source code and plotting sequence diagram. """ # generating sequence diagram for a use-case use_case, driver_path, driver_name, driver_function = self.get_driver_path_and_driver_name( ) generate_sequence_diagram = GenerateSequenceDiagram( driver_path, driver_name, self.source_code_path[0]) spec = importlib.util.spec_from_file_location(driver_name, driver_path) global foo foo = importlib.util.module_from_spec(spec) spec.loader.exec_module(foo) tracer = Trace(countfuncs=1, countcallers=1, timing=1) tracer.run('foo.{}()'.format(driver_function)) results = tracer.results() caller_functions = results.callers function_sequence = [] # consists of all functions called in sequence for caller, callee in caller_functions: _, caller_module, caller_function = caller _, _, callee_function = callee if caller_module not in self.source_code_modules: continue function_sequence.append([caller_function, callee_function]) for sequence in function_sequence: print(sequence) self.df = self.write_in_excel.integrate_sequence_diagram_in_df( self.df, function_sequence, use_case) self.write_in_excel.write_df_to_excel(self.df, 'sheet_one', self.skip_cols, self.classes_covered, use_case)
class TestCallers(unittest.TestCase): """White-box testing of callers tracing""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) self.tracer = Trace(count=0, trace=0, countcallers=1) self.filemod = my_file_and_modname() @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(), 'pre-existing trace function throws off measurements') 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)
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__) self.addCleanup(sys.settrace, sys.gettrace()) 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])
def get_called_functions(self, driver_function): """return the called functions in their called sequence Returns: list(dict) -- called functions returned in a list(sorted) comprising of a dict keyed on filename, modulename and funcname. """ # spec = importlib.util.spec_from_file_location( # self.driver_module, self.driver_path) # foo = importlib.util.module_from_spec(spec) # spec.loader.exec_module(foo) # # main_2 = foo.main_2() # tracer = Trace(countfuncs=1) # function_to_be_called = foo.__getattribute__('main_2') # print(dir(function_to_be_called)) # func_name = function_to_be_called.__name__ # tracer.run('{}()'.format(func_name)) #resolve hardcoded driver function. # results = tracer.results() # print(results.calledfuncs) spec = importlib.util.spec_from_file_location( "driver", "/Users/aviralsrivastava/Desktop/source_code_to_study/driver.py") foo = importlib.util.module_from_spec(spec) spec.loader.exec_module(foo) # foo.main_2() tracer = Trace(countfuncs=1, ) tracer.run('foo.main_2()') results = tracer.results() return results.calledfuncs
class TestCallers(unittest.TestCase): """White-box testing of callers tracing""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) self.tracer = Trace(count=0, trace=0, countcallers=1) self.filemod = my_file_and_modname() @unittest.skipIf( hasattr(sys, 'gettrace') and sys.gettrace(), 'pre-existing trace function throws off measurements') 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)
def test_linear_methods(self): 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)
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 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 TestFuncs(unittest.TestCase): """White-box testing of funcs tracing""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) 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) @unittest.skipIf(hasattr(sys, "gettrace") and sys.gettrace(), "pre-existing trace function throws off measurements") 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 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)
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)
def _run_with_trace(self): from trace import Trace trace = Trace(ignoredirs=[sys.prefix, sys.exec_prefix], trace=False, count=True) try: trace.runfunc(self._run_tests) finally: results = trace.results() real_stdout = sys.stdout sys.stdout = open(self.coverage_summary, 'w') try: results.write_results(show_missing=True, summary=True, coverdir=self.coverage_dir) finally: sys.stdout.close() sys.stdout = real_stdout
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__) self.addCleanup(sys.settrace, sys.gettrace()) def test_exec_counts(self): self.tracer = Trace(count=1, trace=0, countfuncs=0, countcallers=0) code = '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 } for k in expected.keys(): self.assertEqual(self.tracer.results().counts[k], expected[k])
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)
def generate_sequential_function_calls(self): """generate sequential function calls for tracing source code and plotting sequence diagram. """ # generating sequence diagram for a use-case # _ = GenerateSequenceDiagram( # self.driver_path, self.driver_name, self.source_code_path[0]) spec = importlib.util.spec_from_file_location(self.driver_name, self.driver_path) global foo foo = self.foo foo = importlib.util.module_from_spec(spec) spec.loader.exec_module(foo) tracer = Trace(countfuncs=1, countcallers=1, timing=1) tracer.run('foo.{}()'.format(self.driver_function)) results = tracer.results() caller_functions = results.callers function_sequence = [] # consists of all functions called in sequence for caller, callee in caller_functions: _, caller_module, caller_function = caller _, callee_module, callee_function = callee if caller_module not in self.source_code_modules or callee_module not in self.source_code_modules: logging.debug( "Following modules are not in source code and thus to be ignored:" ) logging.debug(caller_module) continue function_sequence.append([(caller_module, caller_function), (callee_module, callee_function)]) logging.debug("Function sequence is: ") for sequence in function_sequence: logging.debug(sequence) self.df = self.write_in_excel.integrate_sequence_diagram_in_df( self.df, function_sequence, self.use_case, self.driver_function, self.skip_cols) self.write_in_excel.write_df_to_excel(self.df, 'sheet_one', self.skip_cols, self.classes_covered, self.use_case)
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)
class TestLineCounts(unittest.TestCase): """White-box testing of line-counting, via runfunc""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) 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) 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): 12, (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): 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 TestLineCounts(unittest.TestCase): """White-box testing of line-counting, via runfunc""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) 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, # List compehentions work differently in 3.x, so the count # below changed compared to 2.x. (self.my_py_filename, firstlineno_calling + 2): 12, (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 TestLineCounts(unittest.TestCase): """White-box testing of line-counting, via runfunc""" def setUp(self): self.addCleanup(sys.settrace, sys.gettrace()) 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, # List compehentions work differently in 3.x, so the count # below changed compared to 2.x. (self.my_py_filename, firstlineno_calling + 2): 12, (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)