def test_crossover_too_large():
test_factory = MagicMock()
test_case0 = MagicMock(dtc.DefaultTestCase)
test_case0_clone = MagicMock(dtc.DefaultTestCase)
test_case0_clone.size.return_value = 5
test_case0.clone.return_value = test_case0_clone
test_case1 = MagicMock(dtc.DefaultTestCase)
test_case1.size.return_value = 7
left = tcc.TestCaseChromosome(test_case0, test_factory=test_factory)
right = tcc.TestCaseChromosome(test_case1, test_factory=test_factory)
config.INSTANCE.chromosome_length = 3
left.set_changed(False)
left.cross_over(right, 1, 2)
assert not left.has_changed()
def test_crossover(chromosome):
cases_a = [tcc.TestCaseChromosome(dtc.DefaultTestCase()) for _ in range(5)]
cases_b = [tcc.TestCaseChromosome(dtc.DefaultTestCase()) for _ in range(5)]
chromosome.add_test_case_chromosomes(cases_a)
other = tsc.TestSuiteChromosome()
other.add_test_case_chromosomes(cases_b)
pos1 = 3
pos2 = 2
chromosome.set_changed(False)
chromosome.cross_over(other, pos1, pos2)
assert chromosome.test_case_chromosomes == cases_a[:pos1] + cases_b[pos2:]
assert chromosome.has_changed()
def test_crossover_success():
test_factory = MagicMock()
test_case0 = MagicMock(dtc.DefaultTestCase)
test_case0_clone = MagicMock(dtc.DefaultTestCase)
test_case0_clone.size.return_value = 5
test_case0.clone.return_value = test_case0_clone
test_case1 = MagicMock(dtc.DefaultTestCase)
test_case1.size.return_value = 7
left = tcc.TestCaseChromosome(test_case0, test_factory=test_factory)
right = tcc.TestCaseChromosome(test_case1, test_factory=test_factory)
left.cross_over(right, 4, 3)
assert test_case0.get_statement.call_count == 4
assert test_case0_clone.add_statement.call_count == 4
assert test_case1.get_statement.call_count == 4
assert test_factory.append_statement.call_count == 4
def test_simple_conversion():
passing = tcc.TestCaseChromosome(dtc.DefaultTestCase())
failing = tcc.TestCaseChromosome(dtc.DefaultTestCase())
mocked_result = MagicMock()
mocked_result.has_test_exceptions.return_value = True
failing.set_last_execution_result(mocked_result)
chromosome = tsc.TestSuiteChromosome()
chromosome.add_test_case_chromosomes([failing, passing])
converter = cc.ChromosomeConverter()
chromosome.accept(converter)
passing_suite = converter.passing_test_suite
failing_suite = converter.failing_test_suite
assert passing_suite.test_case_chromosomes == [passing]
assert failing_suite.test_case_chromosomes == [failing]
def test_delete_statement(result):
test_factory = MagicMock(tf.TestFactory)
test_factory.delete_statement_gracefully.return_value = result
test_case = dtc.DefaultTestCase()
chromosome = tcc.TestCaseChromosome(test_case, test_factory=test_factory)
test_case.add_statement(prim.IntPrimitiveStatement(test_case, 5))
assert chromosome._delete_statement(0) == result
test_factory.delete_statement_gracefully.assert_called_with(test_case, 0)
def test_run_test_case_chromosome_no_result():
executor = MagicMock()
result0 = MagicMock()
executor.execute.return_value = result0
ff = DummyTestSuiteFitnessFunction(executor)
test_case0 = tcc.TestCaseChromosome(MagicMock())
test_case0.set_changed(True)
assert ff._run_test_case_chromosome(test_case0) == result0
assert test_case0.get_last_execution_result() == result0
def test_mutation_delete_skipping():
test_case = dtc.DefaultTestCase()
chromosome = tcc.TestCaseChromosome(test_case)
with mock.patch.object(chromosome, "_delete_statement") as delete_mock:
delete_mock.return_value = True
with mock.patch.object(chromosome,
"_get_last_mutatable_statement") as mut_mock:
mut_mock.return_value = 3
assert not chromosome._mutation_delete()
assert delete_mock.call_count == 0
def test_run_test_suite_chromosome():
executor = MagicMock()
result0 = MagicMock()
result1 = MagicMock()
result2 = MagicMock()
executor.execute.side_effect = [result0, result1]
ff = DummyTestSuiteFitnessFunction(executor)
indiv = tsc.TestSuiteChromosome()
test_case0 = tcc.TestCaseChromosome(MagicMock())
test_case0.set_changed(True)
test_case1 = tcc.TestCaseChromosome(MagicMock())
test_case1.set_changed(False)
test_case2 = tcc.TestCaseChromosome(MagicMock())
test_case2.set_changed(False)
test_case2.set_last_execution_result(result2)
indiv.add_test_case_chromosome(test_case0)
indiv.add_test_case_chromosome(test_case1)
indiv.add_test_case_chromosome(test_case2)
assert ff._run_test_suite_chromosome(indiv) == [result0, result1, result2]
assert test_case0.get_last_execution_result() == result0
assert test_case1.get_last_execution_result() == result1
def test_mutation_delete_not_empty():
test_case = dtc.DefaultTestCase()
chromosome = tcc.TestCaseChromosome(test_case)
int0 = prim.IntPrimitiveStatement(test_case, 5)
int1 = prim.IntPrimitiveStatement(test_case, 5)
test_case.add_statement(int0)
test_case.add_statement(int1)
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
float_mock.side_effect = [0.0, 1.0]
with mock.patch.object(chromosome, "_delete_statement") as delete_mock:
delete_mock.return_value = True
assert chromosome._mutation_delete()
delete_mock.assert_has_calls([call(1)])
assert delete_mock.call_count == 1
def test_mutation_change_call_success(constructor_mock, result):
factory = MagicMock(tf.TestFactory)
factory.change_random_call.return_value = result
test_case = dtc.DefaultTestCase()
chromosome = tcc.TestCaseChromosome(test_case, test_factory=factory)
const0 = ps.ConstructorStatement(test_case, constructor_mock)
const0.return_value.distance = 5
test_case.add_statement(const0)
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
float_mock.return_value = 0.0
with mock.patch.object(const0, "mutate") as mutate_mock:
mutate_mock.return_value = False
assert chromosome._mutation_change() == result
mutate_mock.assert_called_once()
assert const0.return_value.distance == 5
def test_mutation_insert_twice_no_success():
test_factory = MagicMock(tf.TestFactory)
def side_effect(tc, pos):
return -1
test_factory.insert_random_statement.side_effect = side_effect
test_case = dtc.DefaultTestCase()
chromosome = tcc.TestCaseChromosome(test_case, test_factory=test_factory)
config.INSTANCE.statement_insertion_probability = 0.5
config.INSTANCE.chromosome_length = 10
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
float_mock.side_effect = [0.2, 0.2, 0.2]
assert not chromosome._mutation_insert()
test_factory.insert_random_statement.assert_has_calls(
[call(test_case, 0), call(test_case, 0)])
def _get_test_for_nested_branch_fixture(module) -> tcc.TestCaseChromosome:
test_case = dtc.DefaultTestCase()
int_stmt = prim_stmt.IntPrimitiveStatement(test_case, -50)
function_call = param_stmt.FunctionStatement(
test_case,
gao.GenericFunction(
module.nested_branches,
InferredSignature(signature=MagicMock(),
parameters={},
return_type=int),
),
[int_stmt.ret_val],
)
test_case.add_statement(int_stmt)
test_case.add_statement(function_call)
return tcc.TestCaseChromosome(test_case=test_case)
def test_mutation_insert_max_length():
test_factory = MagicMock(tf.TestFactory)
def side_effect(tc, pos):
tc.add_statement(prim.IntPrimitiveStatement(tc, 5))
return 0
test_factory.insert_random_statement.side_effect = side_effect
test_case = dtc.DefaultTestCase()
chromosome = tcc.TestCaseChromosome(test_case, test_factory=test_factory)
config.INSTANCE.statement_insertion_probability = 0.5
config.INSTANCE.chromosome_length = 1
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
float_mock.side_effect = [0.0, 0.0]
assert chromosome._mutation_insert()
test_factory.insert_random_statement.assert_has_calls([call(test_case, 0)])
assert test_case.size() == 1
def _get_test_for_no_branches_fixture(module) -> tcc.TestCaseChromosome:
test_case = dtc.DefaultTestCase()
int_stmt = prim_stmt.IntPrimitiveStatement(test_case, 5)
function_call = param_stmt.FunctionStatement(
test_case,
gao.GenericFunction(
module.identity,
InferredSignature(
signature=inspect.signature(module.identity),
parameters={"a": int},
return_type=int,
),
),
{"a": int_stmt.ret_val},
)
constructor_call = param_stmt.ConstructorStatement(
test_case,
gao.GenericConstructor(
module.DummyClass,
InferredSignature(
signature=inspect.signature(module.DummyClass.__init__),
parameters={"x": int},
return_type=module.DummyClass,
),
),
{"x": function_call.ret_val},
)
method_call = param_stmt.MethodStatement(
test_case,
gao.GenericMethod(
module.DummyClass,
module.DummyClass.get_x,
InferredSignature(signature=MagicMock(),
parameters={},
return_type=int),
),
constructor_call.ret_val,
)
test_case.add_statement(int_stmt)
test_case.add_statement(function_call)
test_case.add_statement(constructor_call)
test_case.add_statement(method_call)
return tcc.TestCaseChromosome(test_case=test_case)
def _get_test_for_single_branch_else_branch_fixture(
module) -> tcc.TestCaseChromosome:
test_case = dtc.DefaultTestCase()
int_stmt = prim_stmt.IntPrimitiveStatement(test_case, -5)
function_call = param_stmt.FunctionStatement(
test_case,
gao.GenericFunction(
module.first,
InferredSignature(
signature=inspect.signature(module.first),
parameters={"a": int},
return_type=int,
),
),
{"a": int_stmt.ret_val},
)
test_case.add_statement(int_stmt)
test_case.add_statement(function_call)
return tcc.TestCaseChromosome(test_case=test_case)
def generate_sequence(
self,
test_chromosome: tsc.TestSuiteChromosome,
failing_test_chromosome: tsc.TestSuiteChromosome,
execution_counter: int,
) -> None:
"""Implements one step of the adapted Randoop algorithm.
Args:
test_chromosome: The list of currently successful test cases
failing_test_chromosome: The list of currently not successful test cases
execution_counter: A current number of algorithm iterations
Raises:
GenerationException: In case an error occurs during generation
"""
self._logger.info("Algorithm iteration %d", execution_counter)
timer = Timer(name="Sequence generation", logger=None)
timer.start()
objects_under_test: Set[
gao.
GenericAccessibleObject] = self.test_cluster.accessible_objects_under_test
if not objects_under_test:
# In case we do not have any objects under test, we cannot generate a
# test case.
raise GenerationException(
"Cannot generate test case without an object-under-test!")
# Create new test case, i.e., sequence in Randoop paper terminology
# Pick a random public method from objects under test
method = self._random_public_method(objects_under_test)
# Select random test cases from existing ones to base generation on
tests = self._random_test_cases([
chromosome.test_case
for chromosome in test_chromosome.test_case_chromosomes
])
new_test = tcc.TestCaseChromosome(dtc.DefaultTestCase())
for test in tests:
new_test.test_case.append_test_case(test)
# Generate random values as input for the previously picked random method
# Extend the test case by the new method call
self.test_factory.append_generic_accessible(new_test.test_case, method)
# Discard duplicates
if (new_test in test_chromosome.test_case_chromosomes
or new_test in failing_test_chromosome.test_case_chromosomes):
return
with Timer(name="Execution time", logger=None):
# Execute new sequence
exec_result = self._executor.execute(new_test.test_case)
# Classify new test case and outputs
if exec_result.has_test_exceptions():
failing_test_chromosome.add_test_case_chromosome(new_test)
else:
test_chromosome.add_test_case_chromosome(new_test)
# TODO(sl) What about extensible flags?
self._execution_results.append(exec_result)
timer.stop()
def test_case_chromosome_with_test():
test_case = dtc.DefaultTestCase()
return tcc.TestCaseChromosome(test_case), test_case
def test_case_chromosome():
return tcc.TestCaseChromosome(dtc.DefaultTestCase())
def test_clone(chromosome):
chromosome.add_test_case_chromosome(
tcc.TestCaseChromosome(dtc.DefaultTestCase()))
result = chromosome.clone()
assert result == chromosome
assert result is not chromosome
def get_chromosome(self) -> tcc.TestCaseChromosome:
test_case = self._test_case_factory.get_test_case()
return tcc.TestCaseChromosome(test_case=test_case,
test_factory=self._test_factory)
