| """Tests for C-implemented GenericAlias.""" |
| |
| import unittest |
| import pickle |
| from collections import ( |
| defaultdict, deque, OrderedDict, Counter, UserDict, UserList |
| ) |
| from collections.abc import * |
| from concurrent.futures import Future |
| from concurrent.futures.thread import _WorkItem |
| from contextlib import AbstractContextManager, AbstractAsyncContextManager |
| from contextvars import ContextVar, Token |
| from dataclasses import Field |
| from functools import partial, partialmethod, cached_property |
| from mailbox import Mailbox, _PartialFile |
| try: |
| import ctypes |
| except ImportError: |
| ctypes = None |
| from difflib import SequenceMatcher |
| from filecmp import dircmp |
| from fileinput import FileInput |
| from itertools import chain |
| from http.cookies import Morsel |
| from multiprocessing.managers import ValueProxy |
| from multiprocessing.pool import ApplyResult |
| try: |
| from multiprocessing.shared_memory import ShareableList |
| except ImportError: |
| # multiprocessing.shared_memory is not available on e.g. Android |
| ShareableList = None |
| from multiprocessing.queues import SimpleQueue as MPSimpleQueue |
| from os import DirEntry |
| from re import Pattern, Match |
| from types import GenericAlias, MappingProxyType, AsyncGeneratorType |
| from tempfile import TemporaryDirectory, SpooledTemporaryFile |
| from urllib.parse import SplitResult, ParseResult |
| from unittest.case import _AssertRaisesContext |
| from queue import Queue, SimpleQueue |
| from weakref import WeakSet, ReferenceType, ref |
| import typing |
| |
| from typing import TypeVar |
| T = TypeVar('T') |
| K = TypeVar('K') |
| V = TypeVar('V') |
| |
| class BaseTest(unittest.TestCase): |
| """Test basics.""" |
| generic_types = [type, tuple, list, dict, set, frozenset, enumerate, |
| defaultdict, deque, |
| SequenceMatcher, |
| dircmp, |
| FileInput, |
| OrderedDict, Counter, UserDict, UserList, |
| Pattern, Match, |
| partial, partialmethod, cached_property, |
| AbstractContextManager, AbstractAsyncContextManager, |
| Awaitable, Coroutine, |
| AsyncIterable, AsyncIterator, |
| AsyncGenerator, Generator, |
| Iterable, Iterator, |
| Reversible, |
| Container, Collection, |
| Mailbox, _PartialFile, |
| ContextVar, Token, |
| Field, |
| Set, MutableSet, |
| Mapping, MutableMapping, MappingView, |
| KeysView, ItemsView, ValuesView, |
| Sequence, MutableSequence, |
| MappingProxyType, AsyncGeneratorType, |
| DirEntry, |
| chain, |
| TemporaryDirectory, SpooledTemporaryFile, |
| Queue, SimpleQueue, |
| _AssertRaisesContext, |
| SplitResult, ParseResult, |
| ValueProxy, ApplyResult, |
| WeakSet, ReferenceType, ref, |
| ShareableList, MPSimpleQueue, |
| Future, _WorkItem, |
| Morsel] |
| if ctypes is not None: |
| generic_types.extend((ctypes.Array, ctypes.LibraryLoader)) |
| |
| def test_subscriptable(self): |
| for t in self.generic_types: |
| if t is None: |
| continue |
| tname = t.__name__ |
| with self.subTest(f"Testing {tname}"): |
| alias = t[int] |
| self.assertIs(alias.__origin__, t) |
| self.assertEqual(alias.__args__, (int,)) |
| self.assertEqual(alias.__parameters__, ()) |
| |
| def test_unsubscriptable(self): |
| for t in int, str, float, Sized, Hashable: |
| tname = t.__name__ |
| with self.subTest(f"Testing {tname}"): |
| with self.assertRaises(TypeError): |
| t[int] |
| |
| def test_instantiate(self): |
| for t in tuple, list, dict, set, frozenset, defaultdict, deque: |
| tname = t.__name__ |
| with self.subTest(f"Testing {tname}"): |
| alias = t[int] |
| self.assertEqual(alias(), t()) |
| if t is dict: |
| self.assertEqual(alias(iter([('a', 1), ('b', 2)])), dict(a=1, b=2)) |
| self.assertEqual(alias(a=1, b=2), dict(a=1, b=2)) |
| elif t is defaultdict: |
| def default(): |
| return 'value' |
| a = alias(default) |
| d = defaultdict(default) |
| self.assertEqual(a['test'], d['test']) |
| else: |
| self.assertEqual(alias(iter((1, 2, 3))), t((1, 2, 3))) |
| |
| def test_unbound_methods(self): |
| t = list[int] |
| a = t() |
| t.append(a, 'foo') |
| self.assertEqual(a, ['foo']) |
| x = t.__getitem__(a, 0) |
| self.assertEqual(x, 'foo') |
| self.assertEqual(t.__len__(a), 1) |
| |
| def test_subclassing(self): |
| class C(list[int]): |
| pass |
| self.assertEqual(C.__bases__, (list,)) |
| self.assertEqual(C.__class__, type) |
| |
| def test_class_methods(self): |
| t = dict[int, None] |
| self.assertEqual(dict.fromkeys(range(2)), {0: None, 1: None}) # This works |
| self.assertEqual(t.fromkeys(range(2)), {0: None, 1: None}) # Should be equivalent |
| |
| def test_no_chaining(self): |
| t = list[int] |
| with self.assertRaises(TypeError): |
| t[int] |
| |
| def test_generic_subclass(self): |
| class MyList(list): |
| pass |
| t = MyList[int] |
| self.assertIs(t.__origin__, MyList) |
| self.assertEqual(t.__args__, (int,)) |
| self.assertEqual(t.__parameters__, ()) |
| |
| def test_repr(self): |
| class MyList(list): |
| pass |
| self.assertEqual(repr(list[str]), 'list[str]') |
| self.assertEqual(repr(list[()]), 'list[()]') |
| self.assertEqual(repr(tuple[int, ...]), 'tuple[int, ...]') |
| self.assertTrue(repr(MyList[int]).endswith('.BaseTest.test_repr.<locals>.MyList[int]')) |
| self.assertEqual(repr(list[str]()), '[]') # instances should keep their normal repr |
| |
| def test_exposed_type(self): |
| import types |
| a = types.GenericAlias(list, int) |
| self.assertEqual(str(a), 'list[int]') |
| self.assertIs(a.__origin__, list) |
| self.assertEqual(a.__args__, (int,)) |
| self.assertEqual(a.__parameters__, ()) |
| |
| def test_parameters(self): |
| from typing import List, Dict, Callable |
| D0 = dict[str, int] |
| self.assertEqual(D0.__args__, (str, int)) |
| self.assertEqual(D0.__parameters__, ()) |
| D1a = dict[str, V] |
| self.assertEqual(D1a.__args__, (str, V)) |
| self.assertEqual(D1a.__parameters__, (V,)) |
| D1b = dict[K, int] |
| self.assertEqual(D1b.__args__, (K, int)) |
| self.assertEqual(D1b.__parameters__, (K,)) |
| D2a = dict[K, V] |
| self.assertEqual(D2a.__args__, (K, V)) |
| self.assertEqual(D2a.__parameters__, (K, V)) |
| D2b = dict[T, T] |
| self.assertEqual(D2b.__args__, (T, T)) |
| self.assertEqual(D2b.__parameters__, (T,)) |
| L0 = list[str] |
| self.assertEqual(L0.__args__, (str,)) |
| self.assertEqual(L0.__parameters__, ()) |
| L1 = list[T] |
| self.assertEqual(L1.__args__, (T,)) |
| self.assertEqual(L1.__parameters__, (T,)) |
| L2 = list[list[T]] |
| self.assertEqual(L2.__args__, (list[T],)) |
| self.assertEqual(L2.__parameters__, (T,)) |
| L3 = list[List[T]] |
| self.assertEqual(L3.__args__, (List[T],)) |
| self.assertEqual(L3.__parameters__, (T,)) |
| L4a = list[Dict[K, V]] |
| self.assertEqual(L4a.__args__, (Dict[K, V],)) |
| self.assertEqual(L4a.__parameters__, (K, V)) |
| L4b = list[Dict[T, int]] |
| self.assertEqual(L4b.__args__, (Dict[T, int],)) |
| self.assertEqual(L4b.__parameters__, (T,)) |
| L5 = list[Callable[[K, V], K]] |
| self.assertEqual(L5.__args__, (Callable[[K, V], K],)) |
| self.assertEqual(L5.__parameters__, (K, V)) |
| |
| def test_parameter_chaining(self): |
| from typing import List, Dict, Union, Callable |
| self.assertEqual(list[T][int], list[int]) |
| self.assertEqual(dict[str, T][int], dict[str, int]) |
| self.assertEqual(dict[T, int][str], dict[str, int]) |
| self.assertEqual(dict[K, V][str, int], dict[str, int]) |
| self.assertEqual(dict[T, T][int], dict[int, int]) |
| |
| self.assertEqual(list[list[T]][int], list[list[int]]) |
| self.assertEqual(list[dict[T, int]][str], list[dict[str, int]]) |
| self.assertEqual(list[dict[str, T]][int], list[dict[str, int]]) |
| self.assertEqual(list[dict[K, V]][str, int], list[dict[str, int]]) |
| self.assertEqual(dict[T, list[int]][str], dict[str, list[int]]) |
| |
| self.assertEqual(list[List[T]][int], list[List[int]]) |
| self.assertEqual(list[Dict[K, V]][str, int], list[Dict[str, int]]) |
| self.assertEqual(list[Union[K, V]][str, int], list[Union[str, int]]) |
| self.assertEqual(list[Callable[[K, V], K]][str, int], |
| list[Callable[[str, int], str]]) |
| self.assertEqual(dict[T, List[int]][str], dict[str, List[int]]) |
| |
| with self.assertRaises(TypeError): |
| list[int][int] |
| dict[T, int][str, int] |
| dict[str, T][str, int] |
| dict[T, T][str, int] |
| |
| def test_equality(self): |
| self.assertEqual(list[int], list[int]) |
| self.assertEqual(dict[str, int], dict[str, int]) |
| self.assertNotEqual(dict[str, int], dict[str, str]) |
| self.assertNotEqual(list, list[int]) |
| self.assertNotEqual(list[int], list) |
| |
| def test_isinstance(self): |
| self.assertTrue(isinstance([], list)) |
| with self.assertRaises(TypeError): |
| isinstance([], list[str]) |
| |
| def test_issubclass(self): |
| class L(list): ... |
| self.assertTrue(issubclass(L, list)) |
| with self.assertRaises(TypeError): |
| issubclass(L, list[str]) |
| |
| def test_type_generic(self): |
| t = type[int] |
| Test = t('Test', (), {}) |
| self.assertTrue(isinstance(Test, type)) |
| test = Test() |
| self.assertEqual(t(test), Test) |
| self.assertEqual(t(0), int) |
| |
| def test_type_subclass_generic(self): |
| class MyType(type): |
| pass |
| with self.assertRaises(TypeError): |
| MyType[int] |
| |
| def test_pickle(self): |
| alias = GenericAlias(list, T) |
| s = pickle.dumps(alias) |
| loaded = pickle.loads(s) |
| self.assertEqual(alias.__origin__, loaded.__origin__) |
| self.assertEqual(alias.__args__, loaded.__args__) |
| self.assertEqual(alias.__parameters__, loaded.__parameters__) |
| |
| def test_union(self): |
| a = typing.Union[list[int], list[str]] |
| self.assertEqual(a.__args__, (list[int], list[str])) |
| self.assertEqual(a.__parameters__, ()) |
| |
| def test_union_generic(self): |
| a = typing.Union[list[T], tuple[T, ...]] |
| self.assertEqual(a.__args__, (list[T], tuple[T, ...])) |
| self.assertEqual(a.__parameters__, (T,)) |
| |
| def test_dir(self): |
| dir_of_gen_alias = set(dir(list[int])) |
| self.assertTrue(dir_of_gen_alias.issuperset(dir(list))) |
| for generic_alias_property in ("__origin__", "__args__", "__parameters__"): |
| self.assertIn(generic_alias_property, dir_of_gen_alias) |
| |
| def test_weakref(self): |
| for t in self.generic_types: |
| if t is None: |
| continue |
| tname = t.__name__ |
| with self.subTest(f"Testing {tname}"): |
| alias = t[int] |
| self.assertEqual(ref(alias)(), alias) |
| |
| def test_no_kwargs(self): |
| # bpo-42576 |
| with self.assertRaises(TypeError): |
| GenericAlias(bad=float) |
| |
| def test_subclassing_types_genericalias(self): |
| class SubClass(GenericAlias): ... |
| alias = SubClass(list, int) |
| class Bad(GenericAlias): |
| def __new__(cls, *args, **kwargs): |
| super().__new__(cls, *args, **kwargs) |
| |
| self.assertEqual(alias, list[int]) |
| with self.assertRaises(TypeError): |
| Bad(list, int, bad=int) |
| |
| def test_abc_callable(self): |
| # A separate test is needed for Callable since it uses a subclass of |
| # GenericAlias. |
| alias = Callable[[int, str], float] |
| with self.subTest("Testing subscription"): |
| self.assertIs(alias.__origin__, Callable) |
| self.assertEqual(alias.__args__, (int, str, float)) |
| self.assertEqual(alias.__parameters__, ()) |
| |
| with self.subTest("Testing instance checks"): |
| self.assertIsInstance(alias, GenericAlias) |
| |
| with self.subTest("Testing weakref"): |
| self.assertEqual(ref(alias)(), alias) |
| |
| with self.subTest("Testing pickling"): |
| s = pickle.dumps(alias) |
| loaded = pickle.loads(s) |
| self.assertEqual(alias.__origin__, loaded.__origin__) |
| self.assertEqual(alias.__args__, loaded.__args__) |
| self.assertEqual(alias.__parameters__, loaded.__parameters__) |
| |
| with self.subTest("Testing TypeVar substitution"): |
| C1 = Callable[[int, T], T] |
| C2 = Callable[[K, T], V] |
| C3 = Callable[..., T] |
| self.assertEqual(C1[str], Callable[[int, str], str]) |
| self.assertEqual(C2[int, float, str], Callable[[int, float], str]) |
| self.assertEqual(C3[int], Callable[..., int]) |
| |
| # multi chaining |
| C4 = C2[int, V, str] |
| self.assertEqual(repr(C4).split(".")[-1], "Callable[[int, ~V], str]") |
| self.assertEqual(repr(C4[dict]).split(".")[-1], "Callable[[int, dict], str]") |
| self.assertEqual(C4[dict], Callable[[int, dict], str]) |
| |
| with self.subTest("Testing type erasure"): |
| class C1(Callable): |
| def __call__(self): |
| return None |
| a = C1[[int], T] |
| self.assertIs(a().__class__, C1) |
| self.assertEqual(a().__orig_class__, C1[[int], T]) |
| |
| # bpo-42195 |
| with self.subTest("Testing collections.abc.Callable's consistency " |
| "with typing.Callable"): |
| c1 = typing.Callable[[int, str], dict] |
| c2 = Callable[[int, str], dict] |
| self.assertEqual(c1.__args__, c2.__args__) |
| self.assertEqual(hash(c1.__args__), hash(c2.__args__)) |
| |
| with self.subTest("Testing ParamSpec uses"): |
| P = typing.ParamSpec('P') |
| C1 = Callable[P, T] |
| # substitution |
| self.assertEqual(C1[int, str], Callable[[int], str]) |
| self.assertEqual(C1[[int, str], str], Callable[[int, str], str]) |
| self.assertEqual(repr(C1).split(".")[-1], "Callable[~P, ~T]") |
| self.assertEqual(repr(C1[int, str]).split(".")[-1], "Callable[[int], str]") |
| |
| C2 = Callable[P, int] |
| # special case in PEP 612 where |
| # X[int, str, float] == X[[int, str, float]] |
| self.assertEqual(C2[int, str, float], C2[[int, str, float]]) |
| self.assertEqual(repr(C2).split(".")[-1], "Callable[~P, int]") |
| self.assertEqual(repr(C2[int, str]).split(".")[-1], "Callable[[int, str], int]") |
| |
| with self.subTest("Testing Concatenate uses"): |
| P = typing.ParamSpec('P') |
| C1 = Callable[typing.Concatenate[int, P], int] |
| self.assertEqual(repr(C1), "collections.abc.Callable" |
| "[typing.Concatenate[int, ~P], int]") |
| |
| if __name__ == "__main__": |
| unittest.main() |