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())