def test_mixed_truth_restricted_type_simple(self) -> None: # join_simple against differently restricted truthiness types drops restrictions. true_a = true_only(self.fx.a) false_o = false_only(self.fx.o) j = join_simple(self.fx.o, true_a, false_o) assert_true(j.can_be_true) assert_true(j.can_be_false)
def test_mixed_truth_restricted_type(self) -> None: # join_types against differently restricted truthiness types drops restrictions. true_any = true_only(AnyType(TypeOfAny.special_form)) false_o = false_only(self.fx.o) j = join_types(true_any, false_o) assert_true(j.can_be_true) assert_true(j.can_be_false)
def test_true_only_of_instance(self) -> None: to = true_only(self.fx.a) assert_equal(str(to), "A") assert_true(to.can_be_true) assert_false(to.can_be_false) assert_type(Instance, to) # The original class still can be false assert_true(self.fx.a.can_be_false)
def test_is_proper_subtype_invariance(self) -> None: fx = self.fx assert_true(is_proper_subtype(fx.gsab, fx.gb)) assert_false(is_proper_subtype(fx.gsab, fx.ga)) assert_false(is_proper_subtype(fx.gsaa, fx.gb)) assert_false(is_proper_subtype(fx.gb, fx.ga)) assert_false(is_proper_subtype(fx.ga, fx.gb))
def test_false_only_of_instance(self) -> None: fo = false_only(self.fx.a) assert_equal(str(fo), "A") assert_false(fo.can_be_true) assert_true(fo.can_be_false) assert_type(Instance, fo) # The original class still can be true assert_true(self.fx.a.can_be_true)
def assert_simple_meet(self, s: Type, t: Type, meet: Type) -> None: result = meet_types(s, t) actual = str(result) expected = str(meet) assert_equal(actual, expected, 'meet({}, {}) == {{}} ({{}} expected)'.format(s, t)) assert_true(is_subtype(result, s), '{} not subtype of {}'.format(result, s)) assert_true(is_subtype(result, t), '{} not subtype of {}'.format(result, t))
def assert_simple_join(self, s: Type, t: Type, join: Type) -> None: result = join_types(s, t) actual = str(result) expected = str(join) assert_equal(actual, expected, 'join({}, {}) == {{}} ({{}} expected)'.format(s, t)) assert_true(is_subtype(s, result), '{} not subtype of {}'.format(s, result)) assert_true(is_subtype(t, result), '{} not subtype of {}'.format(t, result))
def test_true_only_of_union(self) -> None: tup_type = self.tuple(AnyType(TypeOfAny.special_form)) # Union of something that is unknown, something that is always true, something # that is always false union_type = UnionType([self.fx.a, tup_type, self.tuple()]) to = true_only(union_type) assert isinstance(to, UnionType) assert_equal(len(to.items), 2) assert_true(to.items[0].can_be_true) assert_false(to.items[0].can_be_false) assert_true(to.items[1] is tup_type)
def test_simple_type_objects(self) -> None: t1 = self.type_callable(self.fx.a, self.fx.a) t2 = self.type_callable(self.fx.b, self.fx.b) tr = self.type_callable(self.fx.b, self.fx.a) self.assert_join(t1, t1, t1) j = join_types(t1, t1) assert isinstance(j, CallableType) assert_true(j.is_type_obj()) self.assert_join(t1, t2, tr) self.assert_join(t1, self.fx.type_type, self.fx.type_type) self.assert_join(self.fx.type_type, self.fx.type_type, self.fx.type_type)
def test_is_in_module_collection(self) -> None: assert_true(moduleinfo.is_in_module_collection({'foo'}, 'foo')) assert_true(moduleinfo.is_in_module_collection({'foo'}, 'foo.bar')) assert_false(moduleinfo.is_in_module_collection({'foo'}, 'fo')) assert_true(moduleinfo.is_in_module_collection({'foo.bar'}, 'foo.bar')) assert_true(moduleinfo.is_in_module_collection({'foo.bar'}, 'foo.bar.zar')) assert_false(moduleinfo.is_in_module_collection({'foo.bar'}, 'foo'))
def test_false_only_of_union(self) -> None: with strict_optional_set(True): tup_type = self.tuple() # Union of something that is unknown, something that is always true, something # that is always false union_type = UnionType([self.fx.a, self.tuple(AnyType(TypeOfAny.special_form)), tup_type]) assert_equal(len(union_type.items), 3) fo = false_only(union_type) assert isinstance(fo, UnionType) assert_equal(len(fo.items), 2) assert_false(fo.items[0].can_be_true) assert_true(fo.items[0].can_be_false) assert_true(fo.items[1] is tup_type)
def test_is_in_module_collection(self) -> None: assert_true(moduleinfo.is_in_module_collection({'foo'}, 'foo')) assert_true(moduleinfo.is_in_module_collection({'foo'}, 'foo.bar')) assert_false(moduleinfo.is_in_module_collection({'foo'}, 'fo')) assert_true(moduleinfo.is_in_module_collection({'foo.bar'}, 'foo.bar')) assert_true( moduleinfo.is_in_module_collection({'foo.bar'}, 'foo.bar.zar')) assert_false(moduleinfo.is_in_module_collection({'foo.bar'}, 'foo'))
def test_literal_type(self) -> None: a = self.fx.a d = self.fx.d lit1 = LiteralType(1, a) lit2 = LiteralType(2, a) lit3 = LiteralType("foo", d) self.assert_meet(lit1, lit1, lit1) self.assert_meet(lit1, a, lit1) self.assert_meet_uninhabited(lit1, lit3) self.assert_meet_uninhabited(lit1, lit2) self.assert_meet(UnionType([lit1, lit2]), lit1, lit1) self.assert_meet(UnionType([lit1, lit2]), UnionType([lit2, lit3]), lit2) self.assert_meet(UnionType([lit1, lit2]), UnionType([lit1, lit2]), UnionType([lit1, lit2])) self.assert_meet(lit1, self.fx.anyt, lit1) self.assert_meet(lit1, self.fx.o, lit1) assert_true(is_same_type(lit1, narrow_declared_type(lit1, a))) assert_true(is_same_type(lit2, narrow_declared_type(lit2, a)))
def test_literal_type(self) -> None: a = self.fx.a lit1 = self.fx.lit1 lit2 = self.fx.lit2 lit3 = self.fx.lit3 self.assert_meet(lit1, lit1, lit1) self.assert_meet(lit1, a, lit1) self.assert_meet_uninhabited(lit1, lit3) self.assert_meet_uninhabited(lit1, lit2) self.assert_meet(UnionType([lit1, lit2]), lit1, lit1) self.assert_meet(UnionType([lit1, lit2]), UnionType([lit2, lit3]), lit2) self.assert_meet(UnionType([lit1, lit2]), UnionType([lit1, lit2]), UnionType([lit1, lit2])) self.assert_meet(lit1, self.fx.anyt, lit1) self.assert_meet(lit1, self.fx.o, lit1) assert_true(is_same_type(lit1, narrow_declared_type(lit1, a))) assert_true(is_same_type(lit2, narrow_declared_type(lit2, a)))
def test_is_proper_subtype_contravariance(self) -> None: fx_contra = self.fx_contra assert_true(is_proper_subtype(fx_contra.gsab, fx_contra.gb)) assert_false(is_proper_subtype(fx_contra.gsab, fx_contra.ga)) assert_true(is_proper_subtype(fx_contra.gsaa, fx_contra.gb)) assert_false(is_proper_subtype(fx_contra.gb, fx_contra.ga)) assert_true(is_proper_subtype(fx_contra.ga, fx_contra.gb))
def test_false_only_of_false_type_is_idempotent(self) -> None: always_false = NoneType() fo = false_only(always_false) assert_true(always_false is fo)
def test_true_only_of_true_type_is_idempotent(self) -> None: always_true = self.tuple(AnyType(TypeOfAny.special_form)) to = true_only(always_true) assert_true(always_true is to)
def test_is_proper_subtype(self) -> None: fx = self.fx assert_true(is_proper_subtype(fx.a, fx.a)) assert_true(is_proper_subtype(fx.b, fx.a)) assert_true(is_proper_subtype(fx.b, fx.o)) assert_true(is_proper_subtype(fx.b, fx.o)) assert_false(is_proper_subtype(fx.a, fx.b)) assert_false(is_proper_subtype(fx.o, fx.b)) assert_true(is_proper_subtype(fx.anyt, fx.anyt)) assert_false(is_proper_subtype(fx.a, fx.anyt)) assert_false(is_proper_subtype(fx.anyt, fx.a)) assert_true(is_proper_subtype(fx.ga, fx.ga)) assert_true(is_proper_subtype(fx.gdyn, fx.gdyn)) assert_false(is_proper_subtype(fx.ga, fx.gdyn)) assert_false(is_proper_subtype(fx.gdyn, fx.ga)) assert_true(is_proper_subtype(fx.t, fx.t)) assert_false(is_proper_subtype(fx.t, fx.s)) assert_true(is_proper_subtype(fx.a, UnionType([fx.a, fx.b]))) assert_true( is_proper_subtype(UnionType([fx.a, fx.b]), UnionType([fx.a, fx.b, fx.c]))) assert_false( is_proper_subtype(UnionType([fx.a, fx.b]), UnionType([fx.b, fx.c])))
def assert_not_subtype(self, s: Type, t: Type) -> None: assert_true(not is_subtype(s, t), '{} subtype of {}'.format(s, t))
def test_subtype_aliases(self) -> None: A1, _ = self.fx.def_alias_1(self.fx.a) AA1, _ = self.fx.def_alias_1(self.fx.a) assert_true(is_subtype(A1, AA1)) assert_true(is_subtype(AA1, A1)) A2, _ = self.fx.def_alias_2(self.fx.a) AA2, _ = self.fx.def_alias_2(self.fx.a) assert_true(is_subtype(A2, AA2)) assert_true(is_subtype(AA2, A2)) B1, _ = self.fx.def_alias_1(self.fx.b) B2, _ = self.fx.def_alias_2(self.fx.b) assert_true(is_subtype(B1, A1)) assert_true(is_subtype(B2, A2)) assert_false(is_subtype(A1, B1)) assert_false(is_subtype(A2, B2)) assert_false(is_subtype(A2, A1)) assert_true(is_subtype(A1, A2))
def test_nonempty_tuple_always_true(self) -> None: tuple_type = self.tuple(AnyType(TypeOfAny.special_form), AnyType(TypeOfAny.special_form)) assert_true(tuple_type.can_be_true) assert_false(tuple_type.can_be_false)
def test_is_proper_subtype_and_subtype_literal_types(self) -> None: fx = self.fx lit1 = LiteralType(1, fx.a) lit2 = LiteralType("foo", fx.d) lit3 = LiteralType("bar", fx.d) assert_true(is_proper_subtype(lit1, fx.a)) assert_false(is_proper_subtype(lit1, fx.d)) assert_false(is_proper_subtype(fx.a, lit1)) assert_true(is_proper_subtype(fx.uninhabited, lit1)) assert_false(is_proper_subtype(lit1, fx.uninhabited)) assert_true(is_proper_subtype(lit1, lit1)) assert_false(is_proper_subtype(lit1, lit2)) assert_false(is_proper_subtype(lit2, lit3)) assert_true(is_subtype(lit1, fx.a)) assert_false(is_subtype(lit1, fx.d)) assert_false(is_subtype(fx.a, lit1)) assert_true(is_subtype(fx.uninhabited, lit1)) assert_false(is_subtype(lit1, fx.uninhabited)) assert_true(is_subtype(lit1, lit1)) assert_false(is_subtype(lit1, lit2)) assert_false(is_subtype(lit2, lit3)) assert_false(is_proper_subtype(lit1, fx.anyt)) assert_false(is_proper_subtype(fx.anyt, lit1)) assert_true(is_subtype(lit1, fx.anyt)) assert_true(is_subtype(fx.anyt, lit1))
def test_is_more_precise(self) -> None: fx = self.fx assert_true(is_more_precise(fx.b, fx.a)) assert_true(is_more_precise(fx.b, fx.b)) assert_true(is_more_precise(fx.b, fx.b)) assert_true(is_more_precise(fx.b, fx.anyt)) assert_true(is_more_precise(self.tuple(fx.b, fx.a), self.tuple(fx.b, fx.a))) assert_true(is_more_precise(self.tuple(fx.b, fx.b), self.tuple(fx.b, fx.a))) assert_false(is_more_precise(fx.a, fx.b)) assert_false(is_more_precise(fx.anyt, fx.b))
def test_union_can_be_false_if_any_false(self) -> None: union_type = UnionType([self.fx.a, self.tuple()]) assert_true(union_type.can_be_false)
def test_empty_tuple_always_false(self) -> None: tuple_type = self.tuple() assert_true(tuple_type.can_be_false) assert_false(tuple_type.can_be_true)
def test_is_proper_subtype_and_subtype_literal_types(self) -> None: fx = self.fx lit1 = fx.lit1 lit2 = fx.lit2 lit3 = fx.lit3 assert_true(is_proper_subtype(lit1, fx.a)) assert_false(is_proper_subtype(lit1, fx.d)) assert_false(is_proper_subtype(fx.a, lit1)) assert_true(is_proper_subtype(fx.uninhabited, lit1)) assert_false(is_proper_subtype(lit1, fx.uninhabited)) assert_true(is_proper_subtype(lit1, lit1)) assert_false(is_proper_subtype(lit1, lit2)) assert_false(is_proper_subtype(lit2, lit3)) assert_true(is_subtype(lit1, fx.a)) assert_false(is_subtype(lit1, fx.d)) assert_false(is_subtype(fx.a, lit1)) assert_true(is_subtype(fx.uninhabited, lit1)) assert_false(is_subtype(lit1, fx.uninhabited)) assert_true(is_subtype(lit1, lit1)) assert_false(is_subtype(lit1, lit2)) assert_false(is_subtype(lit2, lit3)) assert_false(is_proper_subtype(lit1, fx.anyt)) assert_false(is_proper_subtype(fx.anyt, lit1)) assert_true(is_subtype(lit1, fx.anyt)) assert_true(is_subtype(fx.anyt, lit1))
def test_is_proper_subtype(self) -> None: fx = self.fx assert_true(is_proper_subtype(fx.a, fx.a)) assert_true(is_proper_subtype(fx.b, fx.a)) assert_true(is_proper_subtype(fx.b, fx.o)) assert_true(is_proper_subtype(fx.b, fx.o)) assert_false(is_proper_subtype(fx.a, fx.b)) assert_false(is_proper_subtype(fx.o, fx.b)) assert_true(is_proper_subtype(fx.anyt, fx.anyt)) assert_false(is_proper_subtype(fx.a, fx.anyt)) assert_false(is_proper_subtype(fx.anyt, fx.a)) assert_true(is_proper_subtype(fx.ga, fx.ga)) assert_true(is_proper_subtype(fx.gdyn, fx.gdyn)) assert_false(is_proper_subtype(fx.ga, fx.gdyn)) assert_false(is_proper_subtype(fx.gdyn, fx.ga)) assert_true(is_proper_subtype(fx.t, fx.t)) assert_false(is_proper_subtype(fx.t, fx.s)) assert_true(is_proper_subtype(fx.a, UnionType([fx.a, fx.b]))) assert_true(is_proper_subtype(UnionType([fx.a, fx.b]), UnionType([fx.a, fx.b, fx.c]))) assert_false(is_proper_subtype(UnionType([fx.a, fx.b]), UnionType([fx.b, fx.c])))
def test_is_more_precise(self) -> None: fx = self.fx assert_true(is_more_precise(fx.b, fx.a)) assert_true(is_more_precise(fx.b, fx.b)) assert_true(is_more_precise(fx.b, fx.b)) assert_true(is_more_precise(fx.b, fx.anyt)) assert_true( is_more_precise(self.tuple(fx.b, fx.a), self.tuple(fx.b, fx.a))) assert_true( is_more_precise(self.tuple(fx.b, fx.b), self.tuple(fx.b, fx.a))) assert_false(is_more_precise(fx.a, fx.b)) assert_false(is_more_precise(fx.anyt, fx.b))