def test_eq_different_tests(chromosome):
test_1 = dtc.DefaultTestCase()
test_2 = dtc.DefaultTestCase()
test_3 = MagicMock(tc.TestCase)
other = tsc.TestSuiteChromosome()
chromosome.add_tests([test_1, test_2])
other.add_tests([test_1, test_3])
assert not chromosome.__eq__(other)
def test_constructor_clone_args(constructor_mock):
test_case = dtc.DefaultTestCase()
new_test_case = dtc.DefaultTestCase()
to_clone = MagicMock(vri.VariableReferenceImpl)
the_clone = MagicMock(vri.VariableReferenceImpl)
to_clone.clone.return_value = the_clone
const = ps.ConstructorStatement(test_case, constructor_mock, [to_clone])
assert const._clone_args(new_test_case, 10) == [the_clone]
to_clone.clone.assert_called_with(new_test_case, 10)
def test_field_statement_eq_clone(field_mock):
test_case1 = dtc.DefaultTestCase()
test_case1.add_statement(prim.IntPrimitiveStatement(test_case1, 0))
test_case2 = dtc.DefaultTestCase()
test_case2.add_statement(prim.IntPrimitiveStatement(test_case2, 0))
statement = fstmt.FieldStatement(test_case1, field_mock,
test_case1.statements[0].ret_val)
test_case1.add_statement(statement)
clone = statement.clone(test_case2)
test_case2.add_statement(clone)
assert statement.__eq__(clone)
def test_crossover(chromosome):
cases_a = [dtc.DefaultTestCase() for _ in range(5)]
cases_b = [dtc.DefaultTestCase() for _ in range(5)]
chromosome.add_tests(cases_a)
other = tsc.TestSuiteChromosome()
other.add_tests(cases_b)
pos1 = randomness.next_int(len(cases_a))
pos2 = randomness.next_int(len(cases_b))
chromosome.set_changed(False)
chromosome.cross_over(other, pos1, pos2)
assert chromosome.test_chromosomes == cases_a[:pos1] + cases_b[pos2:]
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_delete_statement(result):
test_factory = MagicMock(tf.TestFactory)
test_factory.delete_statement_gracefully.return_value = result
test_case = dtc.DefaultTestCase(test_factory)
test_case.add_statement(prim.IntPrimitiveStatement(test_case, 5))
assert test_case._delete_statement(0) == result
test_factory.delete_statement_gracefully.assert_called_with(test_case, 0)
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_add_method(provide_callables_from_fixtures_modules,
test_cluster_mock):
test_case = dtc.DefaultTestCase()
object_ = Monkey("foo")
methods = inspect.getmembers(object_, inspect.ismethod)
generic_method = gao.GenericMethod(
owner=provide_callables_from_fixtures_modules["Monkey"],
method=methods[3][1],
inferred_signature=InferredSignature(
signature=Signature(parameters=[
Parameter(
name="sentence",
kind=Parameter.POSITIONAL_OR_KEYWORD,
annotation=str,
),
]),
return_type=provide_callables_from_fixtures_modules["Monkey"],
parameters={"sentence": str},
),
)
test_cluster_mock.select_concrete_type.side_effect = lambda x: x
factory = tf.TestFactory(test_cluster_mock)
config.INSTANCE.none_probability = 1.0
result = factory.add_method(test_case, generic_method, position=0)
assert result.variable_type == provide_callables_from_fixtures_modules[
"Monkey"]
assert test_case.size() == 3
def test_add_function(provide_callables_from_fixtures_modules):
config.INSTANCE.object_reuse_probability = 0.0
test_case = dtc.DefaultTestCase()
generic_function = gao.GenericFunction(
function=provide_callables_from_fixtures_modules["triangle"],
inferred_signature=InferredSignature(
signature=Signature(parameters=[
Parameter(name="x",
kind=Parameter.POSITIONAL_OR_KEYWORD,
annotation=int),
Parameter(name="y",
kind=Parameter.POSITIONAL_OR_KEYWORD,
annotation=int),
Parameter(name="z",
kind=Parameter.POSITIONAL_OR_KEYWORD,
annotation=int),
]),
return_type=None,
parameters={
"x": int,
"y": int,
"z": int
},
),
)
cluster = MagicMock(TestCluster)
cluster.select_concrete_type.side_effect = lambda x: x
factory = tf.TestFactory(cluster)
result = factory.add_function(test_case, generic_function, position=0)
assert isinstance(result.variable_type, type(None))
assert test_case.size() <= 4
def test_attempt_generation_for_none_type(test_cluster_mock):
config.configuration.none_probability = 1.0
factory = tf.TestFactory(test_cluster_mock)
result = factory._attempt_generation(
dtc.DefaultTestCase(), MagicMock(tf.TestFactory), 0, 0, True
)
assert result.distance == 0
def test_attempt_generation_for_none_type_with_no_probability(
test_cluster_mock):
config.INSTANCE.none_probability = 0.0
factory = tf.TestFactory(test_cluster_mock)
result = factory._attempt_generation(dtc.DefaultTestCase(),
MagicMock(tf.TestFactory), 0, 0, True)
assert result is None
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(test_chromosome.test_chromosomes)
new_test: tc.TestCase = dtc.DefaultTestCase()
for test in tests:
new_test.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_statement(new_test, method)
# Discard duplicates
if (new_test in test_chromosome.test_chromosomes
or new_test in failing_test_chromosome.test_chromosomes):
return
with Timer(name="Execution time", logger=None):
# Execute new sequence
exec_result = self._executor.execute([new_test])
# Classify new test case and outputs
if exec_result.has_test_exceptions():
failing_test_chromosome.add_test(new_test)
else:
test_chromosome.add_test(new_test)
# TODO(sl) What about extensible flags?
self._execution_results.append(exec_result)
timer.stop()
def test_simple_execution():
config.INSTANCE.module_name = "tests.fixtures.accessibles.accessible"
tracer = ExecutionTracer()
with install_import_hook(config.INSTANCE.module_name, tracer):
test_case = dtc.DefaultTestCase()
test_case.add_statement(prim_stmt.IntPrimitiveStatement(test_case, 5))
executor = TestCaseExecutor(tracer)
assert not executor.execute([test_case]).has_test_exceptions()
def test_append_test_case(default_test_case):
stmt = MagicMock(st.Statement)
stmt.clone.return_value = stmt
other = dtc.DefaultTestCase()
other._statements = [stmt]
assert len(default_test_case.statements) == 0
default_test_case.append_test_case(other)
assert len(default_test_case.statements) == 1
def test_mutate_no_replacements(field_mock, constructor_mock):
config.INSTANCE.change_parameter_probability = 1.0
test_case = dtc.DefaultTestCase()
const = ps.ConstructorStatement(test_case, constructor_mock)
field = fstmt.FieldStatement(test_case, field_mock, const.return_value)
test_case.add_statement(const)
test_case.add_statement(field)
assert not field.mutate()
def test_constructor_replace_return_value(constructor_mock):
test_case = dtc.DefaultTestCase()
new_value = prim.IntPrimitiveStatement(test_case, 0)
const = ps.ConstructorStatement(test_case, constructor_mock)
test_case.add_statement(new_value)
test_case.add_statement(const)
const.replace(const.return_value, new_value.return_value)
assert const.return_value == new_value.return_value
def test_primitive_statement_replace_ignore(field_mock):
test_case = dtc.DefaultTestCase()
ref = prim.IntPrimitiveStatement(test_case, 5)
statement = fstmt.FieldStatement(test_case, field_mock, ref.return_value)
new = prim.FloatPrimitiveStatement(test_case, 0).return_value
old = statement.source
statement.replace(new, new)
assert statement.source == old
def get_test_case(self) -> tc.TestCase:
test_case = dtc.DefaultTestCase()
attempts = 0
size = randomness.next_int(1, config.configuration.chromosome_length + 1)
while test_case.size() < size and attempts < config.configuration.max_attempts:
self._test_factory.insert_random_statement(test_case, test_case.size())
attempts += 1
return test_case
def short_test_case(constructor_mock):
test_case = dtc.DefaultTestCase()
int_stmt = prim_stmt.IntPrimitiveStatement(test_case, 5)
constructor_stmt = param_stmt.ConstructorStatement(test_case,
constructor_mock,
[int_stmt.return_value])
test_case.add_statement(int_stmt)
test_case.add_statement(constructor_stmt)
return test_case
def test_select_random_variable_for_call_none(constructor_mock, function_mock):
test_case = dtc.DefaultTestCase()
test_case.add_statement(prim.NoneStatement(test_case, MagicMock))
test_case.add_statement(prim.FloatPrimitiveStatement(test_case, 5.0))
function_mock.inferred_signature.update_return_type(None)
test_case.add_statement(
par_stmt.FunctionStatement(test_case, function_mock))
assert (tf.TestFactory._select_random_variable_for_call(
test_case, test_case.size()) is None)
def test_mutation_delete_skipping():
test_case = dtc.DefaultTestCase()
with mock.patch.object(test_case, "_delete_statement") as delete_mock:
delete_mock.return_value = True
with mock.patch.object(test_case,
"_get_last_mutatable_statement") as mut_mock:
mut_mock.return_value = 3
assert not test_case._mutation_delete()
assert delete_mock.call_count == 0
def test_change_random_call_primitive(function_mock):
test_case = dtc.DefaultTestCase()
float_prim = prim.FloatPrimitiveStatement(test_case, 5.0)
test_case.add_statement(float_prim)
test_cluster = MagicMock(TestCluster)
test_cluster.get_generators_for.return_value = {function_mock}
test_factory = tf.TestFactory(test_cluster)
assert not test_factory.change_random_call(test_case, float_prim)
def test_delete_statement_gracefully_no_alternatives(function_mock):
test_case = dtc.DefaultTestCase()
float_prim = prim.FloatPrimitiveStatement(test_case, 5.0)
float_function1 = par_stmt.FunctionStatement(test_case, function_mock,
[float_prim.return_value])
test_case.add_statement(float_prim)
test_case.add_statement(float_function1)
assert tf.TestFactory.delete_statement_gracefully(test_case, 0)
assert test_case.size() == 0
def test_create_primitive(type_, statement_type):
factory = tf.TestFactory(MagicMock(TestCluster))
result = factory._create_primitive(
dtc.DefaultTestCase(),
type_,
position=0,
recursion_depth=0,
)
assert result.variable_type == statement_type
def test_change_call_function(function_mock):
test_case = dtc.DefaultTestCase()
test_case.add_statement(prim.FloatPrimitiveStatement(test_case, 3.5))
to_replace = prim.NoneStatement(test_case, float)
test_case.add_statement(to_replace)
test_cluster = MagicMock(TestCluster)
test_factory = tf.TestFactory(test_cluster)
test_factory.change_call(test_case, to_replace, function_mock)
assert test_case.statements[1].accessible_object() == function_mock
assert test_case.statements[1].return_value is to_replace.return_value
def test_delete_statement_gracefully_no_dependencies(function_mock):
test_case = dtc.DefaultTestCase()
float_prim0 = prim.FloatPrimitiveStatement(test_case, 5.0)
float_prim1 = prim.FloatPrimitiveStatement(test_case, 5.0)
float_prim2 = prim.FloatPrimitiveStatement(test_case, 5.0)
test_case.add_statement(float_prim0)
test_case.add_statement(float_prim1)
test_case.add_statement(float_prim2)
assert tf.TestFactory.delete_statement_gracefully(test_case, 1)
assert test_case.statements == [float_prim0, float_prim2]
def test_insert_random_call_on_object_no_success():
test_case = dtc.DefaultTestCase()
test_cluster = MagicMock(TestCluster)
test_cluster.num_accessible_objects_under_test.return_value = 0
test_factory = tf.TestFactory(test_cluster)
with mock.patch.object(test_factory,
"_select_random_variable_for_call") as select_mock:
select_mock.return_value = None
assert not test_factory.insert_random_call_on_object(test_case, 0)
select_mock.assert_called_with(test_case, 0)
def test__rollback_changes_nothing_to_rollback():
test_case = dtc.DefaultTestCase()
test_case.add_statement(prim.IntPrimitiveStatement(test_case, 5))
test_case.add_statement(prim.IntPrimitiveStatement(test_case, 10))
test_case.add_statement(prim.IntPrimitiveStatement(test_case, 15))
cloned = test_case.clone()
tf.TestFactory._rollback_changes(test_case, cloned.size(), 3)
assert cloned == test_case
def test_primitive_statement_replace(field_mock):
test_case = dtc.DefaultTestCase()
ref = prim.IntPrimitiveStatement(test_case, 5)
test_case.add_statement(ref)
statement = fstmt.FieldStatement(test_case, field_mock, ref.return_value)
test_case.add_statement(statement)
new = vri.VariableReferenceImpl(test_case, int)
statement.replace(ref.return_value, new)
assert statement.source == new
def test_simple_execution():
config.configuration.module_name = "tests.fixtures.accessibles.accessible"
tracer = ExecutionTracer()
with install_import_hook(config.configuration.module_name, tracer):
module = importlib.import_module(config.configuration.module_name)
importlib.reload(module)
test_case = dtc.DefaultTestCase()
test_case.add_statement(prim_stmt.IntPrimitiveStatement(test_case, 5))
executor = TestCaseExecutor(tracer)
assert not executor.execute(test_case).has_test_exceptions()
