def split_chromosomes(
self,
) -> Tuple[tsc.TestSuiteChromosome, tsc.TestSuiteChromosome]:
"""Split the chromosome into two chromosomes.
The first one contains the non failing test cases.
The second one contains the failing test cases.
Returns:
A tuple of passing and failing chromosomes
"""
best = self._get_best_individual()
# Make sure all test cases have a cached result.
best.get_fitness()
non_failing = tsc.TestSuiteChromosome()
failing = tsc.TestSuiteChromosome()
for fitness_function in self._fitness_functions:
non_failing.add_fitness_function(fitness_function)
failing.add_fitness_function(fitness_function)
for test_case_chromosome in best.test_case_chromosomes:
result = test_case_chromosome.get_last_execution_result()
assert result is not None
if result.has_test_exceptions():
failing.add_test_case_chromosome(test_case_chromosome.clone())
else:
non_failing.add_test_case_chromosome(test_case_chromosome.clone())
return non_failing, failing
def test_generate_sequence_duplicate(executor):
test_cluster = MagicMock(TestCluster)
test_cluster.accessible_objects_under_test = set()
algorithm = RandomTestStrategy(executor, test_cluster)
algorithm._random_public_method = lambda x: None
test_case = dtc.DefaultTestCase()
algorithm._random_test_cases = lambda x: [test_case]
with pytest.raises(GenerationException):
algorithm.generate_sequence(
tsc.TestSuiteChromosome(),
tsc.TestSuiteChromosome(),
0,
)
def test_generate_sequence_duplicate(executor):
config.configuration.algorithm = config.Algorithm.RANDOM
test_cluster = MagicMock(TestCluster)
test_cluster.accessible_objects_under_test = set()
algorithm = gaf.TestSuiteGenerationAlgorithmFactory(
executor, test_cluster).get_search_algorithm()
algorithm._random_public_method = lambda x: None # pragma: no cover
test_case = dtc.DefaultTestCase()
algorithm._random_test_cases = lambda x: [test_case] # pragma: no cover
assert isinstance(algorithm, RandomTestStrategy)
with pytest.raises(GenerationException):
algorithm.generate_sequence(
tsc.TestSuiteChromosome(),
tsc.TestSuiteChromosome(),
0,
)
def chromosome():
chrom = tsc.TestSuiteChromosome()
fitness_func = MagicMock(ff.FitnessFunction)
fitness_func.is_maximisation_function.return_value = False
chrom.add_fitness_function(fitness_func)
chrom._update_fitness_values(fitness_func, ff.FitnessValues(0, 0))
chrom.set_changed(False)
return chrom
def test_generate_sequence(has_exceptions, executor):
exec_result = MagicMock(ExecutionResult)
exec_result.has_test_exceptions.return_value = has_exceptions
executor.execute.return_value = exec_result
test_cluster = MagicMock(TestCluster)
test_cluster.accessible_objects_under_test = set()
algorithm = RandomTestStrategy(executor, test_cluster)
algorithm._random_public_method = lambda x: None
test_case = dtc.DefaultTestCase()
test_case.add_statement(MagicMock(stmt.Statement))
algorithm._random_test_cases = lambda x: [test_case]
with pytest.raises(GenerationException):
algorithm.generate_sequence(
tsc.TestSuiteChromosome(),
tsc.TestSuiteChromosome(),
0,
)
def test_eq_different_tests(chromosome):
test_1 = MagicMock(tcc.TestCaseChromosome)
test_2 = MagicMock(tcc.TestCaseChromosome)
test_3 = MagicMock(tcc.TestCaseChromosome)
other = tsc.TestSuiteChromosome()
chromosome.add_test_case_chromosomes([test_1, test_2])
other.add_test_case_chromosomes([test_1, test_3])
assert not chromosome.__eq__(other)
def generate_sequences(
self, ) -> Tuple[tsc.TestSuiteChromosome, tsc.TestSuiteChromosome]:
stopping_condition = self.get_stopping_condition()
stopping_condition.reset()
test_chromosome: tsc.TestSuiteChromosome = tsc.TestSuiteChromosome()
failing_test_chromosome: tsc.TestSuiteChromosome = tsc.TestSuiteChromosome(
)
generation: int = 0
fitness_functions = self.get_fitness_functions()
for fitness_function in fitness_functions:
test_chromosome.add_fitness_function(fitness_function)
failing_test_chromosome.add_fitness_function(fitness_function)
combined_chromosome = self._combine_current_individual(
test_chromosome, failing_test_chromosome)
while (not self.is_fulfilled(stopping_condition)
and combined_chromosome.get_fitness() != 0.0):
try:
generation += 1
stopping_condition.iterate()
self.generate_sequence(
test_chromosome,
failing_test_chromosome,
generation,
)
combined_chromosome = self._combine_current_individual(
test_chromosome, failing_test_chromosome)
StatisticsTracker().current_individual(combined_chromosome)
self._logger.info(
"Generation: %5i. Best fitness: %5f, Best coverage %5f",
generation,
combined_chromosome.get_fitness(),
combined_chromosome.get_coverage(),
)
except (ConstructionFailedException,
GenerationException) as exception:
self._logger.debug(
"Generate test case failed with exception %s", exception)
self._logger.debug("Number of algorithm iterations: %d", generation)
StatisticsTracker().track_output_variable(
RuntimeVariable.AlgorithmIterations, generation)
return test_chromosome, failing_test_chromosome
def get_chromosome(self) -> tsc.TestSuiteChromosome:
chromosome = tsc.TestSuiteChromosome(self.test_case_chromosome_factory)
num_tests = randomness.next_int(config.INSTANCE.min_initial_tests,
config.INSTANCE.max_initial_tests + 1)
for _ in range(num_tests):
chromosome.add_test_case_chromosome(
self.test_case_chromosome_factory.get_chromosome())
return chromosome
def test_generate_sequence(has_exceptions, executor):
config.configuration.algorithm = config.Algorithm.RANDOM
exec_result = MagicMock(ExecutionResult)
exec_result.has_test_exceptions.return_value = has_exceptions
executor.execute.return_value = exec_result
test_cluster = MagicMock(TestCluster)
test_cluster.accessible_objects_under_test = set()
algorithm = gaf.TestSuiteGenerationAlgorithmFactory(
executor, test_cluster).get_search_algorithm()
algorithm._random_public_method = lambda x: None # pragma: no cover
test_case = dtc.DefaultTestCase()
test_case.add_statement(MagicMock(stmt.Statement))
algorithm._random_test_cases = lambda x: [test_case] # pragma: no cover
assert isinstance(algorithm, RandomTestStrategy)
with pytest.raises(GenerationException):
algorithm.generate_sequence(
tsc.TestSuiteChromosome(),
tsc.TestSuiteChromosome(),
0,
)
def test_mutate_no_changes():
test_case_chromosome_factory = MagicMock(tccf.TestCaseChromosomeFactory)
chromosome = tsc.TestSuiteChromosome(test_case_chromosome_factory)
test_1 = MagicMock(tcc.TestCaseChromosome)
test_1.size.return_value = 1
test_1.has_changed.return_value = True
chromosome.add_test_case_chromosome(test_1)
chromosome.set_changed(False)
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
# Prevent any other mutations/insertions.
float_mock.side_effect = [1.0, 1.0, 1.0]
chromosome.mutate()
assert chromosome.test_case_chromosomes == [test_1]
assert not chromosome.has_changed()
def test_mutate_add_new_max_size():
test_case_chromosome_factory = MagicMock(tccf.TestCaseChromosomeFactory)
test_case = MagicMock(tcc.TestCaseChromosome)
test_case.size.return_value = 1
test_case_chromosome_factory.get_chromosome.return_value = test_case
chromosome = tsc.TestSuiteChromosome(test_case_chromosome_factory)
chromosome.set_changed(False)
config.configuration.test_insertion_probability = 0.5
config.configuration.max_size = 2
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
float_mock.side_effect = [0.1, 0.1, 0.1]
chromosome.mutate()
assert test_case_chromosome_factory.get_chromosome.call_count == 2
assert chromosome.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_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 create_test_suite(
self, population: Iterable[tcc.TestCaseChromosome]
) -> chrom.Chromosome:
"""Wraps a population of test-case chromosomes in a test-suite chromosome.
This will add the fitness function attached to this mixin to the resulting
chromosome.
Args:
population: A list of test-case chromosomes
Returns:
A test-suite chromosome
"""
suite = tsc.TestSuiteChromosome()
suite.add_test_case_chromosomes(list(population))
suite.add_fitness_function(self._test_suite_fitness_function)
return suite
def test_get_output_variables_with_content(sequence_factory, chromosome):
def check_result(name: str, value: int, index: int):
assert name == f"CoverageTimeline_T{index}"
assert value == 42
config.INSTANCE.budget = 0.25
chromosome_2 = tsc.TestSuiteChromosome()
sequence_factory.set_start_time(time.time_ns())
time.sleep(0.05)
sequence_factory.update(chromosome)
time.sleep(0.05)
sequence_factory.update(chromosome_2)
time.sleep(0.05)
variables = sequence_factory.get_output_variables()
[
check_result(var.name, var.value, index + 1)
for index, var in enumerate(variables)
]
assert len(variables) >= 0
def test_mutate_remove_empty():
test_case_chromosome_factory = MagicMock(tccf.TestCaseChromosomeFactory)
chromosome = tsc.TestSuiteChromosome(test_case_chromosome_factory)
test_1 = MagicMock(tcc.TestCaseChromosome)
test_1.size.return_value = 1
test_1.has_changed.return_value = True
test_2 = MagicMock(tcc.TestCaseChromosome)
test_2.size.return_value = 0
chromosome.add_test_case_chromosome(test_1)
chromosome.add_test_case_chromosome(test_2)
chromosome.set_changed(False)
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
# Prevent any other mutations/insertions.
float_mock.side_effect = [1.0, 1.0, 1.0]
chromosome.mutate()
assert chromosome.test_case_chromosomes == [test_1]
# A test case can only have a size of zero if it was mutated, but this already sets changed to True
# So this check is valid
assert not chromosome.has_changed()
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_mutate_existing():
test_case_chromosome_factory = MagicMock(tccf.TestCaseChromosomeFactory)
chromosome = tsc.TestSuiteChromosome(test_case_chromosome_factory)
test_1 = MagicMock(tcc.TestCaseChromosome)
test_1.size.return_value = 1
test_1.has_changed.return_value = True
test_2 = MagicMock(tcc.TestCaseChromosome)
test_2.size.return_value = 1
test_2.has_changed.return_value = False
test_3 = MagicMock(tcc.TestCaseChromosome)
test_3.size.return_value = 1
chromosome.add_test_case_chromosome(test_1)
chromosome.add_test_case_chromosome(test_2)
chromosome.set_changed(False)
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
float_mock.side_effect = [0.0, 0.0, 1.0, 1.0]
chromosome.mutate()
test_1.mutate.assert_called_once()
test_2.mutate.assert_called_once()
test_3.mutate.assert_not_called()
assert chromosome.has_changed()
def test_eq_different_size(chromosome):
chromosome.add_test_case_chromosome(MagicMock(tcc.TestCaseChromosome))
other = tsc.TestSuiteChromosome()
other.add_test_case_chromosome(MagicMock(tcc.TestCaseChromosome))
other.add_test_case_chromosome(MagicMock(tcc.TestCaseChromosome))
assert not chromosome.__eq__(other)
executor, test_cluster = setup_result
with Timer(name="Test generation time", logger=None):
algorithm: TestGenerationStrategy = (
self._instantiate_test_generation_strategy(
executor, test_cluster))
self._logger.info("Start generating sequences using %s",
config.INSTANCE.algorithm)
StatisticsTracker().set_sequence_start_time(time.time_ns())
non_failing, failing = algorithm.generate_sequences()
self._logger.info("Stop generating sequences using %s",
config.INSTANCE.algorithm)
algorithm.send_statistics()
with Timer(name="Re-execution time", logger=None):
combined = tsc.TestSuiteChromosome()
for fitness_func in non_failing.get_fitness_functions():
combined.add_fitness_function(fitness_func)
combined.add_test_case_chromosomes(
non_failing.test_case_chromosomes)
combined.add_test_case_chromosomes(
failing.test_case_chromosomes)
StatisticsTracker().track_output_variable(
RuntimeVariable.Coverage, combined.get_coverage())
if config.INSTANCE.generate_assertions:
generator = ag.AssertionGenerator(executor)
for chromosome in [non_failing, failing]:
test_cases = [
chrom.test_case
for chrom in chromosome.test_case_chromosomes
def __init__(self):
"""Create new chromosome converter."""
# TODO(fk) Need to handle fitness functions.
self._failing_test_suite = tsc.TestSuiteChromosome()
self._passing_test_suite = tsc.TestSuiteChromosome()
def chromosome():
return tsc.TestSuiteChromosome()
