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