Debian Codegraph @

Lib/test/test_genericalias.py

raw
1 """Tests for C-implemented GenericAlias."""
2
3 import unittest
4 import pickle
5 from array import array
6 import copy
7 from collections import (
8 defaultdict, deque, OrderedDict, Counter, UserDict, UserList
9 )
10 from collections.abc import *
11 from concurrent.futures import Future
12 from concurrent.futures.thread import _WorkItem
13 from contextlib import AbstractContextManager, AbstractAsyncContextManager
14 from contextvars import ContextVar, Token
15 from csv import DictReader, DictWriter
16 from dataclasses import Field
17 from functools import partial, partialmethod, cached_property
18 from graphlib import TopologicalSorter
19 from logging import LoggerAdapter, StreamHandler
20 from mailbox import Mailbox, _PartialFile
21 try:
22 import ctypes
23 except ImportError:
24 ctypes = None
25 from difflib import SequenceMatcher
26 from filecmp import dircmp
27 from fileinput import FileInput
28 from itertools import chain
29 from http.cookies import Morsel
30 try:
31 from multiprocessing.managers import ValueProxy, DictProxy, ListProxy
32 from multiprocessing.pool import ApplyResult
33 from multiprocessing.queues import SimpleQueue as MPSimpleQueue
34 from multiprocessing.queues import Queue as MPQueue
35 from multiprocessing.queues import JoinableQueue as MPJoinableQueue
36 except ImportError:
37 # _multiprocessing module is optional
38 ValueProxy = None
39 DictProxy = None
40 ListProxy = None
41 ApplyResult = None
42 MPSimpleQueue = None
43 MPQueue = None
44 MPJoinableQueue = None
45 try:
46 from multiprocessing.shared_memory import ShareableList
47 except ImportError:
48 # multiprocessing.shared_memory is not available on e.g. Android
49 ShareableList = None
50 from os import DirEntry
51 from re import Pattern, Match
52 from types import GenericAlias, MappingProxyType, AsyncGeneratorType, CoroutineType, GeneratorType
53 from tempfile import TemporaryDirectory, SpooledTemporaryFile
54 from urllib.parse import SplitResult, ParseResult
55 from unittest.case import _AssertRaisesContext
56 from queue import Queue, SimpleQueue
57 from weakref import WeakSet, ReferenceType, ref
58 try:
59 from tkinter import Event
60 except ImportError:
61 Event = None
62 from string.templatelib import Template, Interpolation
63
64 import typing
65 from typing import TypeVar, Unpack
66 T = TypeVar('T')
67 K = TypeVar('K')
68 V = TypeVar('V')
69
70 _UNPACKED_TUPLES = [
71 # Unpacked tuple using `*`
72 (*tuple[int],)[0],
73 (*tuple[T],)[0],
74 (*tuple[int, str],)[0],
75 (*tuple[int, ...],)[0],
76 (*tuple[T, ...],)[0],
77 tuple[*tuple[int, ...]],
78 tuple[*tuple[T, ...]],
79 tuple[str, *tuple[int, ...]],
80 tuple[*tuple[int, ...], str],
81 tuple[float, *tuple[int, ...], str],
82 tuple[*tuple[*tuple[int, ...]]],
83 # Unpacked tuple using `Unpack`
84 Unpack[tuple[int]],
85 Unpack[tuple[T]],
86 Unpack[tuple[int, str]],
87 Unpack[tuple[int, ...]],
88 Unpack[tuple[T, ...]],
89 tuple[Unpack[tuple[int, ...]]],
90 tuple[Unpack[tuple[T, ...]]],
91 tuple[str, Unpack[tuple[int, ...]]],
92 tuple[Unpack[tuple[int, ...]], str],
93 tuple[float, Unpack[tuple[int, ...]], str],
94 tuple[Unpack[tuple[Unpack[tuple[int, ...]]]]],
95 # Unpacked tuple using `*` AND `Unpack`
96 tuple[Unpack[tuple[*tuple[int, ...]]]],
97 tuple[*tuple[Unpack[tuple[int, ...]]]],
98 ]
99
100
101 class BaseTest(unittest.TestCase):
102 """Test basics."""
103 generic_types = [type, tuple, list, dict, set, frozenset, enumerate, memoryview,
104 defaultdict, deque,
105 SequenceMatcher,
106 dircmp,
107 FileInput,
108 OrderedDict, Counter, UserDict, UserList,
109 Pattern, Match,
110 partial, partialmethod, cached_property,
111 TopologicalSorter,
112 AbstractContextManager, AbstractAsyncContextManager,
113 Awaitable, Coroutine,
114 AsyncIterable, AsyncIterator,
115 AsyncGenerator, Generator,
116 Iterable, Iterator,
117 Reversible,
118 Container, Collection,
119 Mailbox, _PartialFile,
120 ContextVar, Token,
121 Field,
122 Set, MutableSet,
123 Mapping, MutableMapping, MappingView,
124 KeysView, ItemsView, ValuesView,
125 Sequence, MutableSequence,
126 MappingProxyType, AsyncGeneratorType,
127 GeneratorType, CoroutineType,
128 DirEntry,
129 chain,
130 LoggerAdapter, StreamHandler,
131 TemporaryDirectory, SpooledTemporaryFile,
132 Queue, SimpleQueue,
133 _AssertRaisesContext,
134 SplitResult, ParseResult,
135 WeakSet, ReferenceType, ref,
136 ShareableList,
137 Future, _WorkItem,
138 Morsel,
139 DictReader, DictWriter,
140 array,
141 staticmethod,
142 classmethod,
143 Template,
144 Interpolation,
145 ]
146 if ctypes is not None:
147 generic_types.extend((ctypes.Array, ctypes.LibraryLoader, ctypes.py_object))
148 if ValueProxy is not None:
149 generic_types.extend((ValueProxy, DictProxy, ListProxy, ApplyResult,
150 MPSimpleQueue, MPQueue, MPJoinableQueue))
151 if Event is not None:
152 generic_types.append(Event)
153
154 def test_subscriptable(self):
155 for t in self.generic_types:
156 if t is None:
157 continue
158 tname = t.__name__
159 with self.subTest(f"Testing {tname}"):
160 alias = t[int]
161 self.assertIs(alias.__origin__, t)
162 self.assertEqual(alias.__args__, (int,))
163 self.assertEqual(alias.__parameters__, ())
164
165 def test_unsubscriptable(self):
166 for t in int, str, float, Sized, Hashable:
167 tname = t.__name__
168 with self.subTest(f"Testing {tname}"):
169 with self.assertRaisesRegex(TypeError, tname):
170 t[int]
171
172 def test_instantiate(self):
173 for t in tuple, list, dict, set, frozenset, defaultdict, deque:
174 tname = t.__name__
175 with self.subTest(f"Testing {tname}"):
176 alias = t[int]
177 self.assertEqual(alias(), t())
178 if t is dict:
179 self.assertEqual(alias(iter([('a', 1), ('b', 2)])), dict(a=1, b=2))
180 self.assertEqual(alias(a=1, b=2), dict(a=1, b=2))
181 elif t is defaultdict:
182 def default():
183 return 'value'
184 a = alias(default)
185 d = defaultdict(default)
186 self.assertEqual(a['test'], d['test'])
187 else:
188 self.assertEqual(alias(iter((1, 2, 3))), t((1, 2, 3)))
189
190 def test_unbound_methods(self):
191 t = list[int]
192 a = t()
193 t.append(a, 'foo')
194 self.assertEqual(a, ['foo'])
195 x = t.__getitem__(a, 0)
196 self.assertEqual(x, 'foo')
197 self.assertEqual(t.__len__(a), 1)
198
199 def test_subclassing(self):
200 class C(list[int]):
201 pass
202 self.assertEqual(C.__bases__, (list,))
203 self.assertEqual(C.__class__, type)
204
205 def test_class_methods(self):
206 t = dict[int, None]
207 self.assertEqual(dict.fromkeys(range(2)), {0: None, 1: None}) # This works
208 self.assertEqual(t.fromkeys(range(2)), {0: None, 1: None}) # Should be equivalent
209
210 def test_no_chaining(self):
211 t = list[int]
212 with self.assertRaises(TypeError):
213 t[int]
214
215 def test_generic_subclass(self):
216 class MyList(list):
217 pass
218 t = MyList[int]
219 self.assertIs(t.__origin__, MyList)
220 self.assertEqual(t.__args__, (int,))
221 self.assertEqual(t.__parameters__, ())
222
223 def test_repr(self):
224 class MyList(list):
225 pass
226 class MyGeneric:
227 __class_getitem__ = classmethod(GenericAlias)
228
229 self.assertEqual(repr(list[str]), 'list[str]')
230 self.assertEqual(repr(list[()]), 'list[()]')
231 self.assertEqual(repr(tuple[int, ...]), 'tuple[int, ...]')
232 x1 = tuple[*tuple[int]]
233 self.assertEqual(repr(x1), 'tuple[*tuple[int]]')
234 x2 = tuple[*tuple[int, str]]
235 self.assertEqual(repr(x2), 'tuple[*tuple[int, str]]')
236 x3 = tuple[*tuple[int, ...]]
237 self.assertEqual(repr(x3), 'tuple[*tuple[int, ...]]')
238 self.assertEndsWith(repr(MyList[int]), '.BaseTest.test_repr.<locals>.MyList[int]')
239 self.assertEqual(repr(list[str]()), '[]') # instances should keep their normal repr
240
241 # gh-105488
242 self.assertEndsWith(repr(MyGeneric[int]), 'MyGeneric[int]')
243 self.assertEndsWith(repr(MyGeneric[[]]), 'MyGeneric[[]]')
244 self.assertEndsWith(repr(MyGeneric[[int, str]]), 'MyGeneric[[int, str]]')
245
246 def test_evil_repr1(self):
247 # gh-143635
248 class Zap:
249 def __init__(self, container):
250 self.container = container
251 def __getattr__(self, name):
252 if name == "__origin__":
253 self.container.clear()
254 return None
255 if name == "__args__":
256 return ()
257 raise AttributeError
258
259 params = []
260 params.append(Zap(params))
261 alias = GenericAlias(list, (params,))
262 repr_str = repr(alias)
263 self.assertTrue(repr_str.startswith("list[["), repr_str)
264
265 def test_evil_repr2(self):
266 class Zap:
267 def __init__(self, container):
268 self.container = container
269 def __getattr__(self, name):
270 if name == "__qualname__":
271 self.container.clear()
272 return "abcd"
273 if name == "__module__":
274 return None
275 raise AttributeError
276
277 params = []
278 params.append(Zap(params))
279 alias = GenericAlias(list, (params,))
280 repr_str = repr(alias)
281 self.assertTrue(repr_str.startswith("list[["), repr_str)
282
283 def test_evil_repr3(self):
284 # gh-143823
285 lst = []
286 class X:
287 def __repr__(self):
288 lst.clear()
289 return "x"
290
291 lst += [X(), 1]
292 ga = GenericAlias(int, lst)
293 with self.assertRaises(IndexError):
294 repr(ga)
295
296 def test_exposed_type(self):
297 import types
298 a = types.GenericAlias(list, int)
299 self.assertEqual(str(a), 'list[int]')
300 self.assertIs(a.__origin__, list)
301 self.assertEqual(a.__args__, (int,))
302 self.assertEqual(a.__parameters__, ())
303
304 def test_parameters(self):
305 from typing import List, Dict, Callable
306
307 D0 = dict[str, int]
308 self.assertEqual(D0.__args__, (str, int))
309 self.assertEqual(D0.__parameters__, ())
310 D1a = dict[str, V]
311 self.assertEqual(D1a.__args__, (str, V))
312 self.assertEqual(D1a.__parameters__, (V,))
313 D1b = dict[K, int]
314 self.assertEqual(D1b.__args__, (K, int))
315 self.assertEqual(D1b.__parameters__, (K,))
316 D2a = dict[K, V]
317 self.assertEqual(D2a.__args__, (K, V))
318 self.assertEqual(D2a.__parameters__, (K, V))
319 D2b = dict[T, T]
320 self.assertEqual(D2b.__args__, (T, T))
321 self.assertEqual(D2b.__parameters__, (T,))
322
323 L0 = list[str]
324 self.assertEqual(L0.__args__, (str,))
325 self.assertEqual(L0.__parameters__, ())
326 L1 = list[T]
327 self.assertEqual(L1.__args__, (T,))
328 self.assertEqual(L1.__parameters__, (T,))
329 L2 = list[list[T]]
330 self.assertEqual(L2.__args__, (list[T],))
331 self.assertEqual(L2.__parameters__, (T,))
332 L3 = list[List[T]]
333 self.assertEqual(L3.__args__, (List[T],))
334 self.assertEqual(L3.__parameters__, (T,))
335 L4a = list[Dict[K, V]]
336 self.assertEqual(L4a.__args__, (Dict[K, V],))
337 self.assertEqual(L4a.__parameters__, (K, V))
338 L4b = list[Dict[T, int]]
339 self.assertEqual(L4b.__args__, (Dict[T, int],))
340 self.assertEqual(L4b.__parameters__, (T,))
341 L5 = list[Callable[[K, V], K]]
342 self.assertEqual(L5.__args__, (Callable[[K, V], K],))
343 self.assertEqual(L5.__parameters__, (K, V))
344
345 T1 = tuple[*tuple[int]]
346 self.assertEqual(
347 T1.__args__,
348 (*tuple[int],),
349 )
350 self.assertEqual(T1.__parameters__, ())
351
352 T2 = tuple[*tuple[T]]
353 self.assertEqual(
354 T2.__args__,
355 (*tuple[T],),
356 )
357 self.assertEqual(T2.__parameters__, (T,))
358
359 T4 = tuple[*tuple[int, str]]
360 self.assertEqual(
361 T4.__args__,
362 (*tuple[int, str],),
363 )
364 self.assertEqual(T4.__parameters__, ())
365
366 def test_parameter_chaining(self):
367 from typing import List, Dict, Union, Callable
368 self.assertEqual(list[T][int], list[int])
369 self.assertEqual(dict[str, T][int], dict[str, int])
370 self.assertEqual(dict[T, int][str], dict[str, int])
371 self.assertEqual(dict[K, V][str, int], dict[str, int])
372 self.assertEqual(dict[T, T][int], dict[int, int])
373
374 self.assertEqual(list[list[T]][int], list[list[int]])
375 self.assertEqual(list[dict[T, int]][str], list[dict[str, int]])
376 self.assertEqual(list[dict[str, T]][int], list[dict[str, int]])
377 self.assertEqual(list[dict[K, V]][str, int], list[dict[str, int]])
378 self.assertEqual(dict[T, list[int]][str], dict[str, list[int]])
379
380 self.assertEqual(list[List[T]][int], list[List[int]])
381 self.assertEqual(list[Dict[K, V]][str, int], list[Dict[str, int]])
382 self.assertEqual(list[Union[K, V]][str, int], list[Union[str, int]])
383 self.assertEqual(list[Callable[[K, V], K]][str, int],
384 list[Callable[[str, int], str]])
385 self.assertEqual(dict[T, List[int]][str], dict[str, List[int]])
386
387 with self.assertRaises(TypeError):
388 list[int][int]
389 with self.assertRaises(TypeError):
390 dict[T, int][str, int]
391 with self.assertRaises(TypeError):
392 dict[str, T][str, int]
393 with self.assertRaises(TypeError):
394 dict[T, T][str, int]
395
396 def test_equality(self):
397 self.assertEqual(list[int], list[int])
398 self.assertEqual(dict[str, int], dict[str, int])
399 self.assertEqual((*tuple[int],)[0], (*tuple[int],)[0])
400 self.assertEqual(tuple[*tuple[int]], tuple[*tuple[int]])
401 self.assertNotEqual(dict[str, int], dict[str, str])
402 self.assertNotEqual(list, list[int])
403 self.assertNotEqual(list[int], list)
404 self.assertNotEqual(list[int], tuple[int])
405 self.assertNotEqual((*tuple[int],)[0], tuple[int])
406
407 def test_isinstance(self):
408 self.assertTrue(isinstance([], list))
409 with self.assertRaises(TypeError):
410 isinstance([], list[str])
411
412 def test_issubclass(self):
413 class L(list): ...
414 self.assertIsSubclass(L, list)
415 with self.assertRaises(TypeError):
416 issubclass(L, list[str])
417
418 def test_type_generic(self):
419 t = type[int]
420 Test = t('Test', (), {})
421 self.assertTrue(isinstance(Test, type))
422 test = Test()
423 self.assertEqual(t(test), Test)
424 self.assertEqual(t(0), int)
425
426 def test_type_subclass_generic(self):
427 class MyType(type):
428 pass
429 with self.assertRaisesRegex(TypeError, 'MyType'):
430 MyType[int]
431
432 def test_pickle(self):
433 aliases = [GenericAlias(list, T)] + _UNPACKED_TUPLES
434 for alias in aliases:
435 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
436 with self.subTest(alias=alias, proto=proto):
437 s = pickle.dumps(alias, proto)
438 loaded = pickle.loads(s)
439 self.assertEqual(loaded.__origin__, alias.__origin__)
440 self.assertEqual(loaded.__args__, alias.__args__)
441 self.assertEqual(loaded.__parameters__, alias.__parameters__)
442 self.assertEqual(type(loaded), type(alias))
443
444 def test_copy(self):
445 class X(list):
446 def __copy__(self):
447 return self
448 def __deepcopy__(self, memo):
449 return self
450
451 aliases = [
452 GenericAlias(list, T),
453 GenericAlias(deque, T),
454 GenericAlias(X, T),
455 X[T],
456 list[T],
457 deque[T],
458 ] + _UNPACKED_TUPLES
459 for alias in aliases:
460 with self.subTest(alias=alias):
461 copied = copy.copy(alias)
462 self.assertEqual(copied.__origin__, alias.__origin__)
463 self.assertEqual(copied.__args__, alias.__args__)
464 self.assertEqual(copied.__parameters__, alias.__parameters__)
465 copied = copy.deepcopy(alias)
466 self.assertEqual(copied.__origin__, alias.__origin__)
467 self.assertEqual(copied.__args__, alias.__args__)
468 self.assertEqual(copied.__parameters__, alias.__parameters__)
469
470 def test_unpack(self):
471 alias = tuple[str, ...]
472 self.assertIs(alias.__unpacked__, False)
473 unpacked = (*alias,)[0]
474 self.assertIs(unpacked.__unpacked__, True)
475
476 def test_union(self):
477 a = typing.Union[list[int], list[str]]
478 self.assertEqual(a.__args__, (list[int], list[str]))
479 self.assertEqual(a.__parameters__, ())
480
481 def test_union_generic(self):
482 a = typing.Union[list[T], tuple[T, ...]]
483 self.assertEqual(a.__args__, (list[T], tuple[T, ...]))
484 self.assertEqual(a.__parameters__, (T,))
485
486 def test_dir(self):
487 ga = list[int]
488 dir_of_gen_alias = set(dir(ga))
489 self.assertTrue(dir_of_gen_alias.issuperset(dir(list)))
490 for generic_alias_property in (
491 "__origin__", "__args__", "__parameters__",
492 "__unpacked__",
493 ):
494 with self.subTest(generic_alias_property=generic_alias_property):
495 self.assertIn(generic_alias_property, dir_of_gen_alias)
496 for blocked in (
497 "__bases__",
498 "__copy__",
499 "__deepcopy__",
500 ):
501 with self.subTest(blocked=blocked):
502 self.assertNotIn(blocked, dir_of_gen_alias)
503
504 for entry in dir_of_gen_alias:
505 with self.subTest(entry=entry):
506 getattr(ga, entry) # must not raise `AttributeError`
507
508 def test_weakref(self):
509 for t in self.generic_types:
510 if t is None:
511 continue
512 tname = t.__name__
513 with self.subTest(f"Testing {tname}"):
514 alias = t[int]
515 self.assertEqual(ref(alias)(), alias)
516
517 def test_no_kwargs(self):
518 # bpo-42576
519 with self.assertRaises(TypeError):
520 GenericAlias(bad=float)
521
522 def test_subclassing_types_genericalias(self):
523 class SubClass(GenericAlias): ...
524 alias = SubClass(list, int)
525 class Bad(GenericAlias):
526 def __new__(cls, *args, **kwargs):
527 super().__new__(cls, *args, **kwargs)
528
529 self.assertEqual(alias, list[int])
530 with self.assertRaises(TypeError):
531 Bad(list, int, bad=int)
532
533 def test_iter_creates_starred_tuple(self):
534 t = tuple[int, str]
535 iter_t = iter(t)
536 x = next(iter_t)
537 self.assertEqual(repr(x), '*tuple[int, str]')
538
539 def test_calling_next_twice_raises_stopiteration(self):
540 t = tuple[int, str]
541 iter_t = iter(t)
542 next(iter_t)
543 with self.assertRaises(StopIteration):
544 next(iter_t)
545
546 def test_del_iter(self):
547 t = tuple[int, str]
548 iter_x = iter(t)
549 del iter_x
550
551 def test_paramspec_specialization(self):
552 # gh-124445
553 T = TypeVar("T")
554 U = TypeVar("U")
555 type X[**P] = Callable[P, int]
556
557 generic = X[[T]]
558 self.assertEqual(generic.__args__, ([T],))
559 self.assertEqual(generic.__parameters__, (T,))
560 specialized = generic[str]
561 self.assertEqual(specialized.__args__, ([str],))
562 self.assertEqual(specialized.__parameters__, ())
563
564 generic = X[(T,)]
565 self.assertEqual(generic.__args__, (T,))
566 self.assertEqual(generic.__parameters__, (T,))
567 specialized = generic[str]
568 self.assertEqual(specialized.__args__, (str,))
569 self.assertEqual(specialized.__parameters__, ())
570
571 generic = X[[T, U]]
572 self.assertEqual(generic.__args__, ([T, U],))
573 self.assertEqual(generic.__parameters__, (T, U))
574 specialized = generic[str, int]
575 self.assertEqual(specialized.__args__, ([str, int],))
576 self.assertEqual(specialized.__parameters__, ())
577
578 generic = X[(T, U)]
579 self.assertEqual(generic.__args__, (T, U))
580 self.assertEqual(generic.__parameters__, (T, U))
581 specialized = generic[str, int]
582 self.assertEqual(specialized.__args__, (str, int))
583 self.assertEqual(specialized.__parameters__, ())
584
585 def test_nested_paramspec_specialization(self):
586 # gh-124445
587 type X[**P, T] = Callable[P, T]
588
589 x_list = X[[int, str], float]
590 self.assertEqual(x_list.__args__, ([int, str], float))
591 self.assertEqual(x_list.__parameters__, ())
592
593 x_tuple = X[(int, str), float]
594 self.assertEqual(x_tuple.__args__, ((int, str), float))
595 self.assertEqual(x_tuple.__parameters__, ())
596
597 U = TypeVar("U")
598 V = TypeVar("V")
599
600 multiple_params_list = X[[int, U], V]
601 self.assertEqual(multiple_params_list.__args__, ([int, U], V))
602 self.assertEqual(multiple_params_list.__parameters__, (U, V))
603 multiple_params_list_specialized = multiple_params_list[str, float]
604 self.assertEqual(multiple_params_list_specialized.__args__, ([int, str], float))
605 self.assertEqual(multiple_params_list_specialized.__parameters__, ())
606
607 multiple_params_tuple = X[(int, U), V]
608 self.assertEqual(multiple_params_tuple.__args__, ((int, U), V))
609 self.assertEqual(multiple_params_tuple.__parameters__, (U, V))
610 multiple_params_tuple_specialized = multiple_params_tuple[str, float]
611 self.assertEqual(multiple_params_tuple_specialized.__args__, ((int, str), float))
612 self.assertEqual(multiple_params_tuple_specialized.__parameters__, ())
613
614 deeply_nested = X[[U, [V], int], V]
615 self.assertEqual(deeply_nested.__args__, ([U, [V], int], V))
616 self.assertEqual(deeply_nested.__parameters__, (U, V))
617 deeply_nested_specialized = deeply_nested[str, float]
618 self.assertEqual(deeply_nested_specialized.__args__, ([str, [float], int], float))
619 self.assertEqual(deeply_nested_specialized.__parameters__, ())
620
621 def test_gh150146(self):
622 # It used to crash:
623 for container in [memoryview, list, tuple]:
624 with self.subTest(container=container):
625 x = container[TypeVar("")]
626 with self.assertRaises(TypeError):
627 x[*typing.Mapping[..., ...]]
628
629
630 class TypeIterationTests(unittest.TestCase):
631 _UNITERABLE_TYPES = (list, tuple)
632
633 def test_cannot_iterate(self):
634 for test_type in self._UNITERABLE_TYPES:
635 with self.subTest(type=test_type):
636 expected_error_regex = "object is not iterable"
637 with self.assertRaisesRegex(TypeError, expected_error_regex):
638 iter(test_type)
639 with self.assertRaisesRegex(TypeError, expected_error_regex):
640 list(test_type)
641 with self.assertRaisesRegex(TypeError, expected_error_regex):
642 for _ in test_type:
643 pass
644
645 def test_is_not_instance_of_iterable(self):
646 for type_to_test in self._UNITERABLE_TYPES:
647 self.assertNotIsInstance(type_to_test, Iterable)
648
649
650 if __name__ == "__main__":
651 unittest.main()