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