module, typeinferrer = cs._parse_text(program) listcomp_node = list(module.nodes_of_class(astroid.ListComp))[0] expected_type = List[listcomp_node.generators[0].iter.type_constraints.type.__args__[0]] assert listcomp_node.type_constraints.type == expected_type @given(cs.homogeneous_iterable) def test_list_comprehension_single_target_name_heterogeneous_iterable(iterable): """Test Comprehension node visitor representing a comprehension expression with a single target and a name expression over a heterogeneous list.""" program = f'[num for num in {repr(iterable)}]' module, typeinferrer = cs._parse_text(program) listcomp_node = list(module.nodes_of_class(astroid.ListComp))[0] expected_type = List[listcomp_node.generators[0].iter.type_constraints.type.__args__[0]] assert listcomp_node.type_constraints.type == expected_type @given(cs.valid_identifier(min_size=1)) def test_list_comprehension_single_target_name_string(iterable): """Test Comprehension node visitor representing a comprehension expression with a single target and a name expression over a string.""" program = f'[num for num in {repr(iterable)}]' module, typeinferrer = cs._parse_text(program) listcomp_node = list(module.nodes_of_class(astroid.ListComp))[0] expected_type = List[listcomp_node.generators[0].iter.type_constraints.type] assert listcomp_node.type_constraints.type == expected_type if __name__ == '__main__': nose.main()
a homogeneous iterable.""" program = '{elt for elt in ' + repr(iterable) + '}' module, _ = cs._parse_text(program) setcomp_node = list(module.nodes_of_class(astroid.SetComp))[0] assert setcomp_node.inf_type.getValue() == Set[setcomp_node.generators[0].iter.inf_type.getValue().__args__[0]] @given(cs.heterogeneous_iterable) @settings(suppress_health_check=[HealthCheck.too_slow]) def test_set_comprehension_reproduce_heterogeneous(iterable): """Test SetComp node visitor representing a comprehension expression reproducing a set of elements of a heterogeneous iterable.""" program = '{elt for elt in ' + repr(iterable) + '}' module, _ = cs._parse_text(program) setcomp_node = list(module.nodes_of_class(astroid.SetComp))[0] assert setcomp_node.inf_type.getValue() == Set[setcomp_node.generators[0].iter.inf_type.getValue().__args__[0]] @given(cs.valid_identifier(min_size=1)) @settings(suppress_health_check=[HealthCheck.too_slow]) def test_set_comprehension_reproduce_string(iterable): """Test SetComp node visitor representing a comprehension expression reproducing a set of elements of a string.""" program = '{elt for elt in ' + repr(iterable) + '}' module, _ = cs._parse_text(program) setcomp_node = list(module.nodes_of_class(astroid.SetComp))[0] assert setcomp_node.inf_type.getValue() == Set[setcomp_node.generators[0].iter.inf_type.getValue()] if __name__ == '__main__': nose.main()
settings.load_profile("pyta") def _parse_to_function(function_name, args_list, return_statement): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):' \ f' return {return_statement}' def _parse_to_function_no_return(function_name, args_list, function_body): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):\n' \ f' {function_body}' @given(cs.valid_identifier(), cs.primitive_values) @settings(suppress_health_check=[HealthCheck.too_slow]) def test_function_def_no_args(function_name, return_value): """Test FunctionDef node visitors representing function definitions with no parameters and primitive return type.""" assume(not iskeyword(function_name)) program = _parse_to_function(function_name, [], repr(return_value)) module, inferer = cs._parse_text(program) function_type_var = module.type_environment.lookup_in_env(function_name) function_def_node = list(module.nodes_of_class(astroid.FunctionDef))[0] return_tvar = function_def_node.type_environment.lookup_in_env('return') return_type = inferer.type_constraints.resolve(return_tvar).getValue() assert inferer.type_constraints.resolve(function_type_var).getValue() == Callable[[], return_type] @given(cs.valid_identifier(), cs.primitive_values) @settings(suppress_health_check=[HealthCheck.too_slow])
settings.load_profile("pyta") def _parse_to_function(function_name, args_list, return_statement): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):' \ f' return {return_statement}' def _parse_to_function_no_return(function_name, args_list, function_body): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):\n' \ f' {function_body}' @given(cs.valid_identifier(), hs.lists(cs.valid_identifier(), min_size=1)) @settings(suppress_health_check=[HealthCheck.too_slow]) def test_inference_args_simple_return(function_name, arguments): """Test whether visitor was able to infer type of argument given function called on it in function body.""" assume(function_name not in arguments) for argument in arguments: program = _parse_to_function_no_return(function_name, arguments, ('return ' + argument + " + " + repr('bob'))) module, inferer = cs._parse_text(program) # get the functionDef node - there is only one in this test case. function_def_node = next(module.nodes_of_class(astroid.FunctionDef)) expected_arg_type_vars = [function_def_node.type_environment.lookup_in_env(argument) for argument in arguments] expected_arg_types = [inferer.type_constraints.resolve(type_var).getValue() for type_var in expected_arg_type_vars] function_type_var = module.type_environment.lookup_in_env(function_name) function_type = inferer.type_constraints.resolve(function_type_var).getValue() actual_arg_types, actual_return_type = types_in_callable(inferer, function_type) assert expected_arg_types == actual_arg_types
settings.load_profile("pyta") def _parse_to_function(function_name, args_list, return_statement): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):' \ f' return {return_statement}' def _parse_to_function_no_return(function_name, args_list, function_body): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):\n' \ f' {function_body}' @given(cs.valid_identifier(), cs.primitive_values) def test_function_def_no_args(function_name, return_value): """Test FunctionDef node visitors representing function definitions with no parameters and primitive return type.""" assume(not iskeyword(function_name)) program = _parse_to_function(function_name, [], repr(return_value)) module = cs._parse_text(program) function_type_var = module.type_environment.lookup_in_env(function_name) assert TYPE_CONSTRAINTS.lookup_concrete(function_type_var) == Callable[ [], type(return_value)] @given(cs.valid_identifier(), cs.primitive_values) def test_function_def_call_no_args(function_name, return_value): """Test type setting in environment of a function call for a function with no parameters.""" program = _parse_to_function( function_name, [], repr(return_value)) + "\n" + function_name + "()\n"
""" program = f'class Student:\n' \ f' name: str\n' \ f' age: int\n' \ f' status: bool\n' \ f' def __init__(self):\n' \ f' pass\n' \ f'' module, inferer = cs._parse_text(program) for node in module.nodes_of_class(astroid.AnnAssign): variable_type = lookup_type(inferer, node, node.target.name) annotated_type = _node_to_type(node.annotation.name) assert variable_type == annotated_type @given(hs.dictionaries(cs.valid_identifier(), cs.builtin_type, min_size=2)) @settings(suppress_health_check=[HealthCheck.too_slow]) def test_annassign(variables_annotations_dict): """Test whether types are being properly set for an AnnAssign node. """ program = f'class Student:\n' for variable in variables_annotations_dict: program += f' {variable}: {variables_annotations_dict[variable].__name__}\n' program += f' def __init__(self):\n' \ f' pass\n' module, inferer = cs._parse_text(program) for node in module.nodes_of_class(astroid.AnnAssign): variable_type = lookup_type(inferer, node, node.target.name) annotated_type = variables_annotations_dict[node.target.name] assert variable_type == annotated_type
settings.load_profile("pyta") def _parse_to_function(function_name, args_list, return_statement): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):' \ f' return {return_statement}' def _parse_to_function_no_return(function_name, args_list, function_body): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):\n' \ f' {function_body}' @given(cs.valid_identifier(), hs.lists(cs.valid_identifier(), min_size=1)) @settings(suppress_health_check=[HealthCheck.too_slow]) def test_inference_args_simple_return(function_name, arguments): """Test whether visitor was able to infer type of argument given function called on it in function body.""" assume(function_name not in arguments) for argument in arguments: program = _parse_to_function_no_return( function_name, arguments, ('return ' + argument + " + " + repr('bob'))) module, inferer = cs._parse_text(program) # get the functionDef node - there is only one in this test case. function_def_node = next(module.nodes_of_class(astroid.FunctionDef)) expected_arg_type_vars = [ function_def_node.type_environment.lookup_in_env(argument) for argument in arguments ]
""" program = f'class Student:\n' \ f' name: str\n' \ f' age: int\n' \ f' status: bool\n' \ f' def __init__(self):\n' \ f' pass\n' \ f'' module, inferer = cs._parse_text(program) for node in module.nodes_of_class(astroid.AnnAssign): variable_type = lookup_type(inferer, node, node.target.name) annotated_type = _node_to_type(node.annotation.name) assert variable_type == annotated_type @given(hs.dictionaries(cs.valid_identifier(), cs.builtin_type, min_size=2)) @settings(suppress_health_check=[HealthCheck.too_slow]) def test_annassign(variables_annotations_dict): """Test whether types are being properly set for an AnnAssign node. """ program = f'class Student:\n' for variable in variables_annotations_dict: program += f' {variable}: {variables_annotations_dict[variable].__name__}\n' program += f' def __init__(self):\n' \ f' pass\n' module, inferer = cs._parse_text(program) for node in module.nodes_of_class(astroid.AnnAssign): variable_type = lookup_type(inferer, node, node.target.name) annotated_type = variables_annotations_dict[node.target.name] if isinstance(variable_type, _GenericAlias): assert _gorg(variable_type) == annotated_type
for variable_name in variables_dict: assume(not iskeyword(variable_name)) program = ("x = [" + ", ".join([repr(value) for value in variables_dict.values()]) + "]\n" + ", ".join(variables_dict.keys()) + " = x") module, typeinferrer = cs._parse_text(program) ass_node = list(module.nodes_of_class(astroid.Assign))[0] for variable_name in variables_dict: var_tvar = module.type_environment.lookup_in_env(variable_name) assert typeinferrer.type_constraints.lookup_concrete(var_tvar) == ass_node.value.elts[0].type_constraints.type @nottest @given(hs.lists(cs.valid_identifier(), min_size=2), cs.random_list(min_size=2)) def test_assign_complex(variables, values): """Test whether visitors properly set the type constraint of the a Assign node representing a multi-target-assign with a homogeneous list as the value. """ assume(type(values[0]) != type(values[1]) and len(variables) == len(values)) val_types = [type(val) for val in values] if int in val_types: assume(bool not in val_types) if bool in val_types: assume(int not in val_types) program = ("x = [" + ", ".join([repr(val) for val in values]) + "]\n" + ", ".join(variables) + " = x")
""" for variable_name in variables_dict: assume(not iskeyword(variable_name)) program = ("x = [" + ", ".join([repr(value) for value in variables_dict.values()]) + "]\n" + ", ".join(variables_dict.keys()) + " = x") module, typeinferrer = cs._parse_text(program) ass_node = list(module.nodes_of_class(astroid.Assign))[0] for variable_name in variables_dict: var_tvar = module.type_environment.lookup_in_env(variable_name) assert typeinferrer.type_constraints.lookup_concrete(var_tvar) == ass_node.value.elts[0].type_constraints.type @given(hs.lists(cs.valid_identifier(), min_size=2), cs.random_list(min_size=2)) def test_assign_complex(variables, values): """Test whether visitors properly set the type constraint of the a Assign node representing a multi-target-assign with a homogeneous list as the value. """ assume(type(values[0]) != type(values[1]) and len(variables) == len(values)) val_types = [type(val) for val in values] if int in val_types: assume(bool not in val_types) if bool in val_types: assume(int not in val_types) program = ("x = [" + ", ".join([repr(val) for val in values]) + "]\n" + ", ".join(variables) + " = x")
settings.load_profile("pyta") def _parse_to_function(function_name, args_list, return_statement): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):' \ f' return {return_statement}' def _parse_to_function_no_return(function_name, args_list, function_body): """Helper to parse given data into function definition.""" return f'def {function_name}({", ".join(args_list)}):\n' \ f' {function_body}' @given(cs.valid_identifier(), cs.primitive_values) @settings(suppress_health_check=[HealthCheck.too_slow]) def test_function_def_no_args(function_name, return_value): """Test FunctionDef node visitors representing function definitions with no parameters and primitive return type.""" assume(not iskeyword(function_name)) program = _parse_to_function(function_name, [], repr(return_value)) module, inferer = cs._parse_text(program) function_type_var = module.type_environment.lookup_in_env(function_name) function_def_node = list(module.nodes_of_class(astroid.FunctionDef))[0] return_tvar = function_def_node.type_environment.lookup_in_env('return') return_type = inferer.type_constraints.resolve(return_tvar).getValue() assert inferer.type_constraints.resolve( function_type_var).getValue() == Callable[[], return_type] @given(cs.valid_identifier(), cs.primitive_values)