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 generate_coverage_node(self, node):
if node.__class__ in self.get_definitions_nodes():
coverage_node = utils.create_ast('{}.add({})'.format(COVERAGE_SET_NAME, node.marker)).body[0]
else:
markers = {node.marker} | {node.marker for node in node.children}
if node.__class__ in self.get_branch_nodes():
for body_el in node.body:
if hasattr(body_el, 'marker'):
markers.difference_update({body_el.marker})
markers.difference_update({node.marker for node in body_el.children})
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 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 not lines is None:
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.assertTrue(self.coverage_injector.is_covered(first_if_test_node))
self.assertFalse(self.coverage_injector.is_covered(first_if_body_el))
self.assertTrue(self.coverage_injector.is_covered(second_if_test_node))
self.assertTrue(self.coverage_injector.is_covered(second_if_body_el))
self.assertFalse(self.coverage_injector.is_covered(else_body_el))
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.assertFalse(self.coverage_injector.is_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_docstring_coverage(self):
node = utils.create_ast('"""doc"""')
self.coverage_injector.inject(node)
docstring_node = node.body[0]
self.assertTrue(self.coverage_injector.is_covered(docstring_node))
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 not lines is None:
self.assert_mutation_lineo(mutation.node.lineno, lines)
self.assertListEqual(mutants, [], 'did not generate all mutants')
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_visit(self):
node = utils.create_ast('x = y\ny = x')
coverage.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 test_visit(self):
node = utils.create_ast('x = y\ny = x')
coverage.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 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_set_parent(self):
node = utils.create_ast('x += y + z')
utils.ParentNodeTransformer().visit(node)
self.assertEqual(node.body[0].op.parent, node.body[0])
self.assertIn(node.body[0].op, node.body[0].children)
self.assertEqual(node.body[0].value.op.parent, node.body[0].value)
self.assertIn(node.body[0].value.op, node.body[0].value.children)
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.assertFalse(self.coverage_injector.is_covered(assign_node))
self.assertFalse(self.coverage_injector.is_covered(constant_node))
def test_covered_node(self):
node = utils.create_ast('x = 1\nif False:\n\ty = 2')
self.coverage_injector.inject(node)
assign_node = node.body[0]
constant_node = node.body[0].targets[0]
self.assertTrue(self.coverage_injector.is_covered(assign_node))
self.assertTrue(self.coverage_injector.is_covered(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 = controller.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 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)
return super_call
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:
super_call.value.starargs = ast.Name(id=node.args.vararg, ctx=ast.Load())
if node.args.kwarg:
super_call.value.kwargs = ast.Name(id=node.args.kwarg, ctx=ast.Load())
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_second_order_mutation(self):
mutator = controller.HighOrderMutator(
operators=[operators.ArithmeticOperatorReplacement, operators.AssignmentOperatorReplacement],
)
target_ast = utils.create_ast('x += y + z')
for number, (mutations, mutant) in enumerate(mutator.mutate(target_ast)):
if number == 0:
self.assertEqual('x -= y - z', codegen.to_source(mutant))
self.assertEqual(len(mutations), 2)
else:
self.fail()
self.assertEqual(codegen.to_source(target_ast), 'x += y + z')
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.assertTrue(self.coverage_injector.is_covered(func_node))
self.assertTrue(self.coverage_injector.is_covered(arg_node))
self.assertFalse(self.coverage_injector.is_covered(func_body_el))
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.assertTrue(self.coverage_injector.is_covered(func_node))
self.assertTrue(self.coverage_injector.is_covered(arg_node))
self.assertFalse(self.coverage_injector.is_covered(func_body_el))
def test_second_order_mutation_with_same_node_as_target(self):
mutator = controller.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_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_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_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_first_order_mutation(self):
mutator = controller.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_second_order_mutation_with_same_node_as_target(self):
mutator = controller.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_second_order_mutation_with_multiple_visitors(self):
mutator = controller.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 test_second_order_mutation_with_multiple_visitors(self):
mutator = controller.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 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.assertTrue(self.coverage_injector.is_covered(class_node))
self.assertTrue(self.coverage_injector.is_covered(base_node))
self.assertFalse(self.coverage_injector.is_covered(func_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_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.assertTrue(self.coverage_injector.is_covered(class_node))
self.assertTrue(self.coverage_injector.is_covered(base_node))
self.assertFalse(self.coverage_injector.is_covered(func_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.assertTrue(self.coverage_injector.is_covered(while_test_node))
self.assertFalse(self.coverage_injector.is_covered(while_body_el))
self.assertTrue(self.coverage_injector.is_covered(while_else_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.assertTrue(self.coverage_injector.is_covered(for_node))
self.assertTrue(self.coverage_injector.is_covered(for_node.target))
self.assertTrue(self.coverage_injector.is_covered(for_node.iter))
self.assertFalse(self.coverage_injector.is_covered(for_body_el))
self.assertTrue(self.coverage_injector.is_covered(else_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.assertTrue(self.coverage_injector.is_covered(try_node))
self.assertTrue(self.coverage_injector.is_covered(try_body_el))
self.assertTrue(self.coverage_injector.is_covered(except_node))
self.assertTrue(self.coverage_injector.is_covered(except_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.assertTrue(self.coverage_injector.is_covered(for_node))
self.assertTrue(self.coverage_injector.is_covered(for_node.target))
self.assertTrue(self.coverage_injector.is_covered(for_node.iter))
self.assertFalse(self.coverage_injector.is_covered(for_body_el))
self.assertTrue(self.coverage_injector.is_covered(else_body_el))
def test_try_coverage(self):
node = utils.create_ast(
utils.f("""
try:
pass
except:
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.assertTrue(self.coverage_injector.is_covered(try_node))
self.assertTrue(self.coverage_injector.is_covered(try_body_el))
self.assertFalse(self.coverage_injector.is_covered(except_node))
self.assertFalse(self.coverage_injector.is_covered(except_body_el))
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.assertTrue(self.coverage_injector.is_covered(first_if_test_node))
self.assertFalse(self.coverage_injector.is_covered(first_if_body_el))
self.assertTrue(self.coverage_injector.is_covered(second_if_test_node))
self.assertTrue(self.coverage_injector.is_covered(second_if_body_el))
self.assertFalse(self.coverage_injector.is_covered(else_body_el))
def assert_code_equal(self, code):
node = utils.create_ast(code)
generated = codegen.to_source(node)
self.assertMultiLineEqual(code, generated)
def assert_code_equal(self, code):
node = utils.create_ast(code)
generated = codegen.to_source(node)
self.assertMultiLineEqual(code, generated)
def create_target_ast(self, target_module):
return utils.create_ast(self.target_loader.get_source())
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 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 setUp(self):
self.operator = self.PassIdOperator()
self.target_ast = utils.create_ast(PASS)
def create_target_ast(self, target_module):
with open(target_module.__file__) as target_file:
return utils.create_ast(target_file.read())
def create_target_ast(self, target_module):
return utils.create_ast(self.target_loader.get_source())
def create_target_ast(self, target_module):
with open(target_module.__file__) as target_file:
return utils.create_ast(target_file.read())
def create_target_ast(self, target_file_name):
with open("./" + target_file_name + ".py") as target_file:
return utils.create_ast(target_file.read())
