def test_print_code(self): # given text_view = self.get_text_view(show_mutants=True) original = utils.create_ast('x = x + 1') mutant = utils.create_ast('x = x - 1') # when with captured_output() as (out, err): text_view.print_code(mutant, original) # then output = out.getvalue().strip() self.assertEqual( self.SEPARATOR + self.EOL + '- 1: x = x + 1' + self.EOL + '+ 1: x = x - 1' + self.EOL + self.SEPARATOR, output)
def test_future_statement_coverage(self): node = utils.create_ast('from __future__ import print_function') self.coverage_injector.inject(node) import_node = node.body[0] self.assert_not_covered([import_node])
def test_docstring_coverage(self): node = utils.create_ast('"""doc"""') self.coverage_injector.inject(node) docstring_node = node.body[0] self.assert_covered([docstring_node])
def test_visit(self): node = utils.create_ast('x = y\ny = x') MarkerNodeTransformer().visit(node) y_load_node = node.body[0].value.ctx x_load_node = node.body[1].value.ctx self.assertTrue(y_load_node.marker < x_load_node.marker)
def test_not_covered_node(self): node = utils.create_ast('if False:\n\ty = 2') self.coverage_injector.inject(node) assign_node = node.body[0].body[0] constant_node = node.body[0].body[0].targets[0] self.assert_not_covered([assign_node, constant_node])
def generate_coverage_node(self, node): if hasattr(node, 'body'): markers = self.get_markers_from_body_node(node) else: markers = self.get_included_markers(node) coverage_node = utils.create_ast('{}.update({})'.format( COVERAGE_SET_NAME, repr(markers))).body[0] coverage_node.lineno = node.lineno coverage_node.col_offset = node.col_offset return coverage_node
def test_second_order_mutation(self): mutator = HighOrderMutator(operators=[ operators.ArithmeticOperatorReplacement, operators.AssignmentOperatorReplacement ], ) target_ast = utils.create_ast('x += y + z') for number, (mutations, mutant) in enumerate(mutator.mutate(target_ast)): self.assertEqual(number, 0) self.assertEqual('x -= y - z', codegen.to_source(mutant)) self.assertEqual(len(mutations), 2) self.assertEqual(codegen.to_source(target_ast), 'x += y + z')
def test_second_order_mutation_with_multiple_visitors(self): mutator = HighOrderMutator(operators=[operators.ConstantReplacement], ) target_ast = utils.create_ast('x = "test"') number = None for number, (mutations, mutant) in enumerate(mutator.mutate(target_ast)): if number == 0: self.assertEqual("x = 'mutpy'", codegen.to_source(mutant)) self.assertEqual(len(mutations), 1) elif number == 1: self.assertEqual("x = ''", codegen.to_source(mutant)) self.assertEqual(len(mutations), 1) self.assertEqual(number, 1) self.assertEqual(codegen.to_source(target_ast), "x = 'test'")
def create_super_call(self, node): super_call = utils.create_ast('super().{}()'.format(node.name)).body[0] for arg in node.args.args[1:-len(node.args.defaults) or None]: super_call.value.args.append(ast.Name(id=arg.arg, ctx=ast.Load())) for arg, default in zip(node.args.args[-len(node.args.defaults):], node.args.defaults): super_call.value.keywords.append(ast.keyword(arg=arg.arg, value=default)) for arg, default in zip(node.args.kwonlyargs, node.args.kw_defaults): super_call.value.keywords.append(ast.keyword(arg=arg.arg, value=default)) if node.args.vararg: self.add_vararg_to_super_call(super_call, node.args.vararg) if node.args.kwarg: self.add_kwarg_to_super_call(super_call, node.args.kwarg) self.set_lineno(super_call, node.body[0].lineno) return super_call
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_second_order_mutation_with_same_node_as_target(self): mutator = HighOrderMutator(operators=[ operators.ArithmeticOperatorDeletion, operators.ArithmeticOperatorReplacement ], ) target_ast = utils.create_ast('- a') number = None for number, (mutations, mutant) in enumerate(mutator.mutate(target_ast)): if number == 0: self.assertEqual('a', codegen.to_source(mutant)) self.assertEqual(len(mutations), 1) elif number == 1: self.assertEqual('+a', codegen.to_source(mutant)) self.assertEqual(len(mutations), 1) self.assertEqual(number, 1) self.assertEqual(codegen.to_source(target_ast), '-a')
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_first_order_mutation(self): mutator = FirstOrderMutator(operators=[ operators.ArithmeticOperatorReplacement, operators.AssignmentOperatorReplacement ], ) target_ast = utils.create_ast('x += y + z') for number, (mutations, mutant) in enumerate(mutator.mutate(target_ast)): self.assertIn(number, [0, 1]) self.assertEqual(len(mutations), 1) if number == 0: self.assertEqual('x += y - z', codegen.to_source(mutant)) elif number == 1: self.assertEqual('x -= y + z', codegen.to_source(mutant)) self.assertEqual(codegen.to_source(target_ast), 'x += y + z')
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_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 assert_mutation(self, original, mutants, lines=None, operator=None, with_coverage=False, with_exec=False): original_ast = utils.create_ast(original) if with_coverage: coverage_injector = coverage.CoverageInjector() coverage_injector.inject(original_ast) else: coverage_injector = None if not operator: operator = self.__class__.op if isinstance(mutants, str): mutants = [mutants] mutants = list(map(codegen.remove_extra_lines, mutants)) module = None if with_exec: module = utils.create_module(original_ast) for mutation, mutatnt in operator.mutate( original_ast, coverage_injector=coverage_injector, module=module): mutant_code = codegen.remove_extra_lines( codegen.to_source(mutatnt)) msg = '\n\nMutant:\n\n' + mutant_code + '\n\nNot found in:' for other_mutant in mutants: msg += '\n\n----------\n\n' + other_mutant self.assertIn(mutant_code, mutants, msg) mutants.remove(mutant_code) self.assert_location(mutatnt) if lines is not None: if not hasattr(mutation.node, 'lineno'): self.assert_mutation_lineo(mutation.node.parent.lineno, lines) else: self.assert_mutation_lineo(mutation.node.lineno, lines) self.assertListEqual(mutants, [], 'did not generate all mutants')
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 create_target_ast(self, target_module): return utils.create_ast(self.target_loader.get_source())
def setUp(self): self.operator = self.PassIdOperator() self.target_ast = utils.create_ast(PASS)
def test_result(self): node = utils.create_ast('x = 1') self.coverage_injector.inject(node) self.assertEqual(self.coverage_injector.get_result(), (5, 5))
def create_target_ast(self, target_module): with open(target_module.__file__) as target_file: return utils.create_ast(target_file.read())