%PDF-
%PDF-
Mini Shell
Mini Shell
"""Test cases for type inference helper functions."""
from typing import List, Optional, Tuple, Union, Dict, Set
from mypy.test.helpers import Suite, assert_equal
from mypy.argmap import map_actuals_to_formals
from mypy.checker import group_comparison_operands, DisjointDict
from mypy.literals import Key
from mypy.nodes import ArgKind, ARG_POS, ARG_OPT, ARG_STAR, ARG_STAR2, ARG_NAMED, NameExpr
from mypy.types import AnyType, TupleType, Type, TypeOfAny
from mypy.test.typefixture import TypeFixture
class MapActualsToFormalsSuite(Suite):
"""Test cases for argmap.map_actuals_to_formals."""
def test_basic(self) -> None:
self.assert_map([], [], [])
def test_positional_only(self) -> None:
self.assert_map([ARG_POS],
[ARG_POS],
[[0]])
self.assert_map([ARG_POS, ARG_POS],
[ARG_POS, ARG_POS],
[[0], [1]])
def test_optional(self) -> None:
self.assert_map([],
[ARG_OPT],
[[]])
self.assert_map([ARG_POS],
[ARG_OPT],
[[0]])
self.assert_map([ARG_POS],
[ARG_OPT, ARG_OPT],
[[0], []])
def test_callee_star(self) -> None:
self.assert_map([],
[ARG_STAR],
[[]])
self.assert_map([ARG_POS],
[ARG_STAR],
[[0]])
self.assert_map([ARG_POS, ARG_POS],
[ARG_STAR],
[[0, 1]])
def test_caller_star(self) -> None:
self.assert_map([ARG_STAR],
[ARG_STAR],
[[0]])
self.assert_map([ARG_POS, ARG_STAR],
[ARG_STAR],
[[0, 1]])
self.assert_map([ARG_STAR],
[ARG_POS, ARG_STAR],
[[0], [0]])
self.assert_map([ARG_STAR],
[ARG_OPT, ARG_STAR],
[[0], [0]])
def test_too_many_caller_args(self) -> None:
self.assert_map([ARG_POS],
[],
[])
self.assert_map([ARG_STAR],
[],
[])
self.assert_map([ARG_STAR],
[ARG_POS],
[[0]])
def test_tuple_star(self) -> None:
any_type = AnyType(TypeOfAny.special_form)
self.assert_vararg_map(
[ARG_STAR],
[ARG_POS],
[[0]],
self.tuple(any_type))
self.assert_vararg_map(
[ARG_STAR],
[ARG_POS, ARG_POS],
[[0], [0]],
self.tuple(any_type, any_type))
self.assert_vararg_map(
[ARG_STAR],
[ARG_POS, ARG_OPT, ARG_OPT],
[[0], [0], []],
self.tuple(any_type, any_type))
def tuple(self, *args: Type) -> TupleType:
return TupleType(list(args), TypeFixture().std_tuple)
def test_named_args(self) -> None:
self.assert_map(
['x'],
[(ARG_POS, 'x')],
[[0]])
self.assert_map(
['y', 'x'],
[(ARG_POS, 'x'), (ARG_POS, 'y')],
[[1], [0]])
def test_some_named_args(self) -> None:
self.assert_map(
['y'],
[(ARG_OPT, 'x'), (ARG_OPT, 'y'), (ARG_OPT, 'z')],
[[], [0], []])
def test_missing_named_arg(self) -> None:
self.assert_map(
['y'],
[(ARG_OPT, 'x')],
[[]])
def test_duplicate_named_arg(self) -> None:
self.assert_map(
['x', 'x'],
[(ARG_OPT, 'x')],
[[0, 1]])
def test_varargs_and_bare_asterisk(self) -> None:
self.assert_map(
[ARG_STAR],
[ARG_STAR, (ARG_NAMED, 'x')],
[[0], []])
self.assert_map(
[ARG_STAR, 'x'],
[ARG_STAR, (ARG_NAMED, 'x')],
[[0], [1]])
def test_keyword_varargs(self) -> None:
self.assert_map(
['x'],
[ARG_STAR2],
[[0]])
self.assert_map(
['x', ARG_STAR2],
[ARG_STAR2],
[[0, 1]])
self.assert_map(
['x', ARG_STAR2],
[(ARG_POS, 'x'), ARG_STAR2],
[[0], [1]])
self.assert_map(
[ARG_POS, ARG_STAR2],
[(ARG_POS, 'x'), ARG_STAR2],
[[0], [1]])
def test_both_kinds_of_varargs(self) -> None:
self.assert_map(
[ARG_STAR, ARG_STAR2],
[(ARG_POS, 'x'), (ARG_POS, 'y')],
[[0, 1], [0, 1]])
def test_special_cases(self) -> None:
self.assert_map([ARG_STAR],
[ARG_STAR, ARG_STAR2],
[[0], []])
self.assert_map([ARG_STAR, ARG_STAR2],
[ARG_STAR, ARG_STAR2],
[[0], [1]])
self.assert_map([ARG_STAR2],
[(ARG_POS, 'x'), ARG_STAR2],
[[0], [0]])
self.assert_map([ARG_STAR2],
[ARG_STAR2],
[[0]])
def assert_map(self,
caller_kinds_: List[Union[ArgKind, str]],
callee_kinds_: List[Union[ArgKind, Tuple[ArgKind, str]]],
expected: List[List[int]],
) -> None:
caller_kinds, caller_names = expand_caller_kinds(caller_kinds_)
callee_kinds, callee_names = expand_callee_kinds(callee_kinds_)
result = map_actuals_to_formals(
caller_kinds,
caller_names,
callee_kinds,
callee_names,
lambda i: AnyType(TypeOfAny.special_form))
assert_equal(result, expected)
def assert_vararg_map(self,
caller_kinds: List[ArgKind],
callee_kinds: List[ArgKind],
expected: List[List[int]],
vararg_type: Type,
) -> None:
result = map_actuals_to_formals(
caller_kinds,
[],
callee_kinds,
[],
lambda i: vararg_type)
assert_equal(result, expected)
def expand_caller_kinds(kinds_or_names: List[Union[ArgKind, str]]
) -> Tuple[List[ArgKind], List[Optional[str]]]:
kinds = []
names: List[Optional[str]] = []
for k in kinds_or_names:
if isinstance(k, str):
kinds.append(ARG_NAMED)
names.append(k)
else:
kinds.append(k)
names.append(None)
return kinds, names
def expand_callee_kinds(kinds_and_names: List[Union[ArgKind, Tuple[ArgKind, str]]]
) -> Tuple[List[ArgKind], List[Optional[str]]]:
kinds = []
names: List[Optional[str]] = []
for v in kinds_and_names:
if isinstance(v, tuple):
kinds.append(v[0])
names.append(v[1])
else:
kinds.append(v)
names.append(None)
return kinds, names
class OperandDisjointDictSuite(Suite):
"""Test cases for checker.DisjointDict, which is used for type inference with operands."""
def new(self) -> DisjointDict[int, str]:
return DisjointDict()
def test_independent_maps(self) -> None:
d = self.new()
d.add_mapping({0, 1}, {"group1"})
d.add_mapping({2, 3, 4}, {"group2"})
d.add_mapping({5, 6, 7}, {"group3"})
self.assertEqual(d.items(), [
({0, 1}, {"group1"}),
({2, 3, 4}, {"group2"}),
({5, 6, 7}, {"group3"}),
])
def test_partial_merging(self) -> None:
d = self.new()
d.add_mapping({0, 1}, {"group1"})
d.add_mapping({1, 2}, {"group2"})
d.add_mapping({3, 4}, {"group3"})
d.add_mapping({5, 0}, {"group4"})
d.add_mapping({5, 6}, {"group5"})
d.add_mapping({4, 7}, {"group6"})
self.assertEqual(d.items(), [
({0, 1, 2, 5, 6}, {"group1", "group2", "group4", "group5"}),
({3, 4, 7}, {"group3", "group6"}),
])
def test_full_merging(self) -> None:
d = self.new()
d.add_mapping({0, 1, 2}, {"a"})
d.add_mapping({3, 4, 2}, {"b"})
d.add_mapping({10, 11, 12}, {"c"})
d.add_mapping({13, 14, 15}, {"d"})
d.add_mapping({14, 10, 16}, {"e"})
d.add_mapping({0, 10}, {"f"})
self.assertEqual(d.items(), [
({0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 15, 16}, {"a", "b", "c", "d", "e", "f"}),
])
def test_merge_with_multiple_overlaps(self) -> None:
d = self.new()
d.add_mapping({0, 1, 2}, {"a"})
d.add_mapping({3, 4, 5}, {"b"})
d.add_mapping({1, 2, 4, 5}, {"c"})
d.add_mapping({6, 1, 2, 4, 5}, {"d"})
d.add_mapping({6, 1, 2, 4, 5}, {"e"})
self.assertEqual(d.items(), [
({0, 1, 2, 3, 4, 5, 6}, {"a", "b", "c", "d", "e"}),
])
class OperandComparisonGroupingSuite(Suite):
"""Test cases for checker.group_comparison_operands."""
def literal_keymap(self, assignable_operands: Dict[int, NameExpr]) -> Dict[int, Key]:
output: Dict[int, Key] = {}
for index, expr in assignable_operands.items():
output[index] = ('FakeExpr', expr.name)
return output
def test_basic_cases(self) -> None:
# Note: the grouping function doesn't actually inspect the input exprs, so we
# just default to using NameExprs for simplicity.
x0 = NameExpr('x0')
x1 = NameExpr('x1')
x2 = NameExpr('x2')
x3 = NameExpr('x3')
x4 = NameExpr('x4')
basic_input = [('==', x0, x1), ('==', x1, x2), ('<', x2, x3), ('==', x3, x4)]
none_assignable = self.literal_keymap({})
all_assignable = self.literal_keymap({0: x0, 1: x1, 2: x2, 3: x3, 4: x4})
for assignable in [none_assignable, all_assignable]:
self.assertEqual(
group_comparison_operands(basic_input, assignable, set()),
[('==', [0, 1]), ('==', [1, 2]), ('<', [2, 3]), ('==', [3, 4])],
)
self.assertEqual(
group_comparison_operands(basic_input, assignable, {'=='}),
[('==', [0, 1, 2]), ('<', [2, 3]), ('==', [3, 4])],
)
self.assertEqual(
group_comparison_operands(basic_input, assignable, {'<'}),
[('==', [0, 1]), ('==', [1, 2]), ('<', [2, 3]), ('==', [3, 4])],
)
self.assertEqual(
group_comparison_operands(basic_input, assignable, {'==', '<'}),
[('==', [0, 1, 2]), ('<', [2, 3]), ('==', [3, 4])],
)
def test_multiple_groups(self) -> None:
x0 = NameExpr('x0')
x1 = NameExpr('x1')
x2 = NameExpr('x2')
x3 = NameExpr('x3')
x4 = NameExpr('x4')
x5 = NameExpr('x5')
self.assertEqual(
group_comparison_operands(
[('==', x0, x1), ('==', x1, x2), ('is', x2, x3), ('is', x3, x4)],
self.literal_keymap({}),
{'==', 'is'},
),
[('==', [0, 1, 2]), ('is', [2, 3, 4])],
)
self.assertEqual(
group_comparison_operands(
[('==', x0, x1), ('==', x1, x2), ('==', x2, x3), ('==', x3, x4)],
self.literal_keymap({}),
{'==', 'is'},
),
[('==', [0, 1, 2, 3, 4])],
)
self.assertEqual(
group_comparison_operands(
[('is', x0, x1), ('==', x1, x2), ('==', x2, x3), ('==', x3, x4)],
self.literal_keymap({}),
{'==', 'is'},
),
[('is', [0, 1]), ('==', [1, 2, 3, 4])],
)
self.assertEqual(
group_comparison_operands(
[('is', x0, x1), ('is', x1, x2), ('<', x2, x3), ('==', x3, x4), ('==', x4, x5)],
self.literal_keymap({}),
{'==', 'is'},
),
[('is', [0, 1, 2]), ('<', [2, 3]), ('==', [3, 4, 5])],
)
def test_multiple_groups_coalescing(self) -> None:
x0 = NameExpr('x0')
x1 = NameExpr('x1')
x2 = NameExpr('x2')
x3 = NameExpr('x3')
x4 = NameExpr('x4')
nothing_combined = [('==', [0, 1, 2]), ('<', [2, 3]), ('==', [3, 4, 5])]
everything_combined = [('==', [0, 1, 2, 3, 4, 5]), ('<', [2, 3])]
# Note: We do 'x4 == x0' at the very end!
two_groups = [
('==', x0, x1), ('==', x1, x2), ('<', x2, x3), ('==', x3, x4), ('==', x4, x0),
]
self.assertEqual(
group_comparison_operands(
two_groups,
self.literal_keymap({0: x0, 1: x1, 2: x2, 3: x3, 4: x4, 5: x0}),
{'=='},
),
everything_combined,
"All vars are assignable, everything is combined"
)
self.assertEqual(
group_comparison_operands(
two_groups,
self.literal_keymap({1: x1, 2: x2, 3: x3, 4: x4}),
{'=='},
),
nothing_combined,
"x0 is unassignable, so no combining"
)
self.assertEqual(
group_comparison_operands(
two_groups,
self.literal_keymap({0: x0, 1: x1, 3: x3, 5: x0}),
{'=='},
),
everything_combined,
"Some vars are unassignable but x0 is, so we combine"
)
self.assertEqual(
group_comparison_operands(
two_groups,
self.literal_keymap({0: x0, 5: x0}),
{'=='},
),
everything_combined,
"All vars are unassignable but x0 is, so we combine"
)
def test_multiple_groups_different_operators(self) -> None:
x0 = NameExpr('x0')
x1 = NameExpr('x1')
x2 = NameExpr('x2')
x3 = NameExpr('x3')
groups = [('==', x0, x1), ('==', x1, x2), ('is', x2, x3), ('is', x3, x0)]
keymap = self.literal_keymap({0: x0, 1: x1, 2: x2, 3: x3, 4: x0})
self.assertEqual(
group_comparison_operands(groups, keymap, {'==', 'is'}),
[('==', [0, 1, 2]), ('is', [2, 3, 4])],
"Different operators can never be combined"
)
def test_single_pair(self) -> None:
x0 = NameExpr('x0')
x1 = NameExpr('x1')
single_comparison = [('==', x0, x1)]
expected_output = [('==', [0, 1])]
assignable_combinations: List[Dict[int, NameExpr]] = [
{}, {0: x0}, {1: x1}, {0: x0, 1: x1},
]
to_group_by: List[Set[str]] = [set(), {"=="}, {"is"}]
for combo in assignable_combinations:
for operators in to_group_by:
keymap = self.literal_keymap(combo)
self.assertEqual(
group_comparison_operands(single_comparison, keymap, operators),
expected_output,
)
def test_empty_pair_list(self) -> None:
# This case should never occur in practice -- ComparisionExprs
# always contain at least one comparison. But in case it does...
self.assertEqual(group_comparison_operands([], {}, set()), [])
self.assertEqual(group_comparison_operands([], {}, {'=='}), [])
Zerion Mini Shell 1.0