def test_replace_continue_by_break(self): self.assert_mutation( utils.f(""" for x in y: continue """), [utils.f(""" for x in y: break """)])
def test_deletion_with_arguments(self): self.assert_mutation( utils.f(""" @a(1) def f(): pass """), [utils.f(""" def f(): pass """)])
def test_single_decorator_deletion(self): self.assert_mutation( utils.f(""" @a def f(): pass """), [utils.f(""" def f(): pass """)])
def test_double_decorators_deletion(self): self.assert_mutation( utils.f(""" @a @b def f(): pass """), [utils.f(""" def f(): pass """)])
def test_add_staticmethod_decorator(self): self.assert_mutation( utils.f(""" class X: def f(): pass """), utils.f(""" class X: @staticmethod def f(): pass """))
def test_change_position_from_first_to_last(self): self.assert_mutation( utils.f(""" class A: def foo(self, x): super().foo(x) """), [ utils.f(""" class A: def foo(self, x): pass """) ])
def test_delete_overriding_method_when_base_class_from_other_module(self): self.assert_mutation(utils.f(""" import ast class A(ast.NodeTransformer): def visit(self): pass """), [ utils.f(""" import ast class A(ast.NodeTransformer): pass """) ], with_exec=True)
def test_delete_variable_if_two_hiding_in_two_targets(self): self.assert_mutation(utils.f(""" class B: (x, y) = (1, 2) class A(B): (x, y) = (3, 4) """), [ utils.f(""" class B: (x, y) = (1, 2) class A(B): pass """) ], with_exec=True)
def test_swallow_exception(self): self.assert_mutation( utils.f(""" try: pass except: raise """), [ utils.f(""" try: pass except: pass """) ])
def test_delete_variable_if_one_hiding_in_three_targets(self): self.assert_mutation(utils.f(""" class B: x = 1 class A(B): (x, y, z) = (2, 3, 4) """), [ utils.f(""" class B: x = 1 class A(B): (y, z) = (3, 4) """) ], with_exec=True)
def test_delete_variable(self): self.assert_mutation(utils.f(""" class B: x = 1 class A(B): x = 2 """), [ utils.f(""" class B: x = 1 class A(B): pass """) ], with_exec=True)
class MutationControllerTest(unittest.TestCase): TARGET_SRC = 'def mul(x): return x * x' TEST_SRC = utils.f(""" import target from unittest import TestCase class MulTest(TestCase): def test_mul(self): self.assertEqual(target.mul(2), 4) def test_not_used(self): pass """) def setUp(self): target_loader = MockModulesLoader('target', self.TARGET_SRC) test_loader = MockModulesLoader('test', self.TEST_SRC) self.score_view = MutationScoreStoreView() mutator = FirstOrderMutator([operators.ArithmeticOperatorReplacement], percentage=100) self.mutation_controller = MockMutationController( runner_cls=UnittestTestRunner, target_loader=target_loader, test_loader=test_loader, views=[self.score_view], mutant_generator=mutator, mutate_covered=True, ) def test_run(self): self.mutation_controller.run() score = self.score_view.score self.assertEqual(score.all_mutants, 3) self.assertEqual(score.killed_mutants, 2) self.assertEqual(score.survived_mutants, 1)
def test_not_change_position_if_single_statement(self): self.assert_mutation( utils.f(""" class A: def foo(self): super().foo() """), [])
def test_not_add_if_already_has_staticmethod(self): self.assert_no_mutation( utils.f(""" class X: @staticmethod def f(): pass """))
def test_not_delete_if_raise(self): self.assert_mutation( utils.f(""" try: pass except: raise """), [])
def test_not_swallow_if_pass(self): self.assert_mutation( utils.f(""" try: pass except: pass """), [])
def test_delete_overriding_method(self): self.assert_mutation(utils.f(""" class A: def foo(self): pass class B(A): def foo(self): pass """), [ utils.f(""" class A: def foo(self): pass class B(A): pass """) ], with_exec=True)
def test_change_position_from_first_to_last(self): self.assert_mutation(utils.f(""" class B: def foo(self, x, y=1, *args, **kwargs): pass class A(B): def foo(self, x, y=1, *args, **kwargs): pass """), [ utils.f(""" class B: def foo(self, x, y=1, *args, **kwargs): pass class A(B): def foo(self, x, y=1, *args, **kwargs): super().foo(x, y=1, *args, **kwargs) pass """) ], with_exec=True)
def test_double_mutation(self): self.assert_mutation( utils.f(""" while x: pass for x in y: pass """), [ utils.f(""" while x: pass break for x in y: pass """), utils.f(""" while x: pass for x in y: pass break """), ])
def test_func_def_coverage(self): node = utils.create_ast( utils.f(""" def foo(x): pass """)) self.coverage_injector.inject(node) func_node = node.body[0] func_body_el = func_node.body[0] arg_node = func_node.args.args[0] #self.assert_covered([func_node, arg_node]) self.assert_not_covered([func_body_el])
def test_class_def_coverage(self): node = utils.create_ast( utils.f(""" class X(object): def foo(x): pass """)) self.coverage_injector.inject(node) class_node = node.body[0] base_node = class_node.bases[0] func_body_el = class_node.body[0].body[0] self.assert_covered([class_node, base_node]) self.assert_not_covered([func_body_el])
def test_for_coverage(self): node = utils.create_ast( utils.f(""" for x in []: pass else: pass """)) self.coverage_injector.inject(node) for_node = node.body[0] for_body_el = for_node.body[0] else_body_el = for_node.orelse[0] self.assert_covered( [for_node, for_node.target, for_node.iter, else_body_el]) self.assert_not_covered([for_body_el])
def test_except_coverage(self): node = utils.create_ast( utils.f(""" try: raise KeyError except KeyError: pass """)) self.coverage_injector.inject(node) try_node = node.body[0] try_body_el = try_node.body[0] except_node = try_node.handlers[0] except_body_el = except_node.body[0] self.assert_covered( [try_node, try_body_el, except_node, except_body_el])
def test_while__coverage(self): node = utils.create_ast( utils.f(""" while False: pass else: pass """)) self.coverage_injector.inject(node) while_node = node.body[0] while_test_node = while_node.test while_body_el = while_node.body[0] while_else_body_el = while_node.orelse[0] self.assert_covered([while_test_node, while_else_body_el]) self.assert_not_covered([while_body_el])
def test_inject(self): target_module_content = utils.f(""" def x(): import source return source """) target_module = types.ModuleType('target') source_module_before = types.ModuleType('source') source_module_before.__file__ = 'source.py' source_module_after = types.ModuleType('source') sys.modules['source'] = source_module_before importer = utils.InjectImporter(source_module_after) eval(compile(target_module_content, 'target.py', 'exec'), target_module.__dict__) importer.install() source_module = target_module.x() self.assertEqual(source_module, source_module_after) self.assertEqual(source_module.__loader__, importer) del sys.modules['source'] importer.uninstall()
def test_if_coverage(self): node = utils.create_ast( utils.f(""" if False: pass elif True: pass else: pass """)) self.coverage_injector.inject(node) if_node = node.body[0] first_if_test_node = if_node.test first_if_body_el = if_node.body[0] second_if_node = if_node.orelse[0] second_if_test_node = second_if_node.test second_if_body_el = second_if_node.body[0] else_body_el = second_if_node.orelse[0] self.assert_covered( [first_if_test_node, second_if_test_node, second_if_body_el]) self.assert_not_covered([first_if_body_el, else_body_el])
def test_f(self): self.assertEqual( utils.f(""" def f(): pass """), 'def f():\n pass')