def test_mutate_success(field_mock, constructor_mock):
config.INSTANCE.change_parameter_probability = 1.0
test_case = dtc.DefaultTestCase()
const = ps.ConstructorStatement(test_case, constructor_mock)
const2 = ps.ConstructorStatement(test_case, constructor_mock)
field = fstmt.FieldStatement(test_case, field_mock, const.return_value)
const3 = ps.ConstructorStatement(test_case, constructor_mock)
test_case.add_statement(const)
test_case.add_statement(const2)
test_case.add_statement(field)
test_case.add_statement(const3)
assert field.mutate()
assert field.source == const2.return_value
def test_constructor_statement_accept(test_case_mock, variable_reference_mock,
constructor_mock):
statement = ps.ConstructorStatement(test_case_mock, constructor_mock)
visitor = MagicMock(sv.StatementVisitor)
statement.accept(visitor)
visitor.visit_constructor_statement.assert_called_once_with(statement)
def test_constructor_mutable_arg_count(test_case_mock, constructor_mock):
const = ps.ConstructorStatement(
test_case_mock,
constructor_mock,
{"test": MagicMock(vri.VariableReferenceImpl)},
)
assert const._mutable_argument_count() == 1
def add_constructor(
self,
test_case: tc.TestCase,
constructor: gao.GenericConstructor,
position: int = -1,
recursion_depth: int = 0,
allow_none: bool = True,
) -> vr.VariableReference:
"""Adds a constructor statement to a test case at a given position.
If the position is not given, the constructor will be appended on the end of
the test case. A given recursion depth controls how far the factory searches
for suitable parameter values.
Args:
test_case: The test case
constructor: The constructor to add to the test case
position: The position where to put the statement in the test case,
defaults to the end of the test case
recursion_depth: A recursion limit for the search of parameter values
allow_none: Whether or not a variable can be an None value
Returns:
A variable reference to the constructor
Raises:
ConstructionFailedException: if construction of an object failed
"""
self._logger.debug("Adding constructor %s", constructor)
if recursion_depth > config.INSTANCE.max_recursion:
self._logger.debug("Max recursion depth reached")
raise ConstructionFailedException("Max recursion depth reached")
if position < 0:
position = test_case.size()
signature = constructor.inferred_signature
length = test_case.size()
try:
parameters: List[vr.VariableReference] = self.satisfy_parameters(
test_case=test_case,
signature=signature,
position=position,
recursion_depth=recursion_depth + 1,
allow_none=allow_none,
)
new_length = test_case.size()
position = position + new_length - length
statement = par_stmt.ConstructorStatement(
test_case=test_case,
generic_callable=constructor,
args=parameters,
)
return test_case.add_statement(statement, position)
except BaseException as exception:
raise ConstructionFailedException(
f"Failed to add constructor for {constructor} "
f"due to {exception}.")
def test_statement_to_ast_constructor_no_args(statement_to_ast_visitor,
test_case_mock,
constructor_mock):
constr_stmt = param_stmt.ConstructorStatement(test_case_mock,
constructor_mock)
statement_to_ast_visitor.visit_constructor_statement(constr_stmt)
assert (astor.to_source(Module(body=statement_to_ast_visitor.ast_nodes)) ==
"var0 = module0.SomeType()\n")
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_test_case_equals_on_different_prim(
simple_test_case: dtc.DefaultTestCase, constructor_mock):
cloned = simple_test_case.clone()
# Original points to int at 0
simple_test_case.add_statement(
ps.ConstructorStatement(
simple_test_case,
constructor_mock,
{"y": simple_test_case.statements[0].ret_val},
))
# Clone points to int at 1
cloned.add_statement(
ps.ConstructorStatement(cloned, constructor_mock,
{"y": cloned.statements[1].ret_val}))
# Even though they both point to an int, they are not equal
assert not simple_test_case == cloned
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_constructor_statement_args(test_case_mock, variable_reference_mock,
constructor_mock):
statement = ps.ConstructorStatement(test_case_mock, constructor_mock)
references = [
MagicMock(vri.VariableReferenceImpl),
MagicMock(vri.VariableReferenceImpl),
]
statement.args = references
assert statement.args == references
def test_constructor_statement_kwargs(test_case_mock, variable_reference_mock,
constructor_mock):
statement = ps.ConstructorStatement(test_case_mock, constructor_mock)
references = {
"par1": MagicMock(vri.VariableReferenceImpl),
"par2": MagicMock(vri.VariableReferenceImpl),
}
statement.kwargs = references
assert statement.kwargs == references
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_constructor_param_count_of_type(test_case_mock, constructor_mock):
const = ps.ConstructorStatement(
test_case_mock,
constructor_mock,
{
"test0": vri.VariableReferenceImpl(test_case_mock, float),
"test1": vri.VariableReferenceImpl(test_case_mock, int),
},
)
assert const._param_count_of_type(float) == 1
def test_constructor_replace_argument(test_case_mock, constructor_mock):
var0 = vri.VariableReferenceImpl(test_case_mock, float)
var1 = vri.VariableReferenceImpl(test_case_mock, float)
var2 = vri.VariableReferenceImpl(test_case_mock, float)
var3 = vri.VariableReferenceImpl(test_case_mock, float)
const = ps.ConstructorStatement(test_case_mock, constructor_mock, [var0],
{"test0": var2})
const._replace_argument(0, var1)
assert const.args[0] is var1
const._replace_argument("test0", var3)
assert const.kwargs["test0"] is var3
def test_change_call_method(constructor_mock, method_mock):
test_case = dtc.DefaultTestCase()
test_case.add_statement(par_stmt.ConstructorStatement(test_case, constructor_mock))
test_case.add_statement(prim.IntPrimitiveStatement(test_case, 3))
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, method_mock)
assert test_case.statements[2].accessible_object() == method_mock
assert test_case.statements[2].return_value is to_replace.return_value
def test_select_random_variable_for_call_one(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))
const = par_stmt.ConstructorStatement(test_case, constructor_mock)
test_case.add_statement(const)
assert (tf.TestFactory._select_random_variable_for_call(
test_case, test_case.size()) == const.return_value)
def test_statement_to_ast_constructor_kwargs(
statement_to_ast_visitor, test_case_mock, variable_reference_mock, constructor_mock
):
constr_stmt = param_stmt.ConstructorStatement(
test_case_mock, constructor_mock, kwargs={"param1": variable_reference_mock},
)
statement_to_ast_visitor.visit_constructor_statement(constr_stmt)
assert (
astor.to_source(Module(body=statement_to_ast_visitor.ast_nodes))
== "var0 = module0.SomeType(param1=var1)\n"
)
def simple_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])
constructor_stmt.add_assertion(
pas.PrimitiveAssertion(constructor_stmt.return_value, 3))
test_case.add_statement(int_stmt)
test_case.add_statement(constructor_stmt)
return test_case
def test_constructor_replace_args(constructor_mock):
test_case = dtc.DefaultTestCase()
int0 = prim.IntPrimitiveStatement(test_case, 0)
new_value = prim.IntPrimitiveStatement(test_case, 0)
const = ps.ConstructorStatement(test_case, constructor_mock,
{"a": int0.ret_val})
test_case.add_statement(int0)
test_case.add_statement(new_value)
test_case.add_statement(const)
const.replace(int0.ret_val, new_value.ret_val)
assert const.args == {"a": new_value.ret_val}
def test_constructor_get_argument(test_case_mock, constructor_mock):
var0 = vri.VariableReferenceImpl(test_case_mock, float)
var1 = vri.VariableReferenceImpl(test_case_mock, float)
var2 = vri.VariableReferenceImpl(test_case_mock, float)
var3 = vri.VariableReferenceImpl(test_case_mock, float)
const = ps.ConstructorStatement(test_case_mock, constructor_mock,
[var0, var1], {
"test0": var2,
"test1": var3
})
assert const._get_argument(0) is var0
assert const._get_argument("test0") is var2
def test_constructor_mutate_parameter_choose_none(constructor_mock):
test_case = dtc.DefaultTestCase()
float0 = prim.FloatPrimitiveStatement(test_case, 5.0)
const = ps.ConstructorStatement(test_case, constructor_mock,
[float0.return_value])
test_case.add_statement(float0)
test_case.add_statement(const)
assert const._mutate_parameter(0)
assert isinstance(
test_case.get_statement(const.args[0].get_statement_position()),
prim.NoneStatement,
)
def test_constructor_mutate_parameter_get_objects(constructor_mock):
test_case = dtc.DefaultTestCase()
float0 = prim.FloatPrimitiveStatement(test_case, 5.0)
const = ps.ConstructorStatement(test_case, constructor_mock,
[float0.return_value])
test_case.add_statement(float0)
test_case.add_statement(const)
with mock.patch.object(const, "_test_case") as tc:
tc.get_objects.return_value = [float0.return_value]
assert const._mutate_parameter(0)
tc.get_objects.assert_called_with(float0.return_value.variable_type,
const.get_position())
def test_method_mutate_special_parameters_one_found(method_mock,
constructor_mock):
test_case = dtc.DefaultTestCase()
float0 = prim.FloatPrimitiveStatement(test_case, 5.0)
const0 = ps.ConstructorStatement(test_case, constructor_mock,
[float0.ret_val])
const1 = ps.ConstructorStatement(test_case, constructor_mock,
[float0.ret_val])
int0 = prim.IntPrimitiveStatement(test_case, 5)
meth = ps.MethodStatement(test_case, method_mock, const0.ret_val)
test_case.add_statement(float0)
test_case.add_statement(const0)
test_case.add_statement(const1)
test_case.add_statement(int0)
test_case.add_statement(meth)
with mock.patch.object(meth, "_test_case") as tc:
tc.get_objects.return_value = [const0.ret_val, const1.ret_val]
assert meth._mutate_special_parameters(1.0)
tc.get_objects.assert_called_with(const0.ret_val.variable_type,
meth.get_position())
assert meth.callee == const1.ret_val
def test_constructor_mutate_parameter_choose_existing(constructor_mock):
test_case = dtc.DefaultTestCase()
float0 = prim.FloatPrimitiveStatement(test_case, 5.0)
float1 = prim.FloatPrimitiveStatement(test_case, 5.0)
const = ps.ConstructorStatement(test_case, constructor_mock,
[float0.return_value])
test_case.add_statement(float0)
test_case.add_statement(float1)
test_case.add_statement(const)
with mock.patch("pynguin.utils.randomness.choice") as choice_mock:
choice_mock.side_effect = lambda coll: coll[0]
assert const._mutate_parameter(0)
def test_constructor_mutate_parameters_args(test_case_mock, constructor_mock,
variable_reference_mock):
const = ps.ConstructorStatement(
test_case_mock,
constructor_mock,
[variable_reference_mock, variable_reference_mock],
)
with mock.patch("pynguin.utils.randomness.next_float") as float_mock:
with mock.patch.object(const, "_mutate_parameter") as mutate_parameter:
mutate_parameter.return_value = True
float_mock.side_effect = [0.0, 1.0]
assert const._mutate_parameters(0.5)
mutate_parameter.assert_called_with(0)
def test_mutation_change_call_success(constructor_mock, result):
factory = MagicMock(tf.TestFactory)
factory.change_random_call.return_value = result
test_case = dtc.DefaultTestCase(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 test_case._mutation_change() == result
mutate_mock.assert_called_once()
assert const0.return_value.distance == 5
def assemble_stmt_from_gen_callable(
testcase: tc.TestCase,
gen_callable: GenericCallableAccessibleObject,
call: ast.Call,
ref_dict: Dict[str, vr.VariableReference],
) -> Optional[param_stmt.ParametrizedStatement]:
"""Takes a generic callable and assembles the corresponding parametrized statement
from it.
Args:
testcase: the testcase of the statement
gen_callable: the corresponding callable of the cluster
call: the ast.Call statement
ref_dict: a dictionary containing key value pairs of variable ids and
variable references.
Returns:
The corresponding statement.
"""
for arg in call.args:
if not isinstance(arg, (ast.Name, ast.Starred)):
return None
for keyword in call.keywords:
if not isinstance(keyword, ast.keyword):
return None
var_refs = create_variable_references_from_call_args(
call.args,
call.keywords,
gen_callable,
ref_dict # type: ignore
)
if var_refs is None:
return None
if isinstance(gen_callable, GenericFunction):
return param_stmt.FunctionStatement(
testcase, cast(GenericCallableAccessibleObject, gen_callable),
var_refs)
if isinstance(gen_callable, GenericMethod):
return param_stmt.MethodStatement(
testcase,
gen_callable,
ref_dict[call.func.value.id], # type: ignore
var_refs,
)
if isinstance(gen_callable, GenericConstructor):
return param_stmt.ConstructorStatement(
testcase, cast(GenericCallableAccessibleObject, gen_callable),
var_refs)
return None
def test_constructor_statement_clone(constructor_mock):
test_case = dtc.DefaultTestCase()
int_prim = prim.IntPrimitiveStatement(test_case, 5)
method_stmt = ps.ConstructorStatement(
test_case,
constructor_mock,
{"y": int_prim.ret_val},
)
test_case.add_statement(int_prim)
test_case.add_statement(method_stmt)
cloned = test_case.clone()
assert isinstance(cloned.statements[1], ps.ConstructorStatement)
assert cloned.statements[1] is not method_stmt
assert cloned.statements[0].ret_val is not test_case.statements[0].ret_val
def test_constructor_mutate_parameter_choose_none(constructor_mock):
test_case = dtc.DefaultTestCase()
float0 = prim.FloatPrimitiveStatement(test_case, 5.0)
const = ps.ConstructorStatement(test_case, constructor_mock,
{"a": float0.ret_val})
test_case.add_statement(float0)
test_case.add_statement(const)
with mock.patch("pynguin.testcase.testfactory.is_optional_parameter"
) as optional_mock:
optional_mock.return_value = False
assert const._mutate_parameter("a", MagicMock(parameters={"a": float}))
assert isinstance(
test_case.get_statement(const.args["a"].get_statement_position()),
prim.NoneStatement,
)
def test_constructor_mutate_parameter_not_included(constructor_mock):
test_case = dtc.DefaultTestCase()
float0 = prim.FloatPrimitiveStatement(test_case, 5.0)
const = ps.ConstructorStatement(test_case, constructor_mock,
[float0.return_value])
test_case.add_statement(float0)
test_case.add_statement(const)
with mock.patch.object(test_case, "get_objects") as get_objs:
get_objs.return_value = []
assert const._mutate_parameter(0)
get_objs.assert_called_with(float0.return_value.variable_type, 1)
assert isinstance(
test_case.get_statement(const.args[0].get_statement_position()),
prim.NoneStatement,
)