"""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..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]) # substitute a nested GenericAlias (both typing and the builtin # version) C5 = Callable[[typing.List[T], tuple[K, T], V], int] self.assertEqual(C5[int, str, float], Callable[[typing.List[int], tuple[str, int], float], int]) 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]") with self.subTest("Testing TypeErrors"): with self.assertRaisesRegex(TypeError, "variables left in"): alias[int] P = typing.ParamSpec('P') C1 = Callable[P, T] with self.assertRaisesRegex(TypeError, "many arguments for"): C1[int, str, str] with self.assertRaisesRegex(TypeError, "few arguments for"): C1[int] if __name__ == "__main__": unittest.main()