Пример #1
0
    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()
Пример #2
0
    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()
Пример #3
0
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])
Пример #4
0
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
Пример #5
0
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"
Пример #6
0
    """
    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
        ]
Пример #8
0
    """
    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
Пример #9
0
    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")
Пример #10
0
    """
    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")
Пример #11
0
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)