bernsteinbear.com
this repo has no description
1#!/usr/bin/env python3
2# Copyright (c) Facebook, Inc. and its affiliates. (http://www.facebook.com)
3import ast
4import builtins
5import contextlib
6import copy
7import errno
8import math
9import os
10import pickle
11import sys
12import types
13import typing
14import unittest
15import warnings
16from collections import namedtuple
17from types import SimpleNamespace
18from unittest.mock import Mock
19
20from test_support import cpython_only, pyro_only
21
22
23Py_TPFLAGS_HEAPTYPE = 1 << 9
24
25
26try:
27 from builtins import _number_check, instance_proxy, _non_heaptype
28
29 from _builtins import _async_generator_op_iter_get_state, _gc
30except ImportError:
31 pass
32
33
34class Example:
35 pass
36
37
38class Forward:
39 pass
40
41
42class Super:
43 pass
44
45
46class Child(Super):
47 pass
48
49
50class TupleSubclass(tuple):
51 pass
52
53
54class AbsTests(unittest.TestCase):
55 def test_abs_calls_dunder_abs(self):
56 class C:
57 __abs__ = Mock(name="__abs__", return_value=3)
58
59 abs(C())
60 C.__abs__.assert_called_once()
61
62 def test_abs_with_non_callable_dunder_abs_raises_type_error(self):
63 class C:
64 __abs__ = None
65
66 instance = C()
67 with self.assertRaisesRegex(TypeError, "'NoneType' object is not callable"):
68 abs(instance)
69
70 def test_abs_with_nan_returns_nan(self):
71 nan = float("nan")
72 result = abs(nan)
73 self.assertIsNot(result, nan)
74 self.assertNotEqual(result, nan)
75 self.assertTrue(math.isnan(result))
76
77
78class AsciiTests(unittest.TestCase):
79 def test_ascii_calls_dunder_repr(self):
80 class C:
81 def __repr__(self):
82 return "my repr"
83
84 def __str__(self):
85 raise Exception("should not be called")
86
87 self.assertEqual(ascii(C()), "my repr")
88
89 def test_ascii_returns_str(self):
90 self.assertEqual(ascii(42), "42")
91 self.assertEqual(ascii(""), "''")
92 self.assertEqual(ascii("hello"), "'hello'")
93 self.assertEqual(ascii("X\xac\u4213\U0001f40d!"), "'X\\xac\\u4213\\U0001f40d!'")
94
95
96class AsyncGeneratorTests(unittest.TestCase):
97 def test_dunder_aiter_with_non_async_generator_raises_type_error(self):
98 async def async_gen_func():
99 yield
100
101 with self.assertRaises(TypeError):
102 type(async_gen_func()).__aiter__(None)
103
104 def test_dunder_anext_with_non_async_generator_raises_type_error(self):
105 async def async_gen_func():
106 yield
107
108 with self.assertRaises(TypeError):
109 type(async_gen_func()).__anext__(None)
110
111 def test_dunder_del_with_non_async_generator_raises_type_error(self):
112 async def async_gen_func():
113 yield
114
115 with self.assertRaises(TypeError):
116 type(async_gen_func()).__del__(None)
117
118 def test_dunder_repr_with_non_async_generator_raises_type_error(self):
119 async def async_gen_func():
120 yield
121
122 with self.assertRaises(TypeError):
123 type(async_gen_func()).__repr__(None)
124
125 def test_aclose_with_non_async_generator_raises_type_error(self):
126 async def async_gen_func():
127 yield
128
129 with self.assertRaises(TypeError):
130 type(async_gen_func()).aclose(None)
131
132 def test_asend_with_non_async_generator_raises_type_error(self):
133 async def async_gen_func():
134 yield
135
136 with self.assertRaises(TypeError):
137 type(async_gen_func()).asend(None, None)
138
139 def test_athrow_with_non_async_generator_raises_type_error(self):
140 async def async_gen_func():
141 yield
142
143 with self.assertRaises(TypeError):
144 type(async_gen_func()).athrow(None, None, None, None)
145
146 def test_dunder_aiter_returns_self(self):
147 async def async_gen_func():
148 yield
149
150 async_gen = async_gen_func()
151
152 self.assertIs(async_gen.__aiter__(), async_gen)
153
154 def test_dunder_anext_returns_iterable_over_states_of_trivial_async_gen_func(self):
155 async def async_gen_func():
156 yield 1
157
158 with self.assertRaises(StopIteration) as exc:
159 next(iter(async_gen_func().__anext__()))
160 self.assertEqual(exc.exception.value, 1)
161
162 def test_dunder_anext_runs_firstiter_hook_exactly_once(self):
163 firstiter_ran = None
164
165 def firstiter_hook(async_gen_inst):
166 nonlocal firstiter_ran
167 firstiter_ran = async_gen_inst
168
169 sys.set_asyncgen_hooks(firstiter=firstiter_hook)
170
171 async def async_gen_func():
172 yield
173
174 async_gen = async_gen_func()
175 async_gen.__anext__()
176 self.assertIs(firstiter_ran, async_gen)
177
178 firstiter_ran = None
179 async_gen.__anext__()
180 self.assertIsNone(firstiter_ran)
181
182 def test_dunder_anext_sets_finalizer(self):
183 finalizer_ran = None
184
185 def finalizer_hook(async_gen_inst):
186 nonlocal finalizer_ran
187 finalizer_ran = async_gen_inst
188
189 sys.set_asyncgen_hooks(finalizer=finalizer_hook)
190
191 async def async_gen_func():
192 yield
193
194 async_gen = async_gen_func()
195 async_gen.__anext__()
196 async_gen.__del__()
197 self.assertIs(finalizer_ran, async_gen)
198
199 def test_dunder_repr(self):
200 async def async_gen_func():
201 yield
202
203 async_gen_obj = async_gen_func()
204
205 self.assertTrue(
206 async_gen_obj.__repr__().startswith(
207 "<async_generator object AsyncGeneratorTests.test_dunder_repr."
208 "<locals>.async_gen_func at "
209 )
210 )
211
212 def test_aclose_runs_firstiter_hook(self):
213 firstiter_ran = None
214
215 def firstiter_hook(async_gen_inst):
216 nonlocal firstiter_ran
217 firstiter_ran = async_gen_inst
218
219 sys.set_asyncgen_hooks(firstiter=firstiter_hook)
220
221 async def async_gen_func():
222 yield
223
224 async_gen = async_gen_func()
225 async_gen.aclose()
226 self.assertIs(firstiter_ran, async_gen)
227
228 def test_aclose_sets_finalizer(self):
229 finalizer_ran = None
230
231 def finalizer_hook(async_gen_inst):
232 nonlocal finalizer_ran
233 finalizer_ran = async_gen_inst
234
235 sys.set_asyncgen_hooks(finalizer=finalizer_hook)
236
237 async def async_gen_func():
238 yield
239
240 async_gen = async_gen_func()
241 async_gen.aclose()
242 async_gen.__del__()
243 self.assertIs(finalizer_ran, async_gen)
244
245 def test_aclose_raises_generator_exit_inside_generator(self):
246 saw_generator_exit = False
247
248 async def f():
249 nonlocal saw_generator_exit
250 try:
251 yield 1
252 except GeneratorExit:
253 saw_generator_exit = True
254
255 # Create async_generator for f()
256 async_gen = f()
257
258 # Advance generator to 'yield 1' to put us inside a try-except
259 # block from which we can catch aclose's GeneratorExit.
260 try:
261 async_gen.asend(None).send(None)
262 except StopIteration:
263 pass
264
265 try:
266 async_gen.aclose().send(None)
267 except StopIteration:
268 pass
269
270 self.assertTrue(saw_generator_exit)
271
272 def test_aclose_prevents_further_iteration(self):
273 async def f():
274 yield 1
275
276 # Create async_generator for f()
277 async_gen = f()
278
279 # Perform the aclose operation
280 with self.assertRaises(StopIteration) as exc:
281 async_gen.aclose().send(None)
282 # Note '1' is not yielded because we closed before execution begun
283 self.assertIsNone(exc.exception.value)
284
285 # Further attempts to send into the generator result in 'StopAsyncIteration'
286 # which means the iterator has no more results. Again '1' is never yielded.
287 with self.assertRaises(StopAsyncIteration):
288 async_gen.asend(None).send(None)
289
290 def test_asend_runs_firstiter_hook_exactly_once(self):
291 firstiter_ran = None
292
293 def firstiter_hook(async_gen_inst):
294 nonlocal firstiter_ran
295 firstiter_ran = async_gen_inst
296
297 sys.set_asyncgen_hooks(firstiter=firstiter_hook)
298
299 async def async_gen_func():
300 yield
301 yield
302
303 async_gen = async_gen_func()
304 async_gen.asend(None)
305 self.assertIs(firstiter_ran, async_gen)
306
307 firstiter_ran = None
308 async_gen.asend(None)
309 self.assertIs(firstiter_ran, None)
310
311 def test_asend_sets_finalizer(self):
312 finalizer_ran = None
313
314 def finalizer_hook(async_gen_inst):
315 nonlocal finalizer_ran
316 finalizer_ran = async_gen_inst
317
318 sys.set_asyncgen_hooks(finalizer=finalizer_hook)
319
320 async def async_gen_func():
321 yield
322
323 async_gen = async_gen_func()
324 async_gen.asend(None)
325 async_gen.__del__()
326 self.assertIs(finalizer_ran, async_gen)
327
328 def test_asend_returns_iterable_over_states_of_no_op_async_gen_func(self):
329 async def async_gen_func():
330 if False:
331 yield
332
333 async_gen_obj = async_gen_func()
334
335 # Call next() on no-op function advances us to the final state.
336 # StopAsyncIteration indicates there are no further results.
337 with self.assertRaises(StopAsyncIteration):
338 next(iter(async_gen_obj.asend(None)))
339
340 def test_asend_returns_iterables_over_states_of_yielding_async_gen_func(self):
341 async def async_gen_func():
342 yield 1
343
344 async_gen_obj = async_gen_func()
345
346 # Calling next advances us to the first state: yielding 1.
347 with self.assertRaises(StopIteration) as exc:
348 next(iter(async_gen_obj.asend(None)))
349 self.assertEqual(exc.exception.value, 1)
350
351 # Calling next now advances us to the final state.
352 # StopAsyncIteration indicates there are no further results.
353 with self.assertRaises(StopAsyncIteration):
354 next(iter(async_gen_obj.asend(None)))
355
356 def test_using_asend_to_inject_a_value_into_generator(self):
357 async def async_gen_func():
358 yield (yield)
359
360 async_gen_obj = async_gen_func()
361
362 # First next() call runs generator until the first yield.
363 with self.assertRaises(StopIteration) as exc:
364 next(async_gen_obj.asend(None))
365 self.assertIsNone(exc.exception.value)
366
367 # Send value into generator with a value to advance to the next
368 # stopping state which will yield the value we sent in.
369 with self.assertRaises(StopIteration) as exc:
370 next(async_gen_obj.asend(1))
371 self.assertEqual(exc.exception.value, 1)
372
373 def test_athrow_runs_firstiter_hook(self):
374 firstiter_ran = None
375
376 def firstiter_hook(async_gen_inst):
377 nonlocal firstiter_ran
378 firstiter_ran = async_gen_inst
379
380 sys.set_asyncgen_hooks(firstiter=firstiter_hook)
381
382 async def async_gen_func():
383 yield
384
385 async_gen = async_gen_func()
386 async_gen.athrow(None)
387 self.assertIs(firstiter_ran, async_gen)
388
389 def test_athrow_sets_finalizer(self):
390 finalizer_ran = None
391
392 def finalizer_hook(async_gen_inst):
393 nonlocal finalizer_ran
394 finalizer_ran = async_gen_inst
395
396 sys.set_asyncgen_hooks(finalizer=finalizer_hook)
397
398 async def async_gen_func():
399 yield
400
401 async_gen = async_gen_func()
402 async_gen.athrow(None)
403 async_gen.__del__()
404 self.assertIs(finalizer_ran, async_gen)
405
406 def test_athrow_raises_inside_generator(self):
407 async def f():
408 try:
409 yield 1
410 except ValueError:
411 yield 2
412
413 async_gen = f()
414
415 # Advance generator to 'yield 1' so we can catch the ValueError.
416 try:
417 async_gen.asend(None).send(None)
418 except StopIteration:
419 pass
420
421 with self.assertRaises(StopIteration) as exc:
422 async_gen.athrow(ValueError).send(None)
423 self.assertEqual(exc.exception.value, 2)
424
425 def test_athrow_uncaught_in_generator_propagates_out(self):
426 async def f():
427 yield 1
428
429 with self.assertRaises(ValueError) as exc:
430 f().athrow(ValueError, 1).send(None)
431 self.assertEqual(exc.exception.args, (1,))
432
433 def test_async_generator_is_an_asynchronous_iterable(self):
434 # Inline coments from PEP-492 definition of "asynchronous
435 # iterable":
436 # https://www.python.org/dev/peps/pep-0492/#asynchronous-iterators-and-async-for
437
438 async def async_gen_func():
439 yield
440
441 # 1. [An asynchronous iterable] must implement an __aiter__ method ...
442 async_gen_obj = async_gen_func()
443 self.assertTrue(hasattr(async_gen_obj, "__aiter__"))
444
445 # ... returning an asynchronous iterator object.
446 # 2. An asynchronous iterator object must implement an __anext__
447 # method ...
448 async_it_obj = async_gen_obj.__aiter__()
449 self.assertTrue(hasattr(async_it_obj, "__anext__"))
450
451 # ... returning an awaitable.
452 awaitable_obj = async_it_obj.__anext__()
453 self.assertTrue(hasattr(awaitable_obj, "__await__"))
454
455 # 3. To stop iteration __anext__ must raise a StopAsyncIteration
456 # exception.
457 iterable_obj = awaitable_obj.__await__()
458 with self.assertRaises(StopIteration) as exc:
459 next(iter(iterable_obj))
460 self.assertIsNone(exc.exception.value)
461 with self.assertRaises(StopAsyncIteration):
462 next(iter(async_gen_obj.__aiter__().__anext__().__await__()))
463
464 def test_async_generator_explicitly_throws_stop_async_iteration_raise_runtime_error(
465 self,
466 ):
467 async def f():
468 raise StopIteration
469 yield
470
471 with self.assertRaises(RuntimeError):
472 f().asend(None).send(None)
473
474
475class AsyncGeneratorAcloseTests(unittest.TestCase):
476 _STATE_MAP = {"_STATE_INIT": 0, "_STATE_ITER": 1, "_STATE_CLOSED": 2}
477
478 def _assertOpIterState(self, op_iter, state_str):
479 if sys.implementation.name == "skybison":
480 state = _async_generator_op_iter_get_state(op_iter)
481 self.assertEqual(state, AsyncGeneratorAcloseTests._STATE_MAP[state_str])
482
483 def test_dunder_await_with_non_async_generator_aclose_raises_type_error(self):
484 async def async_gen_func():
485 yield
486
487 with self.assertRaises(TypeError):
488 type(async_gen_func().aclose()).__await__(None)
489
490 def test_dunder_iter_with_non_async_generator_aclose_raises_type_error(self):
491 async def async_gen_func():
492 yield
493
494 with self.assertRaises(TypeError):
495 type(async_gen_func().aclose()).__iter__(None)
496
497 def test_dunder_next_with_non_async_generator_aclose_raises_type_error(self):
498 async def async_gen_func():
499 yield
500
501 with self.assertRaises(TypeError):
502 type(async_gen_func().aclose()).__next__(None)
503
504 def test_close_with_non_async_generator_aclose_raises_type_error(self):
505 async def async_gen_func():
506 yield
507
508 with self.assertRaises(TypeError):
509 type(async_gen_func().aclose()).close(None)
510
511 def test_send_with_non_async_generator_aclose_raises_type_error(self):
512 async def async_gen_func():
513 yield
514
515 with self.assertRaises(TypeError):
516 type(async_gen_func().aclose()).send(None, None)
517
518 def test_throw_with_non_async_generator_aclose_raises_type_error(self):
519 async def async_gen_func():
520 yield
521
522 with self.assertRaises(TypeError):
523 type(async_gen_func().aclose()).throw(None, None, None, None)
524
525 def test_dunder_await_returns_self(self):
526 async def f():
527 yield 1
528
529 op_iter = f().aclose()
530
531 self.assertIs(op_iter.__await__(), op_iter)
532
533 def test_dunder_iter_returns_self(self):
534 async def f():
535 yield
536
537 op_iter = f().aclose()
538
539 self.assertIs(op_iter.__iter__(), op_iter)
540
541 def test_is_awaitable(self):
542 async def f():
543 yield 1
544
545 op_iter = f().aclose()
546
547 async def awaiter(awaitable):
548 return await awaitable
549
550 try:
551 # This would raise TypeError if op_iter were not awaitable.
552 awaiter(op_iter).send(None)
553 except StopIteration:
554 pass
555
556 def test_is_iterable(self):
557 async def f():
558 yield 1
559
560 op_iter = f().aclose()
561
562 with self.assertRaises(StopIteration) as exc:
563 next(iter(op_iter))
564 self.assertIsNone(exc.exception.value)
565
566 @pyro_only
567 def test_new_instance_starts_in_init_state(self):
568 async def f():
569 yield 1
570
571 op_iter = f().aclose()
572
573 self._assertOpIterState(op_iter, "_STATE_INIT")
574
575 @pyro_only
576 def test_close_moves_into_closed_state(self):
577 async def f():
578 yield 1
579
580 # Make aclose op_iter
581 op_iter = f().aclose()
582
583 op_iter.close()
584 self._assertOpIterState(op_iter, "_STATE_CLOSED")
585
586 def test_send_state_closed_raises_stop_iteration_state_closed(self):
587 async def f():
588 yield 1
589
590 # Make aclose op_iter in closed state
591 op_iter = f().aclose()
592 op_iter.close()
593
594 with self.assertRaises(
595 RuntimeError, msg="cannot reuse already awaited aclose()/athrow()"
596 ):
597 op_iter.send(None)
598
599 self._assertOpIterState(op_iter, "_STATE_CLOSED")
600
601 def test_send_state_init_arg_is_not_none_raises_runtime_error_state_init(self):
602 async def f():
603 yield 1
604
605 # Make aclose op_iter
606 op_iter = f().aclose()
607
608 with self.assertRaises(RuntimeError):
609 op_iter.send(1)
610
611 self._assertOpIterState(op_iter, "_STATE_INIT")
612
613 def test_send_state_init_arg_is_none_generator_raises_stop_async_iteration_raises_stop_iteration_state_closed( # noqa: B950
614 self,
615 ):
616 async def f():
617 try:
618 yield 1
619 except GeneratorExit:
620 # Returning causes StopAsyncIteration to be raised
621 return
622
623 # Make an async_generator for f
624 async_gen = f()
625
626 # Advance generator into try-except block, pausing after 'yield 1'
627 try:
628 async_gen.asend(None).send(None)
629 except StopIteration:
630 pass
631
632 # Make aclose op_iter which is primted to run inside try-except block
633 op_iter = async_gen.aclose()
634
635 with self.assertRaises(StopIteration) as exc:
636 op_iter.send(None)
637 self.assertIsNone(exc.exception.value)
638
639 self._assertOpIterState(op_iter, "_STATE_CLOSED")
640
641 def test_send_state_init_arg_is_none_generator_raises_generator_exit_raises_stop_iteration_state_closed( # noqa: B950
642 self,
643 ):
644 async def f():
645 yield 1
646
647 # Make aclose op_iter
648 op_iter = f().aclose()
649
650 with self.assertRaises(StopIteration) as exc:
651 # The aclose operation implicitly raises GeneratorExit in the generator
652 op_iter.send(None)
653 self.assertIsNone(exc.exception.value)
654
655 self._assertOpIterState(op_iter, "_STATE_CLOSED")
656
657 def test_send_state_init_arg_is_none_generator_yields_raises_runtime_error_state_iter( # noqa: B950
658 self,
659 ):
660 async def f():
661 try:
662 yield 1
663 except GeneratorExit:
664 yield 2
665
666 # Make an async_generator for f
667 async_gen = f()
668
669 # Advance generator into try-except block, pausing after 'yield 1'
670 try:
671 async_gen.asend(None).send(None)
672 except StopIteration:
673 pass
674
675 # Make aclose op_iter which is primted to run inside try-except block
676 op_iter = async_gen.aclose()
677
678 with self.assertRaises(RuntimeError):
679 op_iter.send(None)
680
681 self._assertOpIterState(op_iter, "_STATE_ITER")
682
683 def test_send_state_init_arg_is_none_generator_awaits_returns_awaitable_yielded_value_state_iter( # noqa: B950
684 self,
685 ):
686 async def f():
687 class Awaitable:
688 def __await__(self):
689 yield 1
690
691 try:
692 yield 2
693 except GeneratorExit:
694 await Awaitable()
695
696 # Make an async_generator for f
697 async_gen = f()
698
699 # Advance generator into try-except block, pausing after 'yield 2'
700 try:
701 async_gen.asend(None).send(None)
702 except StopIteration:
703 pass
704
705 # Make aclose op_iter which is primted to run inside try-except block
706 op_iter = async_gen.aclose()
707
708 self.assertEqual(op_iter.send(None), 1)
709
710 self._assertOpIterState(op_iter, "_STATE_ITER")
711
712 def test_send_state_iter_arg_is_not_none_arg_sent_into_generator(self):
713 sent_value = None
714
715 async def f():
716 class Awaitable:
717 def __await__(self):
718 nonlocal sent_value
719 sent_value = yield 1
720
721 try:
722 yield 2
723 except GeneratorExit:
724 await Awaitable()
725
726 # Make an async_generator for f
727 async_gen = f()
728
729 # Advance generator into try-except block, pausing after 'yield 2'
730 try:
731 async_gen.asend(None).send(None)
732 except StopIteration:
733 pass
734
735 # Make aclose op_iter which is primted to run inside try-except block
736 op_iter = async_gen.aclose()
737
738 # Executing the aclose operation which should take us to the ITER state
739 # as we run 'await Awaitable()'
740 op_iter.send(None)
741
742 # Send the value 3 in which will appear at the yield in the awaitable
743 # and then finish the generator with a StopIteration.
744 try:
745 op_iter.send(3)
746 except StopIteration:
747 pass
748 self.assertEqual(sent_value, 3)
749
750 def test_send_state_iter_arg_is_none_generator_raises_generator_exit_raises_stop_iteration_state_closed( # noqa: B950
751 self,
752 ):
753 async def f():
754 class Awaitable:
755 def __await__(self):
756 yield 1
757 raise GeneratorExit
758
759 try:
760 yield 2
761 except GeneratorExit:
762 await Awaitable()
763
764 # Make an async_generator for f
765 async_gen = f()
766
767 # Advance generator into try-except block, pausing after 'yield 2'
768 try:
769 async_gen.asend(None).send(None)
770 except StopIteration:
771 pass
772
773 # Make aclose op_iter which is primted to run inside try-except block
774 op_iter = async_gen.aclose()
775
776 # Executing the aclose operation which should take us to the ITER state
777 # as we run 'await Awaitable()'
778 op_iter.send(None)
779
780 with self.assertRaises(StopIteration) as exc:
781 op_iter.send(None)
782 self.assertIsNone(exc.exception.value)
783
784 self._assertOpIterState(op_iter, "_STATE_CLOSED")
785
786 def test_send_state_iter_arg_is_none_generator_raises_stop_async_iteration_raises_stop_iteration_state_closed( # noqa: B950
787 self,
788 ):
789 async def f():
790 class Awaitable:
791 def __await__(self):
792 yield 1
793
794 try:
795 yield 2
796 except GeneratorExit:
797 await Awaitable()
798 # Terminating here raises StopAsyncIteration
799
800 # Make an async_generator for f
801 async_gen = f()
802
803 # Advance generator into try-except block, pausing after 'yield 2'
804 try:
805 async_gen.asend(None).send(None)
806 except StopIteration:
807 pass
808
809 # Make aclose op_iter which is primted to run inside try-except block
810 op_iter = async_gen.aclose()
811
812 # Executing the aclose operation which should take us to the ITER state
813 # as we run 'await Awaitable()'
814 op_iter.send(None)
815
816 with self.assertRaises(StopIteration) as exc:
817 op_iter.send(None)
818 self.assertIsNone(exc.exception.value)
819
820 self._assertOpIterState(op_iter, "_STATE_CLOSED")
821
822 def test_send_state_iter_arg_is_none_generator_yields_raises_runtime_error_state_iter( # noqa: B950
823 self,
824 ):
825 async def f():
826 class Awaitable:
827 def __await__(self):
828 yield 1
829
830 try:
831 yield 2
832 except GeneratorExit:
833 await Awaitable()
834 yield 3
835
836 # Make an async_generator for f
837 async_gen = f()
838
839 # Advance generator into try-except block, pausing after 'yield 2'
840 try:
841 async_gen.asend(None).send(None)
842 except StopIteration:
843 pass
844
845 # Make aclose op_iter which is primted to run inside try-except block
846 op_iter = async_gen.aclose()
847
848 # Executing the aclose operation which should take us to the ITER state
849 # as we run 'await Awaitable()'
850 op_iter.send(None)
851
852 with self.assertRaises(RuntimeError):
853 op_iter.send(None)
854
855 self._assertOpIterState(op_iter, "_STATE_ITER")
856
857 def test_send_state_iter_arg_is_none_generator_awaits_returns_awaitable_yielded_value_state_iter( # noqa: B950
858 self,
859 ):
860 async def f():
861 class Awaitable:
862 def __init__(self, yield_value):
863 self._yield_value = yield_value
864
865 def __await__(self):
866 yield self._yield_value
867
868 try:
869 yield 1
870 except GeneratorExit:
871 await Awaitable(2)
872 await Awaitable(3)
873
874 # Make an async_generator for f
875 async_gen = f()
876
877 # Advance generator into try-except block, pausing after 'yield 1'
878 try:
879 async_gen.asend(None).send(None)
880 except StopIteration:
881 pass
882
883 # Make aclose op_iter which is primted to run inside try-except block
884 op_iter = async_gen.aclose()
885
886 # Executing the aclose operation which should take us to the ITER state
887 # as we run 'await Awaitable()'
888 op_iter.send(None)
889
890 self.assertEqual(op_iter.send(None), 3)
891
892 self._assertOpIterState(op_iter, "_STATE_ITER")
893
894 def test_throw_state_closed_raises_stop_iteration_state_closed(self):
895 async def f():
896 yield 1
897
898 # Make aclose op_iter in closed state
899 op_iter = f().aclose()
900 op_iter.close()
901
902 with self.assertRaises(
903 RuntimeError, msg="cannot reuse already awaited aclose()/athrow()"
904 ):
905 op_iter.throw(None, None, None)
906
907 self._assertOpIterState(op_iter, "_STATE_CLOSED")
908
909 def test_throw_state_init_with_non_exception_raises_type_error(self):
910 async def f():
911 yield 1
912
913 # Make aclose op_iter
914 op_iter = f().aclose()
915
916 with self.assertRaises(TypeError):
917 op_iter.throw(None, None, None)
918
919 def test_throw_state_iter_generator_raise_propagates_state_iter(self):
920 async def f():
921 class Awaitable:
922 def __await__(self):
923 yield 1
924
925 try:
926 yield 2
927 except GeneratorExit:
928 await Awaitable()
929
930 # Make an async_generator for f
931 async_gen = f()
932
933 # Advance generator into try-except block, pausing after 'yield 2'
934 try:
935 async_gen.asend(None).send(None)
936 except StopIteration:
937 pass
938
939 # Make aclose op_iter which is primted to run inside try-except block
940 op_iter = async_gen.aclose()
941
942 # Executing the aclose operation which should take us to the ITER state
943 # as we run 'await Awaitable()'
944 op_iter.send(None)
945
946 with self.assertRaises(ValueError) as exc:
947 op_iter.throw(ValueError, 3, None)
948 self.assertEqual(exc.exception.args, (3,))
949
950 self._assertOpIterState(op_iter, "_STATE_ITER")
951
952 def test_throw_state_iter_generator_yields_raises_runtime_error_state_iter(self):
953 async def f():
954 class Awaitable:
955 def __await__(self):
956 yield 1
957
958 try:
959 yield 2
960 except GeneratorExit:
961 try:
962 await Awaitable()
963 except ValueError:
964 yield 3
965
966 # Make an async_generator for f
967 async_gen = f()
968
969 # Advance generator into try-except block, pausing after 'yield 2'
970 try:
971 async_gen.asend(None).send(None)
972 except StopIteration:
973 pass
974
975 # Make aclose op_iter which is primted to run inside try-except block
976 op_iter = async_gen.aclose()
977
978 # Executing the aclose operation which should take us to the ITER state
979 # as we run 'await Awaitable()'
980 op_iter.send(None)
981
982 with self.assertRaises(RuntimeError):
983 op_iter.throw(ValueError, 4, None)
984
985 self._assertOpIterState(op_iter, "_STATE_ITER")
986
987 def test_throw_state_iter_generator_awaits_returns_awaitable_yielded_value_state_iter( # noqa: B950
988 self,
989 ):
990 async def f():
991 class Awaitable:
992 def __init__(self, yield_value):
993 self._yield_value = yield_value
994
995 def __await__(self):
996 yield self._yield_value
997
998 try:
999 yield 1
1000 except GeneratorExit:
1001 try:
1002 await Awaitable(2)
1003 except ValueError:
1004 await Awaitable(3)
1005
1006 # Make an async_generator for f
1007 async_gen = f()
1008
1009 # Advance generator into try-except block, pausing after 'yield 2'
1010 try:
1011 async_gen.asend(None).send(None)
1012 except StopIteration:
1013 pass
1014
1015 # Make aclose op_iter which is primted to run inside try-except block
1016 op_iter = async_gen.aclose()
1017
1018 # Executing the aclose operation which should take us to the ITER state
1019 # as we run 'await Awaitable()'
1020 op_iter.send(None)
1021
1022 self.assertEqual(op_iter.throw(ValueError, 4, None), 3)
1023
1024 self._assertOpIterState(op_iter, "_STATE_ITER")
1025
1026
1027class AsyncGeneratorAsendTests(unittest.TestCase):
1028 _STATE_MAP = {"_STATE_INIT": 0, "_STATE_ITER": 1, "_STATE_CLOSED": 2}
1029
1030 def _assertOpIterState(self, op_iter, state_str):
1031 if sys.implementation.name == "skybison":
1032 state = _async_generator_op_iter_get_state(op_iter)
1033 self.assertEqual(state, AsyncGeneratorAsendTests._STATE_MAP[state_str])
1034
1035 def test_dunder_await_with_non_async_generator_asend_raises_type_error(self):
1036 async def async_gen_func():
1037 yield
1038
1039 with self.assertRaises(TypeError):
1040 type(async_gen_func().asend(None)).__await__(None)
1041
1042 def test_dunder_iter_with_non_async_generator_asend_raises_type_error(self):
1043 async def async_gen_func():
1044 yield
1045
1046 with self.assertRaises(TypeError):
1047 type(async_gen_func().asend(None)).__iter__(None)
1048
1049 def test_dunder_next_with_non_async_generator_asend_raises_type_error(self):
1050 async def async_gen_func():
1051 yield
1052
1053 with self.assertRaises(TypeError):
1054 type(async_gen_func().asend(None)).__next__(None)
1055
1056 def test_close_with_non_async_generator_asend_raises_type_error(self):
1057 async def async_gen_func():
1058 yield
1059
1060 with self.assertRaises(TypeError):
1061 type(async_gen_func().asend(None)).close(None)
1062
1063 def test_send_with_non_async_generator_asend_raises_type_error(self):
1064 async def async_gen_func():
1065 yield
1066
1067 with self.assertRaises(TypeError):
1068 type(async_gen_func().asend(None)).send(None, None)
1069
1070 def test_throw_with_non_async_generator_asend_raises_type_error(self):
1071 async def async_gen_func():
1072 yield
1073
1074 with self.assertRaises(TypeError):
1075 type(async_gen_func().asend(None)).throw(None, None, None, None)
1076
1077 def test_dunder_await_returns_self(self):
1078 async def f():
1079 yield 1
1080
1081 op_iter = f().asend(None)
1082
1083 self.assertIs(op_iter.__await__(), op_iter)
1084
1085 def test_dunder_iter_returns_self(self):
1086 async def f():
1087 yield 1
1088
1089 op_iter = f().asend(None)
1090
1091 self.assertIs(op_iter.__iter__(), op_iter)
1092
1093 def test_is_awaitable(self):
1094 async def f():
1095 yield 1
1096
1097 op_iter = f().asend(None)
1098
1099 async def awaiter(awaitable):
1100 return await awaitable
1101
1102 try:
1103 # This would raise TypeError if op_iter were not awaitable.
1104 awaiter(op_iter).send(None)
1105 except StopIteration:
1106 pass
1107
1108 def test_is_iterable(self):
1109 async def f():
1110 yield 1
1111
1112 op_iter = f().asend(None)
1113
1114 with self.assertRaises(StopIteration) as exc:
1115 next(iter(op_iter))
1116 self.assertEqual(exc.exception.value, 1)
1117
1118 @pyro_only
1119 def test_new_instance_starts_in_init_state(self):
1120 async def f():
1121 yield 1
1122
1123 op_iter = f().asend(None)
1124
1125 self._assertOpIterState(op_iter, "_STATE_INIT")
1126
1127 @pyro_only
1128 def test_close_moves_into_closed_state(self):
1129 async def f():
1130 yield 1
1131
1132 # Make asend op_iter
1133 op_iter = f().asend(None)
1134
1135 op_iter.close()
1136 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1137
1138 def test_send_state_closed_raises_stop_iteration_state_closed(self):
1139 async def f():
1140 yield 1
1141
1142 # Make asend op_iter in closed state
1143 op_iter = f().asend(None)
1144 op_iter.close()
1145
1146 with self.assertRaises(
1147 RuntimeError, msg="cannot reuse already awaited __anext__()/asend()"
1148 ):
1149 op_iter.send(None)
1150
1151 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1152
1153 def test_send_state_init_arg_is_none_sends_primed_value_into_generator(self):
1154 sent_value = 1
1155
1156 async def f():
1157 nonlocal sent_value
1158 sent_value = yield 2
1159
1160 async_gen = f()
1161
1162 # Advance generator through 'yield 2' to waiting to receive a value.
1163 try:
1164 async_gen.asend(None).send(None)
1165 except StopIteration:
1166 pass
1167
1168 try:
1169 # Setup an asend op iter with a "primed" value of 3
1170 async_gen.asend(3).send(None)
1171 except StopAsyncIteration:
1172 pass
1173 self.assertEqual(sent_value, 3)
1174
1175 def test_send_state_init_arg_is_set_sends_arg_into_generator(self):
1176 sent_value = 1
1177
1178 async def f():
1179 nonlocal sent_value
1180 sent_value = yield 2
1181
1182 async_gen = f()
1183
1184 # Advance generator through 'yield 2' to waiting to receive a value.
1185 try:
1186 async_gen.asend(None).send(None)
1187 except StopIteration:
1188 pass
1189
1190 try:
1191 # Setup an asend op iter with a "primed" value of 3 but override
1192 # it with an initial send value of 4.
1193 async_gen.asend(3).send(4)
1194 except StopAsyncIteration:
1195 pass
1196 self.assertEqual(sent_value, 4)
1197
1198 def test_send_state_init_generator_raises_propagates_state_closed(self):
1199 async def f():
1200 raise ValueError
1201 yield
1202
1203 op_iter = f().asend(None)
1204
1205 with self.assertRaises(ValueError):
1206 op_iter.send(None)
1207
1208 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1209
1210 def test_send_state_init_generator_yields_raises_stop_iteration_with_value_state_closed( # noqa: B950
1211 self,
1212 ):
1213 async def f():
1214 yield 1
1215
1216 op_iter = f().asend(None)
1217
1218 with self.assertRaises(StopIteration) as exc:
1219 op_iter.send(None)
1220 self.assertEqual(exc.exception.value, 1)
1221
1222 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1223
1224 def test_send_state_init_generator_awaits_returns_value_yielded_from_awaitable_state_iter( # noqa: B950
1225 self,
1226 ):
1227 async def f():
1228 class Awaitable:
1229 def __await__(self):
1230 yield 1
1231
1232 await Awaitable()
1233 yield 2
1234
1235 op_iter = f().asend(None)
1236
1237 self.assertEqual(op_iter.send(None), 1)
1238
1239 self._assertOpIterState(op_iter, "_STATE_ITER")
1240
1241 def test_send_state_iter_arg_is_none_sends_none_into_generator(self):
1242 sent_value = 1
1243
1244 async def f():
1245 class Awaitable:
1246 def __await__(self):
1247 nonlocal sent_value
1248 sent_value = yield 2
1249
1250 await Awaitable()
1251 yield 3
1252
1253 op_iter = f().asend(None)
1254
1255 # Advance generator to the 'yield 2' inside the Awaitable.
1256 # The op_iter is now in the ITER state.
1257 op_iter.send(None)
1258
1259 # Send None into generator to be received by 'sent_value'
1260 try:
1261 op_iter.send(None)
1262 except StopIteration:
1263 pass
1264
1265 self.assertEqual(sent_value, None)
1266
1267 def test_send_state_iter_arg_is_set_sends_arg_into_generator(self):
1268 sent_value = 1
1269
1270 async def f():
1271 class Awaitable:
1272 def __await__(self):
1273 nonlocal sent_value
1274 sent_value = yield 2
1275
1276 await Awaitable()
1277 yield 3
1278
1279 op_iter = f().asend(None)
1280
1281 # Advance generator to the 'yield 2' inside the Awaitable.
1282 # The op_iter is now in the ITER state.
1283 op_iter.send(None)
1284
1285 # Send 4 into generator to be received by 'sent_value'
1286 try:
1287 op_iter.send(4)
1288 except StopIteration:
1289 pass
1290
1291 self.assertEqual(sent_value, 4)
1292
1293 def test_send_state_init_generator_raises_propagates_state_closed(self):
1294 async def f():
1295 class Awaitable:
1296 def __await__(self):
1297 yield 1
1298 raise ValueError
1299
1300 await Awaitable()
1301 yield 2
1302
1303 op_iter = f().asend(None)
1304
1305 # Advance generator to the 'yield 1' inside the Awaitable.
1306 # The op_iter is now in the ITER state.
1307 op_iter.send(None)
1308
1309 with self.assertRaises(ValueError):
1310 op_iter.send(None)
1311
1312 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1313
1314 def test_send_state_iter_generator_yields_raises_stop_iteration_with_value_state_closed( # noqa: B950
1315 self,
1316 ):
1317 async def f():
1318 class Awaitable:
1319 def __await__(self):
1320 yield 1
1321
1322 await Awaitable()
1323 yield 2
1324
1325 # Make asend op_iter
1326 op_iter = f().asend(None)
1327
1328 # Advance generator to the 'yield 1' inside the Awaitable.
1329 # The op_iter is now in the ITER state.
1330 op_iter.send(None)
1331
1332 with self.assertRaises(StopIteration) as exc:
1333 op_iter.send(None)
1334 self.assertEqual(exc.exception.value, 2)
1335
1336 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1337
1338 def test_send_state_init_generator_awaits_returns_value_yielded_from_awaitable_state_iter( # noqa: B950
1339 self,
1340 ):
1341 async def f():
1342 class Awaitable:
1343 def __init__(self, yield_value):
1344 self._yield_value = yield_value
1345
1346 def __await__(self):
1347 yield self._yield_value
1348
1349 await Awaitable(1)
1350 await Awaitable(2)
1351 yield 3
1352
1353 # Make asend op_iter
1354 op_iter = f().asend(None)
1355
1356 # Advance generator to the point it runs 'yield 1' inside the Awaitable.
1357 # The op_iter is now in the ITER state.
1358 op_iter.send(None)
1359
1360 self.assertEqual(op_iter.send(None), 2)
1361
1362 self._assertOpIterState(op_iter, "_STATE_ITER")
1363
1364 def test_throw_state_closed_raises_stop_iteration_state_closed(self):
1365 async def f():
1366 yield 1
1367
1368 # Make asend op_iter in closed state
1369 op_iter = f().asend(None)
1370 op_iter.close()
1371
1372 with self.assertRaises(
1373 RuntimeError, msg="cannot reuse already awaited __anext__()/asend()"
1374 ):
1375 op_iter.throw(None, None, None)
1376
1377 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1378
1379 def test_throw_state_init_propagates_exception_through_generator_state_closed(self):
1380 async def f():
1381 yield 1
1382
1383 # Make asend op_iter
1384 op_iter = f().asend(None)
1385
1386 with self.assertRaises(ValueError) as exc:
1387 op_iter.throw(ValueError, 1)
1388 self.assertEqual(exc.exception.args, (1,))
1389
1390 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1391
1392 def test_throw_state_init_generator_catches_and_yields_raises_stop_iteration_with_value_state_closed( # noqa: B950
1393 self,
1394 ):
1395 async def f():
1396 try:
1397 yield 1
1398 except ValueError:
1399 yield 2
1400
1401 # Make async generator for f
1402 async_gen = f()
1403
1404 # Advanced generator inside try-except block so throw can be caught
1405 # and further action taken.
1406 try:
1407 async_gen.asend(None).send(None)
1408 except StopIteration:
1409 pass
1410
1411 op_iter = async_gen.asend(None)
1412
1413 with self.assertRaises(StopIteration) as exc:
1414 op_iter.throw(ValueError, 3)
1415 self.assertEqual(exc.exception.value, 2)
1416
1417 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1418
1419 def test_throw_state_init_generator_catches_and_awaits_returns_value_yielded_from_awaitable_state_iter( # noqa: B950
1420 self,
1421 ):
1422 async def f():
1423 class Awaitable:
1424 def __await__(self):
1425 yield 1
1426
1427 try:
1428 yield 2
1429 except ValueError:
1430 await Awaitable()
1431
1432 # Make async generator for f
1433 async_gen = f()
1434
1435 # Advanced generator inside try-except block so throw can be caught
1436 # and further action taken.
1437 try:
1438 async_gen.asend(None).send(None)
1439 except StopIteration:
1440 pass
1441
1442 op_iter = async_gen.asend(None)
1443
1444 self.assertEqual(op_iter.throw(ValueError, 3), 1)
1445
1446 self._assertOpIterState(op_iter, "_STATE_ITER")
1447
1448
1449class AsyncGeneratorAthrowTests(unittest.TestCase):
1450 _STATE_MAP = {"_STATE_INIT": 0, "_STATE_ITER": 1, "_STATE_CLOSED": 2}
1451
1452 def _assertOpIterState(self, op_iter, state_str):
1453 if sys.implementation.name == "skybison":
1454 state = _async_generator_op_iter_get_state(op_iter)
1455 self.assertEqual(state, AsyncGeneratorAthrowTests._STATE_MAP[state_str])
1456
1457 def test_dunder_await_with_non_async_generator_athrow_raises_type_error(self):
1458 async def async_gen_func():
1459 yield
1460
1461 with self.assertRaises(TypeError):
1462 type(async_gen_func().athrow(None)).__await__(None)
1463
1464 def test_dunder_iter_with_non_async_generator_athrow_raises_type_error(self):
1465 async def async_gen_func():
1466 yield
1467
1468 with self.assertRaises(TypeError):
1469 type(async_gen_func().athrow(None)).__iter__(None)
1470
1471 def test_dunder_next_with_non_async_generator_athrow_raises_type_error(self):
1472 async def async_gen_func():
1473 yield
1474
1475 with self.assertRaises(TypeError):
1476 type(async_gen_func().athrow(None)).__next__(None)
1477
1478 def test_close_with_non_async_generator_athrow_raises_type_error(self):
1479 async def async_gen_func():
1480 yield
1481
1482 with self.assertRaises(TypeError):
1483 type(async_gen_func().athrow(None)).close(None)
1484
1485 def test_send_with_non_async_generator_athrow_raises_type_error(self):
1486 async def async_gen_func():
1487 yield
1488
1489 with self.assertRaises(TypeError):
1490 type(async_gen_func().athrow(None)).send(None, None)
1491
1492 def test_throw_with_non_async_generator_athrow_raises_type_error(self):
1493 async def async_gen_func():
1494 yield
1495
1496 with self.assertRaises(TypeError):
1497 type(async_gen_func().athrow(None)).throw(None, None, None, None)
1498
1499 def test_dunder_await_returns_self(self):
1500 async def f():
1501 yield 1
1502
1503 # Make athrow op_iter
1504 op_iter = f().athrow(ValueError, 1)
1505
1506 self.assertIs(op_iter.__await__(), op_iter)
1507
1508 def test_dunder_iter_returns_self(self):
1509 async def f():
1510 yield 1
1511
1512 # Make athrow op_iter
1513 op_iter = f().athrow(ValueError, 1)
1514
1515 self.assertIs(op_iter.__iter__(), op_iter)
1516
1517 def test_is_awaitable(self):
1518 async def f():
1519 yield 1
1520
1521 # Make athrow op_iter
1522 op_iter = f().athrow(ValueError, 1)
1523
1524 async def awaiter(awaitable):
1525 return await awaitable
1526
1527 try:
1528 # This would raise TypeError if op_iter were not awaitable.
1529 awaiter(op_iter).send(None)
1530 except ValueError:
1531 pass
1532
1533 def test_is_iterable(self):
1534 async def f():
1535 yield 1
1536
1537 # Make athrow op_iter
1538 op_iter = f().athrow(ValueError, 1)
1539
1540 with self.assertRaises(ValueError) as exc:
1541 next(iter(op_iter))
1542 self.assertEqual(exc.exception.args, (1,))
1543
1544 @pyro_only
1545 def test_new_instance_starts_in_init_state(self):
1546 async def f():
1547 yield 1
1548
1549 # Make athrow op_iter
1550 op_iter = f().athrow(ValueError, 1)
1551
1552 self._assertOpIterState(op_iter, "_STATE_INIT")
1553
1554 @pyro_only
1555 def test_close_moves_into_closed_state(self):
1556 async def f():
1557 yield 1
1558
1559 # Make athrow op_iter
1560 op_iter = f().athrow(ValueError, 1)
1561
1562 op_iter.close()
1563 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1564
1565 def test_send_state_closed_raises_stop_iteration_state_closed(self):
1566 async def f():
1567 yield 1
1568
1569 # Make athrow op_iter in closed state
1570 op_iter = f().athrow(ValueError, 1)
1571 op_iter.close()
1572
1573 with self.assertRaises(
1574 RuntimeError, msg="cannot reuse already awaited aclose()/athrow()"
1575 ):
1576 op_iter.send(None)
1577
1578 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1579
1580 def test_send_state_init_arg_is_not_none_raises_runtime_error_state_init(self):
1581 async def f():
1582 yield 1
1583
1584 # Make athrow op_iter
1585 op_iter = f().athrow(ValueError, 1)
1586
1587 with self.assertRaises(RuntimeError):
1588 op_iter.send(1)
1589
1590 self._assertOpIterState(op_iter, "_STATE_INIT")
1591
1592 def test_send_state_init_arg_is_none_generator_raises_stop_async_iteration_propagates_state_closed( # noqa: B950
1593 self,
1594 ):
1595 async def f():
1596 try:
1597 yield 1
1598 except ValueError:
1599 # Returning causes StopAsyncIteration to be raised
1600 return
1601
1602 # Make an async_generator for f
1603 async_gen = f()
1604
1605 # Advance generator into try-except block, pausing after 'yield 1'
1606 try:
1607 async_gen.asend(None).send(None)
1608 except StopIteration:
1609 pass
1610
1611 # Make athrow op_iter which is primted to run inside try-except block
1612 op_iter = async_gen.athrow(ValueError, 2)
1613
1614 with self.assertRaises(StopAsyncIteration):
1615 op_iter.send(None)
1616
1617 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1618
1619 def test_send_state_init_arg_is_none_generator_propagates_generator_exit(
1620 self,
1621 ):
1622 async def f():
1623 yield 1
1624
1625 # Make athrow op_iter
1626 op_iter = f().athrow(GeneratorExit)
1627
1628 with self.assertRaises(GeneratorExit):
1629 op_iter.send(None)
1630
1631 def test_send_state_init_arg_is_none_generator_yields_raises_stop_iteration_with_value_state_iter( # noqa: B950
1632 self,
1633 ):
1634 async def f():
1635 try:
1636 yield 1
1637 except ValueError:
1638 yield 2
1639
1640 # Make an async_generator for f
1641 async_gen = f()
1642
1643 # Advance generator into try-except block, pausing after 'yield 1'
1644 try:
1645 async_gen.asend(None).send(None)
1646 except StopIteration:
1647 pass
1648
1649 # Make athrow op_iter which is primted to run inside try-except block
1650 op_iter = async_gen.athrow(ValueError)
1651
1652 with self.assertRaises(StopIteration) as exc:
1653 op_iter.send(None)
1654 self.assertEqual(exc.exception.value, 2)
1655
1656 self._assertOpIterState(op_iter, "_STATE_ITER")
1657
1658 def test_send_state_init_arg_is_none_generator_awaits_returns_awaitable_yielded_value_state_iter( # noqa: B950
1659 self,
1660 ):
1661 async def f():
1662 class Awaitable:
1663 def __await__(self):
1664 yield 1
1665
1666 try:
1667 yield 2
1668 except ValueError:
1669 await Awaitable()
1670
1671 # Make an async_generator for f
1672 async_gen = f()
1673
1674 # Advance generator into try-except block, pausing after 'yield 2'
1675 try:
1676 async_gen.asend(None).send(None)
1677 except StopIteration:
1678 pass
1679
1680 # Make athrow op_iter which is primted to run inside try-except block
1681 op_iter = async_gen.athrow(ValueError)
1682
1683 self.assertEqual(op_iter.send(None), 1)
1684
1685 self._assertOpIterState(op_iter, "_STATE_ITER")
1686
1687 def test_send_state_iter_arg_is_not_none_arg_sent_into_generator(self):
1688 sent_value = None
1689
1690 async def f():
1691 class Awaitable:
1692 def __await__(self):
1693 nonlocal sent_value
1694 sent_value = yield 1
1695
1696 try:
1697 yield 2
1698 except ValueError:
1699 await Awaitable()
1700
1701 # Make an async_generator for f
1702 async_gen = f()
1703
1704 # Advance generator into try-except block, pausing after 'yield 2'
1705 try:
1706 async_gen.asend(None).send(None)
1707 except StopIteration:
1708 pass
1709
1710 # Make athrow op_iter which is primted to run inside try-except block
1711 op_iter = async_gen.athrow(ValueError, 3)
1712
1713 # Executing the athrow operation which should take us to the ITER state
1714 # as we run 'await Awaitable()'
1715 op_iter.send(None)
1716
1717 # Send the value 4 in which will appear at the yield in the awaitable
1718 # and then finish the generator with a StopAsyncIteration.
1719 try:
1720 op_iter.send(4)
1721 except StopAsyncIteration:
1722 pass
1723 self.assertEqual(sent_value, 4)
1724
1725 def test_send_state_iter_arg_is_none_generator_raise_propagates_state_iter( # noqa: B950
1726 self,
1727 ):
1728 async def f():
1729 class Awaitable:
1730 def __await__(self):
1731 yield 1
1732
1733 try:
1734 yield 2
1735 except ValueError:
1736 await Awaitable()
1737 raise ValueError(3)
1738
1739 # Make an async_generator for f
1740 async_gen = f()
1741
1742 # Advance generator into try-except block, pausing after 'yield 2'
1743 try:
1744 async_gen.asend(None).send(None)
1745 except StopIteration:
1746 pass
1747
1748 # Make athrow op_iter which is primted to run inside try-except block
1749 op_iter = async_gen.athrow(ValueError, 4)
1750
1751 # Execute the athrow operation which should take us to the ITER state
1752 # as we run 'await Awaitable()'
1753 op_iter.send(None)
1754
1755 with self.assertRaises(ValueError) as exc:
1756 op_iter.send(None)
1757 self.assertEqual(exc.exception.args, (3,))
1758
1759 self._assertOpIterState(op_iter, "_STATE_ITER")
1760
1761 def test_send_state_iter_arg_is_none_generator_yields_raises_stop_iteration_with_value_state_iter( # noqa: B950
1762 self,
1763 ):
1764 async def f():
1765 class Awaitable:
1766 def __await__(self):
1767 yield 1
1768
1769 try:
1770 yield 2
1771 except ValueError:
1772 await Awaitable()
1773 yield 3
1774
1775 # Make an async_generator for f
1776 async_gen = f()
1777
1778 # Advance generator into try-except block, pausing after 'yield 2'
1779 try:
1780 async_gen.asend(None).send(None)
1781 except StopIteration:
1782 pass
1783
1784 # Make athrow op_iter which is primted to run inside try-except block
1785 op_iter = async_gen.athrow(ValueError, 4)
1786
1787 # Execute the athrow operation which should take us to the ITER state
1788 # as we run 'await Awaitable()'
1789 op_iter.send(None)
1790
1791 with self.assertRaises(StopIteration) as exc:
1792 op_iter.send(None)
1793 self.assertEqual(exc.exception.value, 3)
1794
1795 self._assertOpIterState(op_iter, "_STATE_ITER")
1796
1797 def test_send_state_iter_arg_is_none_generator_awaits_returns_awaitable_yielded_value_state_iter( # noqa: B950
1798 self,
1799 ):
1800 async def f():
1801 class Awaitable:
1802 def __init__(self, yield_value):
1803 self._yield_value = yield_value
1804
1805 def __await__(self):
1806 yield self._yield_value
1807
1808 try:
1809 yield 1
1810 except ValueError:
1811 await Awaitable(2)
1812 await Awaitable(3)
1813
1814 # Make an async_generator for f
1815 async_gen = f()
1816
1817 # Advance generator into try-except block, pausing after 'yield 1'
1818 try:
1819 async_gen.asend(None).send(None)
1820 except StopIteration:
1821 pass
1822
1823 # Make athrow op_iter which is primted to run inside try-except block
1824 op_iter = async_gen.athrow(ValueError, 4)
1825
1826 # Execute the athrow operation which should take us to the ITER state
1827 # as we run 'await Awaitable()'
1828 op_iter.send(None)
1829
1830 self.assertEqual(op_iter.send(None), 3)
1831
1832 self._assertOpIterState(op_iter, "_STATE_ITER")
1833
1834 def test_throw_state_closed_raises_stop_iteration_state_closed(self):
1835 async def f():
1836 yield 1
1837
1838 # Make athrow op_iter in closed state
1839 op_iter = f().athrow(ValueError, 1)
1840 op_iter.close()
1841
1842 with self.assertRaises(
1843 RuntimeError, msg="cannot reuse already awaited aclose()/athrow()"
1844 ):
1845 op_iter.throw(None, None, None)
1846
1847 self._assertOpIterState(op_iter, "_STATE_CLOSED")
1848
1849 def test_throw_state_init_with_non_exception_raises_type_error(self):
1850 async def f():
1851 yield 1
1852
1853 # Make athrow op_iter
1854 op_iter = f().athrow(ValueError, 1)
1855
1856 with self.assertRaises(TypeError):
1857 op_iter.throw(None, None, None)
1858
1859 def test_throw_state_iter_generator_raise_propagates_state_iter(self):
1860 async def f():
1861 class Awaitable:
1862 def __await__(self):
1863 yield 1
1864
1865 try:
1866 yield 2
1867 except ValueError:
1868 await Awaitable()
1869
1870 # Make an async_generator for f
1871 async_gen = f()
1872
1873 # Advance generator into try-except block, pausing after 'yield 2'
1874 try:
1875 async_gen.asend(None).send(None)
1876 except StopIteration:
1877 pass
1878
1879 # Make athrow op_iter which is primted to run inside try-except block
1880 op_iter = async_gen.athrow(ValueError, 3)
1881
1882 # Execute the athrow operation which should take us to the ITER state
1883 # as we run 'await Awaitable()'
1884 op_iter.send(None)
1885
1886 with self.assertRaises(ValueError) as exc:
1887 op_iter.throw(ValueError, 4, None)
1888 self.assertEqual(exc.exception.args, (4,))
1889
1890 self._assertOpIterState(op_iter, "_STATE_ITER")
1891
1892 def test_throw_state_iter_generator_yields_raises_stop_iteration_error_with_value_state_iter( # noqa: B950
1893 self,
1894 ):
1895 async def f():
1896 class Awaitable:
1897 def __await__(self):
1898 yield 1
1899
1900 try:
1901 yield 2
1902 except ValueError:
1903 try:
1904 await Awaitable()
1905 except ValueError:
1906 yield 3
1907
1908 # Make an async_generator for f
1909 async_gen = f()
1910
1911 # Advance generator into try-except block, pausing after 'yield 2'
1912 try:
1913 async_gen.asend(None).send(None)
1914 except StopIteration:
1915 pass
1916
1917 # Make athrow op_iter which is primted to run inside try-except block
1918 op_iter = async_gen.athrow(ValueError, 4)
1919
1920 # Execute the athrow operation which should take us to the ITER state
1921 # as we run 'await Awaitable()'
1922 op_iter.send(None)
1923
1924 with self.assertRaises(StopIteration) as exc:
1925 op_iter.throw(ValueError, 5, None)
1926 self.assertEqual(exc.exception.value, 3)
1927
1928 self._assertOpIterState(op_iter, "_STATE_ITER")
1929
1930 def test_throw_state_iter_generator_awaits_returns_awaitable_yielded_value_state_iter( # noqa: B950
1931 self,
1932 ):
1933 async def f():
1934 class Awaitable:
1935 def __init__(self, yield_value):
1936 self._yield_value = yield_value
1937
1938 def __await__(self):
1939 yield self._yield_value
1940
1941 try:
1942 yield 1
1943 except ValueError:
1944 try:
1945 await Awaitable(2)
1946 except ValueError:
1947 await Awaitable(3)
1948
1949 # Make an async_generator for f
1950 async_gen = f()
1951
1952 # Advance generator into try-except block, pausing after 'yield 2'
1953 try:
1954 async_gen.asend(None).send(None)
1955 except StopIteration:
1956 pass
1957
1958 # Make athrow op_iter which is primted to run inside try-except block
1959 op_iter = async_gen.athrow(ValueError, 4)
1960
1961 # Execute the athrow operation which should take us to the ITER state
1962 # as we run 'await Awaitable()'
1963 op_iter.send(None)
1964
1965 self.assertEqual(op_iter.throw(ValueError, 5, None), 3)
1966
1967 self._assertOpIterState(op_iter, "_STATE_ITER")
1968
1969
1970class AwaitablesTest(unittest.TestCase):
1971 def test_await_on_awaitable_raising_an_exception_propagates(self):
1972 class Awaitable:
1973 def __await__(self):
1974 raise ValueError
1975
1976 async def f():
1977 return await Awaitable()
1978
1979 with self.assertRaises(ValueError):
1980 f().send(None)
1981
1982 def test_await_on_awaitable_returning_non_iterator_is_type_error(self):
1983 class Awaitable:
1984 def __await__(self):
1985 return 1
1986
1987 async def f():
1988 return await Awaitable()
1989
1990 with self.assertRaisesRegex(
1991 TypeError, "__await__.* returned non-iterator of type 'int'"
1992 ):
1993 f().send(None)
1994
1995 def test_await_on_awaitable_returning_coroutine_raises_type_error(self):
1996 async def f():
1997 pass
1998
1999 with contextlib.closing(f()) as coro:
2000
2001 class Awaitable:
2002 def __await__(self):
2003 return coro
2004
2005 async def g():
2006 return await Awaitable()
2007
2008 with self.assertRaisesRegex(TypeError, "__await__.* returned a coroutine"):
2009 g().send(None)
2010
2011 def test_await_on_awaitable_returning_iterable_coroutine_raises_type_error(self):
2012 class Awaitable:
2013 def __await__(self):
2014 @types.coroutine
2015 def f():
2016 yield
2017
2018 return f()
2019
2020 async def g():
2021 return await Awaitable()
2022
2023 with self.assertRaisesRegex(TypeError, "__await__.* returned a coroutine"):
2024 g().send(None)
2025
2026 def test_async_for_over_awaitable_raising_on_await_raises_type_error_with_cause_and_context(
2027 self,
2028 ):
2029 class AsyncIterator:
2030 def __aiter__(self):
2031 return self
2032
2033 def __anext__(self):
2034 return self
2035
2036 def __await__(self):
2037 raise ValueError
2038
2039 async def f():
2040 async for _ in AsyncIterator():
2041 pass
2042
2043 with self.assertRaisesRegex(
2044 TypeError, "an invalid object from __anext__"
2045 ) as exc:
2046 f().send(None)
2047
2048 self.assertIsInstance(exc.exception.__cause__, ValueError)
2049 self.assertIsInstance(exc.exception.__context__, ValueError)
2050
2051 def test_async_for_over_awaitable_raising_exact_exception_on_await_raises_type_error_with_ause_and_context(
2052 self,
2053 ):
2054 class AsyncIterator:
2055 value_error = ValueError()
2056
2057 def __aiter__(self):
2058 return self
2059
2060 def __anext__(self):
2061 return self
2062
2063 def __await__(self):
2064 raise AsyncIterator.value_error
2065
2066 async def f():
2067 async for _ in AsyncIterator():
2068 pass
2069
2070 with self.assertRaisesRegex(
2071 TypeError, "an invalid object from __anext__"
2072 ) as exc:
2073 f().send(None)
2074
2075 self.assertIs(exc.exception.__cause__, AsyncIterator.value_error)
2076 self.assertIs(exc.exception.__context__, AsyncIterator.value_error)
2077
2078
2079class BinTests(unittest.TestCase):
2080 def test_returns_string(self):
2081 self.assertEqual(bin(0), "0b0")
2082 self.assertEqual(bin(-1), "-0b1")
2083 self.assertEqual(bin(1), "0b1")
2084 self.assertEqual(bin(54321), "0b1101010000110001")
2085 self.assertEqual(bin(494991), "0b1111000110110001111")
2086
2087 def test_with_large_int_returns_string(self):
2088 self.assertEqual(
2089 bin(1 << 63),
2090 "0b1000000000000000000000000000000000000000000000000000000000000000",
2091 )
2092 self.assertEqual(
2093 bin(1 << 64),
2094 "0b10000000000000000000000000000000000000000000000000000000000000000",
2095 )
2096 self.assertEqual(
2097 bin(0xDEE182DE2EC55F61B22A509ED1DC3EB),
2098 "0b1101111011100001100000101101111000101110110001010101111101"
2099 "1000011011001000101010010100001001111011010001110111000011111"
2100 "01011",
2101 )
2102 self.assertEqual(
2103 bin(-0x53ADC651E593B1323158BFA776E8173F60C76519277B2BD6),
2104 "-0b1010011101011011100011001010001111001011001001110110001001"
2105 "1001000110001010110001011111110100111011101101110100000010111"
2106 "0011111101100000110001110110010100011001001001110111101100101"
2107 "01111010110",
2108 )
2109
2110 def test_calls_dunder_index(self):
2111 class C:
2112 def __int__(self):
2113 return 42
2114
2115 def __index__(self):
2116 return -9
2117
2118 self.assertEqual(bin(C()), "-0b1001")
2119
2120 def test_with_int_subclass(self):
2121 class C(int):
2122 pass
2123
2124 self.assertEqual(bin(C(51)), "0b110011")
2125
2126 def test_with_non_int_raises_type_error(self):
2127 with self.assertRaises(TypeError) as context:
2128 bin("not an int")
2129 self.assertEqual(
2130 str(context.exception), "'str' object cannot be interpreted as an integer"
2131 )
2132
2133
2134class BoolTests(unittest.TestCase):
2135 def test_dunder_hash(self):
2136 self.assertEqual(bool.__hash__(False), 0)
2137 self.assertEqual(bool.__hash__(True), 1)
2138
2139 def test_dunder_hash_matches_int_dunder_hash(self):
2140 self.assertEqual(bool.__hash__(False), int.__hash__(0))
2141 self.assertEqual(bool.__hash__(True), int.__hash__(1))
2142
2143 def test_dunder_and_success(self):
2144 self.assertEqual(bool.__and__(True, True), True)
2145 self.assertEqual(bool.__and__(True, False), False)
2146 self.assertEqual(bool.__and__(True, 1024 - 1), 1)
2147 self.assertEqual(bool.__and__(True, 1024), 0)
2148 self.assertEqual(bool.__and__(False, True), False)
2149 self.assertEqual(bool.__and__(False, False), False)
2150 self.assertEqual(bool.__and__(False, 1), 0)
2151 self.assertEqual(bool.__and__(False, 0), 0)
2152
2153 def test_dunder_and_not_implemented(self):
2154 self.assertIs(bool.__and__(True, "string"), NotImplemented)
2155 self.assertIs(bool.__and__(True, 1.8), NotImplemented)
2156
2157 def test_dunder_rand_success(self):
2158 self.assertEqual(bool.__rand__(True, True), True)
2159 self.assertEqual(bool.__rand__(False, True), False)
2160 self.assertEqual(bool.__rand__(True, 1024 - 1), 1)
2161 self.assertEqual(bool.__rand__(True, 1024), 0)
2162 self.assertEqual(bool.__rand__(True, False), False)
2163 self.assertEqual(bool.__rand__(False, False), False)
2164 self.assertEqual(bool.__rand__(False, 1), 0)
2165 self.assertEqual(bool.__rand__(False, 0), 0)
2166
2167 def test_dunder_rand_not_implemented(self):
2168 self.assertIs(bool.__rand__(True, "string"), NotImplemented)
2169 self.assertIs(bool.__rand__(True, 1.8), NotImplemented)
2170
2171 def test_dunder_or_with_non_bool_raises_type_error(self):
2172 self.assertRaisesRegex(
2173 TypeError,
2174 "'__or__' .* 'bool' object.* a 'int'",
2175 bool.__or__,
2176 1,
2177 1,
2178 )
2179
2180 def test_dunder_or_success(self):
2181 self.assertEqual(bool.__or__(True, True), True)
2182 self.assertEqual(bool.__or__(True, False), True)
2183 self.assertEqual(bool.__or__(True, 1024 - 1), 1023)
2184 self.assertEqual(bool.__or__(True, 1024), 1025)
2185 self.assertEqual(bool.__or__(False, True), True)
2186 self.assertEqual(bool.__or__(False, False), False)
2187 self.assertEqual(bool.__or__(False, 1), 1)
2188 self.assertEqual(bool.__or__(False, 0), 0)
2189
2190 def test_dunder_or_not_implemented(self):
2191 self.assertIs(bool.__or__(True, "string"), NotImplemented)
2192 self.assertIs(bool.__or__(True, 1.8), NotImplemented)
2193
2194 def test_dunder_ror_with_non_bool_raises_type_error(self):
2195 self.assertRaisesRegex(
2196 TypeError,
2197 "'__ror__' .* 'bool' object.* a 'int'",
2198 bool.__ror__,
2199 1,
2200 1,
2201 )
2202
2203 def test_dunder_ror_success(self):
2204 self.assertEqual(bool.__ror__(True, True), True)
2205 self.assertEqual(bool.__ror__(False, True), True)
2206 self.assertEqual(bool.__ror__(True, 1024 - 1), 1023)
2207 self.assertEqual(bool.__ror__(True, 1024), 1025)
2208 self.assertEqual(bool.__ror__(True, False), True)
2209 self.assertEqual(bool.__ror__(False, False), False)
2210 self.assertEqual(bool.__ror__(False, 1), 1)
2211 self.assertEqual(bool.__ror__(False, 0), 0)
2212
2213 def test_dunder_ror_not_implemented(self):
2214 self.assertIs(bool.__ror__(True, "string"), NotImplemented)
2215 self.assertIs(bool.__ror__(True, 1.8), NotImplemented)
2216
2217 def test_dunder_xor_with_non_bool_raises_type_error(self):
2218 with self.assertRaises(TypeError) as ctx:
2219 bool.__xor__(1, 1)
2220 self.assertIn(
2221 "'__xor__' .* 'bool' object.* a 'int'",
2222 str(ctx.exception),
2223 )
2224
2225 def test_dunder_xor_success(self):
2226 self.assertEqual(bool.__xor__(True, True), False)
2227 self.assertEqual(bool.__xor__(True, False), True)
2228 self.assertEqual(bool.__xor__(True, 1024 - 1), 1022)
2229 self.assertEqual(bool.__xor__(True, 1024), 1025)
2230 self.assertEqual(bool.__xor__(False, True), True)
2231 self.assertEqual(bool.__xor__(False, False), False)
2232 self.assertEqual(bool.__xor__(False, 1), 1)
2233 self.assertEqual(bool.__xor__(False, 0), 0)
2234
2235 def test_dunder_xor_with_non_int_returns_notimplemented(self):
2236 self.assertIs(bool.__xor__(True, "string"), NotImplemented)
2237 self.assertIs(bool.__xor__(True, 1.8), NotImplemented)
2238
2239 def test_dunder_xor_with_non_bool_raises_type_error(self):
2240 self.assertRaisesRegex(
2241 TypeError,
2242 "'__rxor__' .* 'bool' object.* a 'int'",
2243 bool.__rxor__,
2244 1,
2245 1,
2246 )
2247
2248 def test_dunder_rxor_success(self):
2249 self.assertEqual(bool.__rxor__(True, True), False)
2250 self.assertEqual(bool.__rxor__(False, True), True)
2251 self.assertEqual(bool.__rxor__(True, 1024 - 1), 1022)
2252 self.assertEqual(bool.__rxor__(True, 1024), 1025)
2253 self.assertEqual(bool.__rxor__(True, False), True)
2254 self.assertEqual(bool.__rxor__(False, False), False)
2255 self.assertEqual(bool.__rxor__(False, 1), 1)
2256 self.assertEqual(bool.__rxor__(False, 0), 0)
2257
2258 def test_dunder_rxor_with_non_int_returns_notimplemented(self):
2259 self.assertIs(bool.__rxor__(True, "string"), NotImplemented)
2260 self.assertIs(bool.__rxor__(True, 1.8), NotImplemented)
2261
2262
2263class BoundMethodTests(unittest.TestCase):
2264 def test_dunder_func_returns_function(self):
2265 class Foo:
2266 def foo(self):
2267 pass
2268
2269 self.assertIs(Foo.foo, Foo().foo.__func__)
2270
2271 def test_dunder_self_returns_self_member(self):
2272 class Foo:
2273 def foo(self):
2274 pass
2275
2276 f = Foo()
2277 self.assertIs(f, f.foo.__self__)
2278
2279 def test_dunder_doc_returns_function_dunder_doc(self):
2280 class Foo:
2281 def foo(self):
2282 "This is the docstring of foo"
2283 pass
2284
2285 self.assertEqual(Foo().foo.__doc__, "This is the docstring of foo")
2286 self.assertIs(Foo.foo.__doc__, Foo().foo.__doc__)
2287
2288 def test_write_readonly_attributes_raises_attribute_error(self):
2289 class Foo:
2290 def foo(self):
2291 "This is the docstring of foo"
2292 pass
2293
2294 f = Foo().foo
2295 with self.assertRaises(AttributeError):
2296 f.__func__ = abs
2297
2298 with self.assertRaises(AttributeError):
2299 f.__self__ = int
2300
2301 with self.assertRaises(AttributeError):
2302 f.__doc__ = "hey!"
2303
2304 def test_getattribute_returns_function_attribute(self):
2305 class C:
2306 def meth(self):
2307 pass
2308
2309 meth.attr = 42
2310
2311 c = C()
2312 bound = c.meth
2313 self.assertEqual(bound.attr, 42)
2314
2315 def test_dunder_eq_with_invalid_self_raises_type_error(self):
2316 class C:
2317 def meth(self):
2318 pass
2319
2320 with self.assertRaises(TypeError):
2321 type(C().meth).__eq__(None, None)
2322
2323 def test_is_not_same_with_same_method_on_same_instance(self):
2324 class C:
2325 def meth(self):
2326 pass
2327
2328 c = C()
2329 bound_meth1 = c.meth
2330 bound_meth2 = c.meth
2331 self.assertFalse(bound_meth1 is bound_meth2)
2332
2333 def test_equal_with_same_method_on_same_instance(self):
2334 class C:
2335 def meth(self):
2336 pass
2337
2338 c = C()
2339 bound_meth1 = c.meth
2340 bound_meth2 = c.meth
2341 self.assertTrue(bound_meth1.__eq__(bound_meth2))
2342
2343 def test_not_equal_with_same_method_on_different_instances(self):
2344 class C:
2345 def meth(self):
2346 pass
2347
2348 bound_meth1 = C().meth
2349 bound_meth2 = C().meth
2350 self.assertFalse(bound_meth1.__eq__(bound_meth2))
2351
2352 def test_not_equal_with_different_method_on_same_instances(self):
2353 class C:
2354 def meth1(self):
2355 pass
2356
2357 def meth2(self):
2358 pass
2359
2360 c = C()
2361 bound_meth1 = c.meth1
2362 bound_meth2 = c.meth2
2363 self.assertFalse(bound_meth1.__eq__(bound_meth2))
2364
2365 def test_compared_to_non_bound_method_returns_not_implemented(self):
2366 class C:
2367 def meth(self):
2368 pass
2369
2370 self.assertEqual(C().meth.__eq__(None), NotImplemented)
2371
2372 def test_dunder_eq_ignores_overriden_self_equality(self):
2373 class C:
2374 def meth(self):
2375 pass
2376
2377 def __eq__(self, other):
2378 return True
2379
2380 m0 = C().meth
2381 m1 = C().meth
2382 self.assertFalse(m0.__eq__(m1))
2383
2384 def test_dunder_hash_calls_function_hash_but_not_self_hash(self):
2385 class C:
2386 __hash__ = Mock(name="__hash__", return_value=42)
2387
2388 class D:
2389 def __call__(self):
2390 pass
2391
2392 __hash__ = Mock(name="__hash__", return_value=1)
2393
2394 from types import MethodType
2395
2396 self_obj = C()
2397 callable = D()
2398 m = MethodType(callable, self_obj)
2399 self.assertIs(type(hash(m)), int)
2400 C.__hash__.assert_not_called()
2401 D.__hash__.assert_called_once()
2402
2403 def test_dunder_hash_with_equal_objects_returns_equal_values(self):
2404 class C:
2405 def meth(self):
2406 pass
2407
2408 from types import MethodType
2409
2410 self_obj = C()
2411 m0 = MethodType(C.meth, self_obj)
2412 m1 = MethodType(C.meth, self_obj)
2413 m2 = self_obj.meth
2414 self.assertEqual(hash(m0), hash(m0))
2415 self.assertIsNot(m0, m1)
2416 self.assertEqual(hash(m0), hash(m1))
2417 self.assertIsNot(m0, m2)
2418 self.assertEqual(hash(m0), hash(m2))
2419
2420
2421class CallableIteratorTest(unittest.TestCase):
2422 def test_callable_iterator_iterates_till_sentinel(self):
2423 class C:
2424 def __init__(self):
2425 self.x = 0
2426
2427 def __call__(self):
2428 self.x += 1
2429 return self.x
2430
2431 i = C()
2432 it = iter(i, 5)
2433 self.assertFalse(hasattr(it, "__len__"))
2434 self.assertEqual(list(it), [1, 2, 3, 4])
2435
2436 @pyro_only
2437 def test_callable_iterator_dunder_init_initializes(self):
2438 class C:
2439 def __init__(self):
2440 self.x = -5
2441
2442 def __call__(self):
2443 self.x += 3
2444 return self.x
2445
2446 i = C()
2447 it = builtins.callable_iterator(i, 7)
2448 self.assertEqual(list(it), [-2, 1, 4])
2449
2450
2451class ChrTests(unittest.TestCase):
2452 def test_returns_string(self):
2453 self.assertEqual(chr(101), "e")
2454 self.assertEqual(chr(42), "*")
2455 self.assertEqual(chr(0x1F40D), "\U0001f40d")
2456
2457 def test_with_int_subclass_returns_string(self):
2458 class C(int):
2459 pass
2460
2461 self.assertEqual(chr(C(122)), "z")
2462
2463 def test_with_unicode_max_returns_string(self):
2464 import sys
2465
2466 self.assertEqual(ord(chr(sys.maxunicode)), sys.maxunicode)
2467
2468 def test_with_unicode_max_plus_one_raises_value_error(self):
2469 import sys
2470
2471 with self.assertRaises(ValueError) as context:
2472 chr(sys.maxunicode + 1)
2473 self.assertIn("chr() arg not in range", str(context.exception))
2474
2475 def test_with_negative_raises_value_error(self):
2476 with self.assertRaises(ValueError) as context:
2477 chr(-1)
2478 self.assertIn("chr() arg not in range", str(context.exception))
2479
2480 def test_non_int_raises_type_error(self):
2481 with self.assertRaises(TypeError) as context:
2482 chr(None)
2483 self.assertEqual(
2484 str(context.exception), "an integer is required (got type NoneType)"
2485 )
2486
2487 def test_with_large_int_raises_overflow_error(self):
2488 with self.assertRaisesRegex(
2489 OverflowError, r"Python int too large to convert to C \w*"
2490 ):
2491 chr(123456789012345678901234567890)
2492
2493
2494class ClassMethodTests(unittest.TestCase):
2495 def test_dunder_abstractmethod_with_missing_attr_returns_false(self):
2496 def foo():
2497 pass
2498
2499 method = classmethod(foo)
2500 self.assertIs(method.__isabstractmethod__, False)
2501
2502 def test_dunder_abstractmethod_with_false_attr_returns_false(self):
2503 def foo():
2504 pass
2505
2506 foo.__isabstractmethod__ = False
2507 with self.assertRaises(AttributeError):
2508 type(foo).__isabstractmethod__
2509 prop = property(foo)
2510 self.assertIs(prop.__isabstractmethod__, False)
2511
2512 def test_dunder_abstractmethod_with_abstract_returns_true(self):
2513 def foo():
2514 pass
2515
2516 foo.__isabstractmethod__ = ["random", "values"]
2517 with self.assertRaises(AttributeError):
2518 type(foo).__isabstractmethod__
2519 method = classmethod(foo)
2520 self.assertIs(method.__isabstractmethod__, True)
2521
2522 def test_dunder_abstractmethod_with_non_classmethod_raises_type_error(self):
2523 with self.assertRaises(TypeError):
2524 classmethod.__dict__["__isabstractmethod__"].__get__(42)
2525
2526 def test_dunder_class_setter_with_non_type_raises_type_error(self):
2527 class C:
2528 pass
2529
2530 class D:
2531 pass
2532
2533 obj = C()
2534 with self.assertRaisesRegex(TypeError, "__class__ must be"):
2535 obj.__class__ = 123
2536
2537 def test_dunder_class_setter_on_builtin_types_raises_type_error(self):
2538 class C:
2539 pass
2540
2541 class D:
2542 pass
2543
2544 obj = "foo"
2545 with self.assertRaisesRegex(TypeError, "only supported for"):
2546 obj.__class__ = C
2547 with self.assertRaisesRegex(TypeError, "only supported for"):
2548 C.__class__ = D
2549
2550 def test_dunder_class_setter_on_different_layout_raises_type_error(self):
2551 class C(float):
2552 pass
2553
2554 class D(list):
2555 pass
2556
2557 obj = C(12.3)
2558 with self.assertRaisesRegex(TypeError, "layout differs"):
2559 obj.__class__ = D
2560
2561 def test_dunder_class_setter_changes_instance_type(self):
2562 class C:
2563 def foo(self):
2564 return 123
2565
2566 class D:
2567 def foo(self):
2568 return 321
2569
2570 obj = C()
2571 obj.__class__ = D
2572 self.assertIsInstance(obj, D)
2573 self.assertEqual(obj.foo(), 321)
2574
2575 def test_dunder_class_setter_retains_original_attributes(self):
2576 class C:
2577 def __init__(self):
2578 self.a = 123
2579 self.b = 321
2580
2581 pass
2582
2583 class D:
2584 def __init__(self):
2585 self.a = 789
2586 self.b = 987
2587
2588 obj = C()
2589 obj.__class__ = D
2590 self.assertIsInstance(obj, D)
2591 self.assertEqual(obj.a, 123)
2592 self.assertEqual(obj.b, 321)
2593
2594 def test_dunder_func_returns_wrapped_function(self):
2595 class C:
2596 def foo(self):
2597 return 1
2598
2599 bar = classmethod(foo)
2600
2601 self.assertIs(C.bar.__func__, C.foo)
2602
2603 def test_dunder_func_assignment_raises_attribute_error(self):
2604 class C:
2605 def foo(self):
2606 return 1
2607
2608 bar = classmethod(foo)
2609
2610 with self.assertRaises(AttributeError):
2611 C.bar.__func__ = C.foo
2612
2613 def test_has_dunder_call(self):
2614 class C:
2615 @classmethod
2616 def bar(cls):
2617 pass
2618
2619 C.bar.__getattribute__("__call__")
2620
2621 def test_dunder_get_returns_value(self):
2622 class C:
2623 @classmethod
2624 def bar(cls):
2625 return 5
2626
2627 self.assertEqual(C.bar(), 5)
2628
2629 def test_dunder_get_with_subclassed_classmethod_returns_value(self):
2630 class foo(classmethod):
2631 pass
2632
2633 class C:
2634 @foo
2635 def bar(self):
2636 return 5
2637
2638 self.assertEqual(C.bar(), 5)
2639
2640 def test_dunder_get_called_with_non_classmethod_raises_type_error(self):
2641 self.assertRaisesRegex(
2642 TypeError,
2643 "'__get__' .* 'classmethod' object.* a 'float'",
2644 classmethod.__get__,
2645 42.3,
2646 None,
2647 None,
2648 )
2649
2650 def test_dunder_new_called_with_non_type_object_raises_type_error(self):
2651 with self.assertRaises(TypeError) as context:
2652
2653 def bar():
2654 pass
2655
2656 classmethod.__new__(42.3, bar)
2657 self.assertIn("not a type object", str(context.exception))
2658
2659 def test_dunder_new_called_with_non_subtype_raises_type_error(self):
2660 with self.assertRaises(TypeError) as context:
2661
2662 def bar():
2663 pass
2664
2665 classmethod.__new__(float, bar)
2666 self.assertIn("not a subtype of classmethod", str(context.exception))
2667
2668 def test_dunder_new_with_subclassed_classmethod_returns_instance_of_superclass(
2669 self,
2670 ):
2671 class foo(classmethod):
2672 pass
2673
2674 def bar():
2675 pass
2676
2677 self.assertIsInstance(classmethod.__new__(foo, bar), foo)
2678
2679
2680class CodeTests(unittest.TestCase):
2681 def foo(self):
2682 pass
2683
2684 CodeType = type(foo.__code__)
2685
2686 if sys.implementation.name == "skybison" or sys.version_info >= (3, 8):
2687 SAMPLE = CodeType(
2688 1,
2689 1,
2690 1,
2691 4,
2692 1,
2693 1,
2694 b"",
2695 (),
2696 (),
2697 ("a", "b", "c"),
2698 "filename",
2699 "name",
2700 1,
2701 b"",
2702 (),
2703 (),
2704 )
2705
2706 def test_dunder_hash_with_non_code_object_raises_type_error(self):
2707 self.assertRaisesRegex(
2708 TypeError,
2709 "'__hash__' .* 'code' object.* a 'NoneType'",
2710 self.CodeType.__hash__,
2711 None,
2712 )
2713
2714 def test_dunder_hash_returns_stable_value_on_different_code_objects(self):
2715 def foo():
2716 return 4
2717
2718 first_foo_code = foo.__code__
2719
2720 def foo():
2721 return 4
2722
2723 second_foo_code = foo.__code__
2724
2725 self.assertIsNot(first_foo_code, second_foo_code)
2726 self.assertEqual(hash(first_foo_code), hash(second_foo_code))
2727
2728 def test_dunder_new_with_non_int_argcount_raises_type_error(self):
2729 with self.assertRaises(TypeError) as context:
2730 self.CodeType(
2731 "non_int",
2732 1,
2733 1,
2734 4,
2735 1,
2736 1,
2737 b"",
2738 (),
2739 (),
2740 ("a", "b"),
2741 "filename",
2742 "name",
2743 1,
2744 b"",
2745 (),
2746 (),
2747 )
2748 self.assertIn("an integer is required (got type str)", str(context.exception))
2749
2750 def test_dunder_new_with_negative_argcount_raises_value_error(self):
2751 with self.assertRaises(ValueError) as context:
2752 self.CodeType(
2753 -1,
2754 1,
2755 1,
2756 4,
2757 1,
2758 1,
2759 b"",
2760 (),
2761 (),
2762 ("a", "b"),
2763 "filename",
2764 "name",
2765 1,
2766 b"",
2767 (),
2768 (),
2769 )
2770 self.assertIn("argcount must not be negative", str(context.exception))
2771
2772 def test_dunder_new_with_non_int_posonlyargcount_raises_type_error(self):
2773 with self.assertRaises(TypeError) as context:
2774 self.CodeType(
2775 1,
2776 "non_int",
2777 1,
2778 4,
2779 1,
2780 1,
2781 b"",
2782 (),
2783 (),
2784 ("a", "b"),
2785 "filename",
2786 "name",
2787 1,
2788 b"",
2789 (),
2790 (),
2791 )
2792 self.assertIn("an integer is required (got type str)", str(context.exception))
2793
2794 def test_dunder_new_with_non_int_kwonlyargcount_raises_type_error(self):
2795 with self.assertRaises(TypeError) as context:
2796 self.CodeType(
2797 1,
2798 1,
2799 "non_int",
2800 4,
2801 1,
2802 1,
2803 b"",
2804 (),
2805 (),
2806 ("a", "b"),
2807 "filename",
2808 "name",
2809 1,
2810 b"",
2811 (),
2812 (),
2813 )
2814 self.assertIn("an integer is required (got type str)", str(context.exception))
2815
2816 def test_dunder_new_with_negative_kwonlyargcount_raises_value_error(self):
2817 with self.assertRaises(ValueError) as context:
2818 self.CodeType(
2819 1,
2820 0,
2821 -1,
2822 4,
2823 1,
2824 1,
2825 b"",
2826 (),
2827 (),
2828 ("a", "b"),
2829 "filename",
2830 "name",
2831 1,
2832 b"",
2833 (),
2834 (),
2835 )
2836 self.assertIn("kwonlyargcount must not be negative", str(context.exception))
2837
2838 def test_dunder_new_with_non_int_nlocals_raises_type_error(self):
2839 with self.assertRaises(TypeError) as context:
2840 self.CodeType(
2841 1,
2842 0,
2843 1,
2844 "non_int",
2845 1,
2846 1,
2847 b"",
2848 (),
2849 (),
2850 ("a", "b"),
2851 "filename",
2852 "name",
2853 1,
2854 b"",
2855 (),
2856 (),
2857 )
2858 self.assertIn("an integer is required (got type str)", str(context.exception))
2859
2860 def test_dunder_new_with_negative_nlocals_raises_value_error(self):
2861 with self.assertRaises(ValueError) as context:
2862 self.CodeType(
2863 1,
2864 0,
2865 1,
2866 -4,
2867 1,
2868 1,
2869 b"",
2870 (),
2871 (),
2872 ("a", "b"),
2873 "filename",
2874 "name",
2875 1,
2876 b"",
2877 (),
2878 (),
2879 )
2880 self.assertIn("nlocals must not be negative", str(context.exception))
2881
2882 def test_dunder_new_with_non_int_stacksize_raises_type_error(self):
2883 with self.assertRaises(TypeError) as context:
2884 self.CodeType(
2885 1,
2886 0,
2887 1,
2888 1,
2889 "non_int",
2890 1,
2891 b"",
2892 (),
2893 (),
2894 ("a", "b"),
2895 "filename",
2896 "name",
2897 1,
2898 b"",
2899 (),
2900 (),
2901 )
2902 self.assertIn("an integer is required (got type str)", str(context.exception))
2903
2904 def test_dunder_new_with_negative_stacksize_raises_system_error(self):
2905 with self.assertRaises(SystemError):
2906 self.CodeType(
2907 1,
2908 0,
2909 1,
2910 4,
2911 -1,
2912 1,
2913 b"",
2914 (),
2915 (),
2916 ("a", "b"),
2917 "filename",
2918 "name",
2919 1,
2920 b"",
2921 (),
2922 (),
2923 )
2924
2925 def test_dunder_new_with_non_int_flags_raises_type_error(self):
2926 with self.assertRaises(TypeError) as context:
2927 self.CodeType(
2928 1,
2929 0,
2930 1,
2931 1,
2932 1,
2933 "non_int",
2934 b"",
2935 (),
2936 (),
2937 ("a", "b"),
2938 "filename",
2939 "name",
2940 1,
2941 b"",
2942 (),
2943 (),
2944 )
2945 self.assertIn("an integer is required (got type str)", str(context.exception))
2946
2947 def test_dunder_new_with_negative_flags_raises_system_error(self):
2948 with self.assertRaises(SystemError):
2949 self.CodeType(
2950 1,
2951 0,
2952 1,
2953 4,
2954 1,
2955 -1,
2956 b"",
2957 (),
2958 (),
2959 ("a", "b"),
2960 "filename",
2961 "name",
2962 1,
2963 b"",
2964 (),
2965 (),
2966 )
2967
2968 def test_dunder_new_with_non_bytes_code_raises_type_error(self):
2969 with self.assertRaises(TypeError) as context:
2970 self.CodeType(1, 0, 1, 1, 1, 1, "not_bytes", 1, 1, 1, 1, 1, 1, 1)
2971 self.assertIn("bytes", str(context.exception))
2972 self.assertIn("str", str(context.exception))
2973
2974 def test_dunder_new_with_non_tuple_consts_raises_type_error(self):
2975 with self.assertRaises(TypeError) as context:
2976 self.CodeType(1, 0, 1, 1, 1, 1, b"", "not_tuple", 1, 1, 1, 1, 1, 1)
2977 self.assertIn("tuple", str(context.exception))
2978 self.assertIn("str", str(context.exception))
2979
2980 def test_dunder_new_with_non_tuple_names_raises_type_error(self):
2981 with self.assertRaises(TypeError) as context:
2982 self.CodeType(1, 0, 1, 1, 1, 1, b"", (), "not_tuple", 1, 1, 1, 1, 1)
2983 self.assertIn("tuple", str(context.exception))
2984 self.assertIn("str", str(context.exception))
2985
2986 def test_dunder_new_with_non_tuple_varnames_raises_type_error(self):
2987 with self.assertRaises(TypeError) as context:
2988 self.CodeType(1, 0, 1, 1, 1, 1, b"", (), (), "not_tuple", 1, 1, 1, 1)
2989 self.assertIn("tuple", str(context.exception))
2990 self.assertIn("str", str(context.exception))
2991
2992 def test_dunder_new_with_non_str_filename_raises_type_error(self):
2993 with self.assertRaises(TypeError) as context:
2994 self.CodeType(1, 0, 1, 1, 1, 1, b"", (), (), (), b"not_str", 1, 1, 1)
2995 self.assertIn("str", str(context.exception))
2996 self.assertIn("bytes", str(context.exception))
2997
2998 def test_dunder_new_with_non_str_name_raises_type_error(self):
2999 with self.assertRaises(TypeError) as context:
3000 self.CodeType(
3001 1, 0, 1, 1, 1, 1, b"", (), (), (), "filename", b"not_str", 1, 1
3002 )
3003 self.assertIn("str", str(context.exception))
3004 self.assertIn("bytes", str(context.exception))
3005
3006 def test_dunder_new_with_non_int_firstlineno_raises_type_error(self):
3007 with self.assertRaises(TypeError) as context:
3008 self.CodeType(
3009 1,
3010 0,
3011 1,
3012 4,
3013 1,
3014 1,
3015 b"",
3016 (),
3017 (),
3018 ("a", "b"),
3019 "filename",
3020 "name",
3021 "non_int",
3022 b"",
3023 (),
3024 (),
3025 )
3026 self.assertIn("an integer is required (got type str)", str(context.exception))
3027
3028 def test_dunder_new_with_negative_firstlineno_returns_code_object(self):
3029 result = self.CodeType(
3030 1,
3031 0,
3032 1,
3033 4,
3034 1,
3035 1,
3036 b"",
3037 (),
3038 (),
3039 ("a", "b"),
3040 "filename",
3041 "name",
3042 -1,
3043 b"",
3044 (),
3045 (),
3046 )
3047 self.assertIsInstance(result, self.CodeType)
3048
3049 def test_dunder_new_with_non_bytes_lnotab_raises_type_error(self):
3050 with self.assertRaises(TypeError) as context:
3051 self.CodeType(
3052 1, 0, 1, 1, 1, 1, b"", (), (), (), "filename", "name", 1, "not_bytes"
3053 )
3054 self.assertIn("bytes", str(context.exception))
3055 self.assertIn("str", str(context.exception))
3056
3057 def test_dunder_new_with_non_tuple_freevars_raises_type_error(self):
3058 with self.assertRaises(TypeError) as context:
3059 self.CodeType(
3060 1,
3061 0,
3062 1,
3063 1,
3064 1,
3065 1,
3066 b"",
3067 (),
3068 (),
3069 (),
3070 "filename",
3071 "name",
3072 1,
3073 b"",
3074 "not_tuple",
3075 )
3076 self.assertIn("tuple", str(context.exception))
3077 self.assertIn("str", str(context.exception))
3078
3079 def test_dunder_new_with_non_tuple_cellvars_raises_type_error(self):
3080 with self.assertRaises(TypeError) as context:
3081 self.CodeType(
3082 1,
3083 0,
3084 1,
3085 1,
3086 1,
3087 1,
3088 b"",
3089 (),
3090 (),
3091 (),
3092 "filename",
3093 "name",
3094 1,
3095 b"",
3096 (),
3097 "not_tuple",
3098 )
3099 self.assertIn("tuple", str(context.exception))
3100 self.assertIn("str", str(context.exception))
3101
3102 def test_dunder_new_returns_code(self):
3103 result = self.CodeType(
3104 1,
3105 0,
3106 1,
3107 4,
3108 1,
3109 1,
3110 b"",
3111 (),
3112 (),
3113 ("a", "b"),
3114 "filename",
3115 "name",
3116 1,
3117 b"",
3118 (),
3119 (),
3120 )
3121 self.assertIsInstance(result, self.CodeType)
3122
3123 def test_replace_with_non_int_argcount_raises_type_error(self):
3124 with self.assertRaises(TypeError):
3125 self.SAMPLE.replace(co_argcount="non_int")
3126
3127 def test_replace_with_negative_argcount_raises_value_error(self):
3128 with self.assertRaises(ValueError):
3129 self.SAMPLE.replace(co_argcount=-7)
3130
3131 def test_replace_with_argcount_replaces_argcount(self):
3132 self.assertNotEqual(self.SAMPLE.co_argcount, 2)
3133 self.assertLessEqual(self.SAMPLE.co_posonlyargcount, 2)
3134 result = self.SAMPLE.replace(co_argcount=2)
3135 self.assertEqual(result.co_argcount, 2)
3136
3137 def test_replace_with_argcount_less_than_posonlyargcount_raises_system_error(self):
3138 self.assertGreater(self.SAMPLE.co_posonlyargcount, 0)
3139 with self.assertRaises(SystemError):
3140 self.SAMPLE.replace(co_argcount=0)
3141
3142 def test_replace_with_non_int_posonlyargcount_raises_type_error(self):
3143 with self.assertRaises(TypeError):
3144 self.SAMPLE.replace(co_posonlyargcount="non_int")
3145
3146 def test_replace_with_negative_posonlyargcount_raises_value_error(self):
3147 with self.assertRaises(ValueError):
3148 self.SAMPLE.replace(co_posonlyargcount=-7)
3149
3150 def test_replace_with_posonlyargcount_replaces_posonlyargcount(self):
3151 self.assertNotEqual(self.SAMPLE.co_posonlyargcount, 0)
3152 result = self.SAMPLE.replace(co_posonlyargcount=0)
3153 self.assertEqual(result.co_posonlyargcount, 0)
3154
3155 def test_replace_with_non_int_kwonlyargcount_raises_type_error(self):
3156 with self.assertRaises(TypeError):
3157 self.SAMPLE.replace(co_kwonlyargcount="non_int")
3158
3159 def test_replace_with_negative_kwonlyargcount_raises_value_error(self):
3160 with self.assertRaises(ValueError):
3161 self.SAMPLE.replace(co_kwonlyargcount=-7)
3162
3163 def test_replace_with_kwonlyargcount_replaces_kwonlyargcount(self):
3164 self.assertNotEqual(self.SAMPLE.co_kwonlyargcount, 0)
3165 result = self.SAMPLE.replace(co_kwonlyargcount=0)
3166 self.assertEqual(result.co_kwonlyargcount, 0)
3167
3168 def test_replace_with_non_int_nlocals_raises_type_error(self):
3169 with self.assertRaises(TypeError):
3170 self.SAMPLE.replace(co_nlocals="non_int")
3171
3172 def test_replace_with_negative_nlocals_raises_value_error(self):
3173 with self.assertRaises(ValueError):
3174 self.SAMPLE.replace(co_nlocals=-7)
3175
3176 def test_replace_with_nlocals_replaces_nlocals(self):
3177 self.assertNotEqual(self.SAMPLE.co_nlocals, 5)
3178 result = self.SAMPLE.replace(co_nlocals=5)
3179 self.assertEqual(result.co_nlocals, 5)
3180
3181 def test_replace_with_non_int_stacksize_raises_type_error(self):
3182 with self.assertRaises(TypeError):
3183 self.SAMPLE.replace(co_stacksize="non_int")
3184
3185 def test_replace_with_negative_stacksize_raises_value_error(self):
3186 with self.assertRaises(ValueError):
3187 self.SAMPLE.replace(co_stacksize=-7)
3188
3189 def test_replace_with_stacksize_replaces_stacksize(self):
3190 self.assertNotEqual(self.SAMPLE.co_stacksize, 0)
3191 result = self.SAMPLE.replace(co_stacksize=0)
3192 self.assertEqual(result.co_stacksize, 0)
3193
3194 def test_replace_with_non_int_flags_raises_type_error(self):
3195 with self.assertRaises(TypeError):
3196 self.SAMPLE.replace(co_flags="non_int")
3197
3198 def test_replace_with_negative_flags_raises_value_error(self):
3199 with self.assertRaises(ValueError):
3200 self.SAMPLE.replace(co_flags=-7)
3201
3202 def test_replace_with_flags_replaces_flags(self):
3203 self.assertNotEqual(self.SAMPLE.co_flags, 64)
3204 result = self.SAMPLE.replace(co_flags=64)
3205 self.assertEqual(result.co_flags, 64)
3206
3207 def test_replace_with_non_bytes_code_raises_type_error(self):
3208 with self.assertRaises(TypeError):
3209 self.SAMPLE.replace(co_code="non_bytes")
3210
3211 def test_replace_with_code_replaces_code(self):
3212 self.assertNotEqual(self.SAMPLE.co_code, b"123")
3213 result = self.SAMPLE.replace(co_code=b"123")
3214 self.assertEqual(result.co_code, b"123")
3215
3216 def test_replace_with_non_tuple_consts_raises_type_error(self):
3217 with self.assertRaises(TypeError):
3218 self.SAMPLE.replace(co_consts="non_tuple")
3219
3220 def test_replace_with_consts_replaces_consts(self):
3221 self.assertNotEqual(self.SAMPLE.co_consts, (1, 2, 3))
3222 result = self.SAMPLE.replace(co_consts=(1, 2, 3))
3223 self.assertEqual(result.co_consts, (1, 2, 3))
3224
3225 def test_replace_with_non_tuple_names_raises_type_error(self):
3226 with self.assertRaises(TypeError):
3227 self.SAMPLE.replace(co_names="non_tuple")
3228
3229 def test_replace_with_names_replaces_names(self):
3230 self.assertNotEqual(self.SAMPLE.co_names, ("foo", "bar"))
3231 result = self.SAMPLE.replace(co_names=("foo", "bar"))
3232 self.assertEqual(result.co_names, ("foo", "bar"))
3233
3234 def test_replace_with_non_tuple_varnames_raises_type_error(self):
3235 with self.assertRaises(TypeError):
3236 self.SAMPLE.replace(co_varnames="non_tuple")
3237
3238 def test_replace_with_varnames_replaces_varnames(self):
3239 self.assertNotEqual(self.SAMPLE.co_varnames, ("foo", "bar"))
3240 result = self.SAMPLE.replace(co_varnames=("foo", "bar"))
3241 self.assertEqual(result.co_varnames, ("foo", "bar"))
3242
3243 def test_replace_with_non_str_filename_raises_type_error(self):
3244 with self.assertRaises(TypeError):
3245 self.SAMPLE.replace(co_filename=b"non_str")
3246
3247 def test_replace_with_filename_replaces_filename(self):
3248 self.assertNotEqual(self.SAMPLE.co_filename, "newfilename")
3249 result = self.SAMPLE.replace(co_filename="newfilename")
3250 self.assertEqual(result.co_filename, "newfilename")
3251
3252 def test_replace_with_non_str_name_raises_type_error(self):
3253 with self.assertRaises(TypeError):
3254 self.SAMPLE.replace(co_name=b"non_str")
3255
3256 def test_replace_with_name_replaces_name(self):
3257 self.assertNotEqual(self.SAMPLE.co_name, "newname")
3258 result = self.SAMPLE.replace(co_name="newname")
3259 self.assertEqual(result.co_name, "newname")
3260
3261 def test_replace_with_non_int_firstlineno_raises_type_error(self):
3262 with self.assertRaises(TypeError):
3263 self.SAMPLE.replace(co_firstlineno="non_int")
3264
3265 def test_replace_with_negative_firstlineno_raises_value_error(self):
3266 with self.assertRaises(ValueError):
3267 self.SAMPLE.replace(co_firstlineno=-7)
3268
3269 def test_dunder_new_with_existing_negative_firstlineno_raises_value_error(self):
3270 code = self.CodeType(
3271 1,
3272 0,
3273 1,
3274 4,
3275 1,
3276 1,
3277 b"",
3278 (),
3279 (),
3280 ("a", "b"),
3281 "filename",
3282 "name",
3283 -1,
3284 b"",
3285 (),
3286 (),
3287 )
3288 self.assertLess(code.co_firstlineno, 0)
3289 with self.assertRaises(ValueError):
3290 code.replace()
3291
3292 def test_replace_with_firstlineno_replaces_firstlineno(self):
3293 self.assertNotEqual(self.SAMPLE.co_firstlineno, 0)
3294 result = self.SAMPLE.replace(co_firstlineno=0)
3295 self.assertEqual(result.co_firstlineno, 0)
3296
3297 def test_replace_with_non_bytes_lnotab_raises_type_error(self):
3298 with self.assertRaises(TypeError):
3299 self.SAMPLE.replace(co_lnotab="non_bytes")
3300
3301 def test_replace_with_lnotab_replaces_lnotab(self):
3302 self.assertNotEqual(self.SAMPLE.co_lnotab, b"123")
3303 result = self.SAMPLE.replace(co_lnotab=b"123")
3304 self.assertEqual(result.co_lnotab, b"123")
3305
3306 def test_replace_with_non_tuple_freevars_raises_type_error(self):
3307 with self.assertRaises(TypeError):
3308 self.SAMPLE.replace(co_freevars="non_tuple")
3309
3310 def test_replace_with_freevars_replaces_freevars(self):
3311 self.assertNotEqual(self.SAMPLE.co_freevars, ("foo", "bar"))
3312 result = self.SAMPLE.replace(co_freevars=("foo", "bar"))
3313 self.assertEqual(result.co_freevars, ("foo", "bar"))
3314
3315 def test_replace_with_non_tuple_cellvars_raises_type_error(self):
3316 with self.assertRaises(TypeError):
3317 self.SAMPLE.replace(co_cellvars="non_tuple")
3318
3319 def test_replace_with_cellvars_replaces_cellvars(self):
3320 self.assertNotEqual(self.SAMPLE.co_cellvars, ("foo", "bar"))
3321 result = self.SAMPLE.replace(co_cellvars=("foo", "bar"))
3322 self.assertEqual(result.co_cellvars, ("foo", "bar"))
3323
3324
3325class ContextManagerTests(unittest.TestCase):
3326 def test_dunder_exit_return(self):
3327 class Manager:
3328 def __init__(self, test_case):
3329 self._test_case = test_case
3330
3331 def __enter__(self):
3332 pass
3333
3334 def __exit__(self, ty, val, tb):
3335 self._test_case.assertIs(ty, None)
3336 self._test_case.assertIs(val, None)
3337 self._test_case.assertIs(tb, None)
3338
3339 def f():
3340 with Manager(self):
3341 return 10
3342
3343 self.assertEqual(f(), 10)
3344
3345
3346class CompileTests(unittest.TestCase):
3347 def test_compile_with_iterable_coroutine_flag_raises_value_error(self):
3348 self.assertRaises(ValueError, compile, "result = 42", "", "exec", 0x100)
3349
3350 def test_compile_with_only_ast_flag_returns_ast(self):
3351 result = compile("result = 42", "", "exec", ast.PyCF_ONLY_AST)
3352 self.assertIsInstance(result, ast.AST)
3353
3354 def test_compile_with_dont_inherit_and_only_ast_flag_returns_ast(self):
3355 result = compile("result = 42", "", "exec", ast.PyCF_ONLY_AST, True)
3356 self.assertIsInstance(result, ast.AST)
3357
3358 def test_compile_with_negative_optimize_raises_value_error(self):
3359 with self.assertRaisesRegex(ValueError, r"compile\(\): invalid optimize value"):
3360 compile("True", "", "exec", 0, True, -2)
3361
3362 def test_compile_with_too_high_optimize_raises_value_error(self):
3363 with self.assertRaisesRegex(ValueError, r"compile\(\): invalid optimize value"):
3364 compile("True", "", "exec", 0, True, 3)
3365
3366 def test_compile_with_optimize_disables_asserts(self):
3367 code = compile("assert False", "", "exec", 0, True, 1)
3368 exec(code) # should not raise
3369
3370 def test_exec_mode_returns_code(self):
3371 from types import CodeType
3372 from types import ModuleType
3373
3374 code = compile("result = 42", "", "exec", 0, True, -1)
3375 self.assertIsInstance(code, CodeType)
3376 module = ModuleType("")
3377 exec(code, module.__dict__)
3378 self.assertEqual(module.result, 42)
3379
3380 def test_single_returns_code(self):
3381 from types import CodeType
3382 from types import ModuleType
3383
3384 code = compile("result = 8", "", "exec", 0, True, -1)
3385 self.assertIsInstance(code, CodeType)
3386 module = ModuleType("")
3387 exec(code, module.__dict__)
3388 self.assertEqual(module.result, 8)
3389
3390 def test_eval_mode_returns_code(self):
3391 from types import CodeType
3392
3393 code = compile("7 * 9", "", "eval", 0, True, -1)
3394 self.assertIsInstance(code, CodeType)
3395 self.assertEqual(eval(code), 63) # noqa: P204
3396
3397 def test_with_flags_returns_code(self):
3398 import __future__
3399
3400 from types import CodeType
3401
3402 code = compile(
3403 "7 <> 9", "", "eval", __future__.CO_FUTURE_BARRY_AS_BDFL, True, -1
3404 )
3405 self.assertIsInstance(code, CodeType)
3406
3407 def test_inherits_compile_flags(self):
3408 import __future__
3409
3410 from types import CodeType
3411
3412 code = compile(
3413 "compile('7 <> 9', '', 'eval')",
3414 "",
3415 "eval",
3416 __future__.CO_FUTURE_BARRY_AS_BDFL,
3417 True,
3418 -1,
3419 )
3420 self.assertIsInstance(code, CodeType)
3421
3422 def test_with_bytes_source_returns_code(self):
3423 from types import CodeType
3424
3425 code = compile(b"42", "", "eval")
3426 self.assertIsInstance(code, CodeType)
3427
3428 def test_with_bytearray_source_returns_code(self):
3429 from types import CodeType
3430
3431 code = compile(bytearray(b"42"), "", "eval")
3432 self.assertIsInstance(code, CodeType)
3433
3434 def test_raises_syntax_error(self):
3435 with self.assertRaises(SyntaxError) as context:
3436 compile("$*@", "bar", "exec")
3437 self.assertEqual(context.exception.filename, "bar")
3438 self.assertEqual(context.exception.lineno, 1)
3439 with self.assertRaises(SyntaxError):
3440 compile("7 <> 9", "", "eval", 0, True, -1)
3441
3442 def test_statement_with_eval_mode_raises_syntax_error(self):
3443 with self.assertRaises(SyntaxError):
3444 compile("pass", "", "eval")
3445
3446 def test_statements_with_single_mode_raises_syntax_error(self):
3447 with self.assertRaises(SyntaxError) as context:
3448 compile("pass\npass", "", "single")
3449 self.assertIn(
3450 "multiple statements found while compiling a single statement",
3451 str(context.exception),
3452 )
3453
3454 def test_with_invalid_source_raises_type_error(self):
3455 with self.assertRaises(TypeError):
3456 compile(42, "", "eval")
3457
3458 def test_with_invalid_mode_raises_value_error(self):
3459 with self.assertRaises(ValueError):
3460 compile("", "", "not a valid mode")
3461
3462
3463class ComplexTests(unittest.TestCase):
3464 def test_dunder_abs_with_non_complex_self_raises_type_error(self):
3465 with self.assertRaises(TypeError):
3466 complex.__abs__(1)
3467
3468 def test_dunder_abs_calculates_magnitude_returns_float(self):
3469 nums = [complex(x / 3.0, y / 7.0) for x in range(-9, 9) for y in range(-9, 9)]
3470 for num in nums:
3471 self.assertAlmostEqual((num.real ** 2 + num.imag ** 2) ** 0.5, abs(num), 5)
3472
3473 def test_dunder_add_with_non_complex_self_raises_type_error(self):
3474 with self.assertRaises(TypeError):
3475 complex.__add__(1, 2)
3476
3477 def test_dunder_add_with_non_number_type_returns_not_implemented(self):
3478 self.assertIs(complex(3.2, 0).__add__("not-num"), NotImplemented)
3479
3480 def test_dunder_add_adds_numbers_together(self):
3481 self.assertEqual(complex(1.0, 1.0).__add__(0), complex(1, 1))
3482 self.assertEqual(complex(1.0, 1.0).__add__(1.0), complex(2, 1))
3483 self.assertEqual(complex(1.0, 1.0).__add__(complex(2, 2)), complex(3, 3))
3484
3485 def test_dunder_add_with_int_subclass_returns_complex(self):
3486 class A(int):
3487 pass
3488
3489 self.assertEqual(complex(1.0, 1.0).__add__(A(3)), complex(4, 1))
3490
3491 def test_dunder_bool_returns_correct_boolean(self):
3492 self.assertTrue(complex.__bool__(complex(0.0, 1.0)))
3493 self.assertTrue(complex.__bool__(complex(1.0, 0.0)))
3494 self.assertTrue(complex.__bool__(complex(-1.0, 1.0)))
3495
3496 self.assertFalse(complex.__bool__(complex(0.0, 0.0)))
3497
3498 def test_dunder_hash_with_0_image_returns_float_hash(self):
3499 self.assertEqual(complex.__hash__(complex(0.0)), float.__hash__(0.0))
3500 self.assertEqual(complex.__hash__(complex(-0.0)), float.__hash__(-0.0))
3501 self.assertEqual(complex.__hash__(complex(1.0)), float.__hash__(1.0))
3502 self.assertEqual(complex.__hash__(complex(-1.0)), float.__hash__(-1.0))
3503 self.assertEqual(complex.__hash__(complex(42.0)), float.__hash__(42.0))
3504 self.assertEqual(complex.__hash__(complex(1e23)), float.__hash__(1e23))
3505 inf = float("inf")
3506 self.assertEqual(complex.__hash__(complex(inf)), float.__hash__(inf))
3507 nan = float("nan")
3508 self.assertEqual(complex.__hash__(complex(nan)), float.__hash__(nan))
3509
3510 def test_dunder_hash_with_1_imag_returns_hash_info_imag(self):
3511 import sys
3512
3513 imag_hash = sys.hash_info.imag
3514 self.assertEqual(complex.__hash__(1j), imag_hash)
3515 self.assertEqual(
3516 complex.__hash__(1.000000001j), float.__hash__(1.000000001) * imag_hash
3517 )
3518 self.assertEqual(
3519 complex.__hash__(complex(2.0, -3.0)),
3520 float.__hash__(2.0) + float.__hash__(-3.0) * imag_hash,
3521 )
3522
3523 def test_dunder_eq_with_num_and_non_zero_imaginary_returns_false(self):
3524 self.assertFalse(complex(1, 1).__eq__(1))
3525 self.assertFalse(complex(1.0, 1).__eq__(1))
3526
3527 def test_dunder_eq_with_num_compares_real_field(self):
3528 self.assertTrue(complex(2, 0).__eq__(2))
3529 self.assertTrue(complex(3.2, 0).__eq__(3.2))
3530
3531 def test_dunder_eq_with_complex_compares_both_fields(self):
3532 self.assertTrue(complex(1.2, 3.4), complex(1.2, 3.4))
3533 self.assertFalse(complex(3.2, 0).__eq__(complex(3.2, 1)))
3534 self.assertFalse(complex(1, 1).__eq__(complex(3.2, 1)))
3535
3536 def test_dunder_eq_with_non_num_or_complex_returns_false(self):
3537 self.assertIs(complex(3.2, 0).__eq__([3.2, 0]), NotImplemented)
3538 self.assertIs(complex(1, 1).__eq__("(1+1j)"), NotImplemented)
3539
3540 def test_dunder_new_with_no_args_returns_complex_zero(self):
3541 c = complex()
3542 self.assertIsInstance(c, complex)
3543 self.assertEqual(c, 0)
3544
3545 def test_dunder_new_with_int_returns_complex(self):
3546 c = complex(1)
3547 self.assertIsInstance(c, complex)
3548 self.assertEqual(c, 1)
3549
3550 def test_dunder_new_with_float_returns_complex(self):
3551 c = complex(1.0)
3552 self.assertIsInstance(c, complex)
3553 self.assertEqual(c, 1.0)
3554
3555 def test_dunder_new_with_complex_returns_same_complex(self):
3556 c1 = 1 + 2j
3557 c2 = complex(c1)
3558 self.assertIs(c1, c2)
3559
3560 def test_dunder_new_with_str_returns_complex(self):
3561 c = complex("1")
3562 self.assertIsInstance(c, complex)
3563 self.assertEqual(c, 1)
3564
3565 def test_dunder_new_with_str_subclass_returns_complex(self):
3566 class C(str):
3567 pass
3568
3569 c = complex(C("1"))
3570 self.assertIsInstance(c, complex)
3571 self.assertEqual(c, 1)
3572
3573 def test_dunder_new_with_str_subclass_does_not_call_dunder_float(self):
3574 class C(str):
3575 def __float__(self):
3576 return 2.0
3577
3578 c = complex(C("1"))
3579 self.assertIsInstance(c, complex)
3580 self.assertEqual(c, 1)
3581
3582 def test_dunder_new_with_empty_str_raises_value_error(self):
3583 with self.assertRaises(ValueError):
3584 complex("")
3585
3586 def test_dunder_new_with_str_only_whitespace_raises_value_error(self):
3587 with self.assertRaises(ValueError):
3588 complex(" ")
3589
3590 def test_dunder_new_with_str_and_leading_whitespace_returns_complex(self):
3591 c = complex(" 1")
3592 self.assertIsInstance(c, complex)
3593 self.assertEqual(c, 1)
3594
3595 def test_dunder_new_with_str_and_mismatched_parens_raises_value_error(self):
3596 with self.assertRaises(ValueError):
3597 complex("(1")
3598
3599 with self.assertRaises(ValueError):
3600 complex(")1")
3601
3602 with self.assertRaises(ValueError):
3603 complex("()1")
3604
3605 with self.assertRaises(ValueError):
3606 complex("1()")
3607
3608 with self.assertRaises(ValueError):
3609 complex("1(")
3610
3611 with self.assertRaises(ValueError):
3612 complex("1)")
3613
3614 def test_dunder_new_with_str_and_whitespace_inside_parens_returns_complex(self):
3615 c = complex("( 1)")
3616 self.assertIsInstance(c, complex)
3617 self.assertEqual(c, 1)
3618
3619 def test_dunder_new_with_str_and_parens_inside_whitespace_returns_complex(self):
3620 c = complex(" (1)")
3621 self.assertIsInstance(c, complex)
3622 self.assertEqual(c, 1)
3623
3624 def test_dunder_new_with_str_and_trailing_whitespace_returns_complex(self):
3625 c = complex("1 ")
3626 self.assertIsInstance(c, complex)
3627 self.assertEqual(c, 1)
3628
3629 def test_dunder_new_with_str_and_leading_plus_returns_complex(self):
3630 c = complex("+1")
3631 self.assertIsInstance(c, complex)
3632 self.assertEqual(c, 1)
3633
3634 def test_dunder_new_with_str_and_leading_minus_returns_complex(self):
3635 c = complex("-1")
3636 self.assertIsInstance(c, complex)
3637 self.assertEqual(c, -1)
3638
3639 def test_dunder_new_with_str_and_e_returns_complex(self):
3640 c = complex("2e3")
3641 self.assertIsInstance(c, complex)
3642 self.assertEqual(c.real, 2000)
3643 self.assertEqual(c.imag, 0)
3644
3645 c = complex("2E3")
3646 self.assertIsInstance(c, complex)
3647 self.assertEqual(c.real, 2000)
3648 self.assertEqual(c.imag, 0)
3649
3650 def test_dunder_new_with_str_and_only_j_returns_complex(self):
3651 c = complex("j")
3652 self.assertIsInstance(c, complex)
3653 self.assertEqual(c.real, 0)
3654 self.assertEqual(c.imag, 1)
3655
3656 c = complex("J")
3657 self.assertIsInstance(c, complex)
3658 self.assertEqual(c.real, 0)
3659 self.assertEqual(c.imag, 1)
3660
3661 def test_dunder_new_with_str_and_only_imag_returns_complex(self):
3662 c = complex("2j")
3663 self.assertIsInstance(c, complex)
3664 self.assertEqual(c.real, 0)
3665 self.assertEqual(c.imag, 2)
3666
3667 def test_dunder_new_with_str_and_real_and_imag_returns_complex(self):
3668 c = complex("1+2j")
3669 self.assertIsInstance(c, complex)
3670 self.assertEqual(c.real, 1)
3671 self.assertEqual(c.imag, 2)
3672
3673 c = complex("1-2j")
3674 self.assertIsInstance(c, complex)
3675 self.assertEqual(c.real, 1)
3676 self.assertEqual(c.imag, -2)
3677
3678 def test_dunder_new_with_str_and_exponent_imag_returns_complex(self):
3679 c = complex("1-2e3j")
3680 self.assertIsInstance(c, complex)
3681 self.assertEqual(c.real, 1)
3682 self.assertEqual(c.imag, -2000)
3683
3684 c = complex("1-2E3j")
3685 self.assertIsInstance(c, complex)
3686 self.assertEqual(c.real, 1)
3687 self.assertEqual(c.imag, -2000)
3688
3689 def test_dunder_new_with_str_and_fractional_real_and_imag_returns_complex(self):
3690 c = complex("1.234+5.678j")
3691 self.assertIsInstance(c, complex)
3692 self.assertEqual(c.real, 1.234)
3693 self.assertEqual(c.imag, 5.678)
3694
3695 def test_dunder_new_with_str_and_imag_first_raises_value_error(self):
3696 with self.assertRaises(ValueError):
3697 complex("j+1")
3698
3699 def test_dunder_new_with_str_and_imag_no_j_raises_value_error(self):
3700 with self.assertRaises(ValueError):
3701 complex("1-2")
3702
3703 def test_dunder_new_with_str_and_sign_but_no_imag_raises_value_error(self):
3704 with self.assertRaises(ValueError):
3705 complex("1+")
3706
3707 with self.assertRaises(ValueError):
3708 complex("1-")
3709
3710 def test_dunder_new_with_subtype_returns_instance(self):
3711 class C(complex):
3712 pass
3713
3714 c = C()
3715 self.assertIsInstance(c, complex)
3716 self.assertIs(type(c), C)
3717
3718 def test_dunder_new_with_real_numbers_returns_complex(self):
3719 c = complex(1, 2.0)
3720 self.assertIsInstance(c, complex)
3721 self.assertEqual(c, 1 + 2j)
3722
3723 def test_dunder_new_with_complex_numbers_returns_complex(self):
3724 c = complex(4 + 4j, 1 + 2j)
3725 self.assertIsInstance(c, complex)
3726 self.assertEqual(c, 2 + 5j)
3727
3728 def test_dunder_new_with_string_real_and_imag_raises_type_error(self):
3729 with self.assertRaises(TypeError) as context:
3730 complex("foo", 1)
3731 self.assertEqual(
3732 str(context.exception),
3733 "complex() can't take second arg if first is a string",
3734 )
3735
3736 def test_dunder_new_with_string_imag_raises_type_error(self):
3737 with self.assertRaises(TypeError) as context:
3738 complex(1, "foo")
3739 self.assertEqual(
3740 str(context.exception), "complex() second arg can't be a string"
3741 )
3742
3743 def test_dunder_new_calls_dunder_complex(self):
3744 class C(int):
3745 def __complex__(self):
3746 return 1 + 0j
3747
3748 c = complex(C())
3749 self.assertEqual(c, 1 + 0j)
3750
3751 def test_dunder_new_with_dunder_index(self):
3752 class C:
3753 def __index__(self):
3754 return 21
3755
3756 result = complex.__new__(complex, C())
3757 self.assertEqual(result, 21 + 0j)
3758
3759 def test_dunder_new_with_dunder_index_for_imaginary_bit(self):
3760 class C:
3761 def __index__(self):
3762 return 21
3763
3764 result = complex.__new__(complex, 1.0, C())
3765 self.assertEqual(result, 1.0 + 21.0j)
3766
3767 def test_dunder_new_with_non_complex_dunder_complex(self):
3768 class C:
3769 def __complex__(self):
3770 return 1
3771
3772 with self.assertRaises(TypeError) as context:
3773 complex(C())
3774 self.assertEqual(
3775 str(context.exception), "__complex__ returned non-complex (type int)"
3776 )
3777
3778 def test_dunder_new_with_bytes_real_raises_type_error(self):
3779 with self.assertRaises(TypeError) as context:
3780 complex(b"")
3781 self.assertEqual(
3782 str(context.exception),
3783 "complex() first argument must be a string or a number, not 'bytes'",
3784 )
3785
3786 def test_dunder_new_with_bytes_imag_raises_type_error(self):
3787 with self.assertRaises(TypeError) as context:
3788 complex(1, b"")
3789 self.assertEqual(
3790 str(context.exception),
3791 "complex() second argument must be a number, not 'bytes'",
3792 )
3793
3794 def test_dunder_neg_with_non_complex_raises_type_error(self):
3795 with self.assertRaises(TypeError):
3796 complex.__neg__(1.0)
3797
3798 def test_dunder_neg_negates_both_fields_in_complex(self):
3799 self.assertEqual(complex(0, 0).__neg__(), complex(0, 0))
3800 self.assertEqual(complex(1, 2.2).__neg__(), complex(-1, -2.2))
3801 self.assertEqual(complex(-3.4, -5.6).__neg__(), complex(3.4, 5.6))
3802
3803 def test_dunder_neg_with_complex_subclass_returns_complex(self):
3804 class A(complex):
3805 pass
3806
3807 neg_complex_subclass = A(1.2, -2.1).__neg__()
3808 self.assertEqual(type(neg_complex_subclass), complex)
3809 self.assertEqual(neg_complex_subclass, complex(-1.2, 2.1))
3810
3811 def test_dunder_pos_with_non_complex_raises_type_error(self):
3812 with self.assertRaises(TypeError):
3813 complex.__pos__(1.0)
3814
3815 def test_dunder_pos_returns_unmodified_complex(self):
3816 self.assertEqual(complex(0, 0).__pos__(), complex(0, 0))
3817 self.assertEqual(complex(1, 2.2).__pos__(), complex(1, 2.2))
3818 self.assertEqual(complex(-3.4, -5.6).__pos__(), complex(-3.4, -5.6))
3819
3820 def test_dunder_pos_with_complex_subclass_returns_complex(self):
3821 class A(complex):
3822 pass
3823
3824 pos_complex_subclass = A(1, -2).__pos__()
3825 self.assertEqual(type(pos_complex_subclass), complex)
3826 self.assertEqual(pos_complex_subclass, complex(1, -2))
3827
3828 def test_dunder_rsub_with_non_complex_self_raises_type_error(self):
3829 with self.assertRaises(TypeError):
3830 complex.__rsub__(1, 2)
3831
3832 def test_dunder_rsub_with_non_number_type_returns_not_implemented(self):
3833 self.assertIs(complex(3.2, 0).__rsub__("not-num"), NotImplemented)
3834
3835 def test_dunder_rsub_subtracts_first_number_from_second_number(self):
3836 self.assertEqual(complex(1.0, 1.0).__rsub__(0), complex(-1, -1))
3837 self.assertEqual(complex(1.0, 1.0).__rsub__(1.0), complex(0, -1))
3838 self.assertEqual(complex(1.0, 1.0).__rsub__(complex(2, 2)), complex(1, 1))
3839
3840 def test_dunder_rsub_with_int_subclass_returns_complex(self):
3841 class A(int):
3842 pass
3843
3844 self.assertEqual(complex(1.0, 1.0).__rsub__(A(3)), complex(2, -1))
3845
3846 def test_dunder_sub_with_non_complex_self_raises_type_error(self):
3847 with self.assertRaises(TypeError):
3848 complex.__sub__(1, 2)
3849
3850 def test_dunder_sub_with_non_number_type_returns_not_implemented(self):
3851 self.assertIs(complex(3.2, 0).__sub__("not-num"), NotImplemented)
3852
3853 def test_dunder_sub_subtracts_first_number_from_second_number(self):
3854 self.assertEqual(complex(1.0, 1.0).__sub__(0), complex(1, 1))
3855 self.assertEqual(complex(1.0, 1.0).__sub__(1.0), complex(0, 1))
3856 self.assertEqual(complex(1.0, 1.0).__sub__(complex(2, 2)), complex(-1, -1))
3857
3858 def test_dunder_sub_with_int_subclass_returns_complex(self):
3859 class A(int):
3860 pass
3861
3862 self.assertEqual(complex(1.0, 1.0).__sub__(A(3)), complex(-2, 1))
3863
3864 def test_imag_with_subclass_returns_float(self):
3865 class C(complex):
3866 pass
3867
3868 c = C(1 + 2j)
3869 i = c.imag
3870 self.assertIsInstance(i, float)
3871 self.assertEqual(i, 2.0)
3872
3873 def test_real_with_subclass_returns_float(self):
3874 class C(complex):
3875 pass
3876
3877 c = C(1 + 2j)
3878 r = c.real
3879 self.assertIsInstance(r, float)
3880 self.assertEqual(r, 1.0)
3881
3882 def test_dunder_mul_complex_returns_complex(self):
3883 self.assertEqual(complex(1, 2).__mul__(complex(-2, 3)), complex(-8, -1))
3884 self.assertEqual(complex(1, 2).__mul__(complex(2.5, -1)), complex(4.5, 4))
3885 self.assertEqual(complex(1, 2).__mul__(complex(0, 3)), complex(-6, 3))
3886 self.assertEqual(complex(1, 2).__mul__(complex(2, 0)), complex(2, 4))
3887
3888 def test_dunder_mul_complex_with_nan_returns_nan_complex(self):
3889 import math
3890
3891 res = complex(1, 2).__mul__(complex(2, float("nan")))
3892 self.assertTrue(math.isnan(res.real))
3893 self.assertTrue(math.isnan(res.imag))
3894
3895 def test_dunder_rmul_complex_with_nan_returns_nan_complex(self):
3896 import math
3897
3898 res = complex(1, 2).__rmul__(complex(2, float("nan")))
3899 self.assertTrue(math.isnan(res.real))
3900 self.assertTrue(math.isnan(res.imag))
3901
3902 def test_dunder_rmul_complex_with_int_returns_complex(self):
3903 self.assertEqual(complex(1, 2).__rmul__(4), complex(4, 8))
3904
3905 def test_dunder_rmul_complex_with_float_returns_complex(self):
3906 self.assertEqual(complex(1, 2).__rmul__(4.9), complex(4.9, 9.8))
3907
3908 def test_dunder_rmul_complex_with_str_returns_notimplemented(self):
3909 self.assertIs(complex(1, 2).__rmul__("ciao"), NotImplemented)
3910
3911 def test_dunder_rmul_complex_with_list_returns_notimplemented(self):
3912 self.assertIs(complex(1, 2).__rmul__([4]), NotImplemented)
3913
3914 def test_dunder_div_complex_returns_complex(self):
3915 self.assertEqual(complex(1, 2).__truediv__(complex(1, 1)), complex(1.5, 0.5))
3916 self.assertEqual(
3917 complex(1, 2).__truediv__(complex(-2, 2)), complex(0.25, -0.75)
3918 )
3919 self.assertEqual(complex(2, 1).__truediv__(complex(0, 2)), complex(0.5, -1))
3920 self.assertEqual(complex(3, 2).__truediv__(complex(-0.5, 0)), complex(-6, -4))
3921
3922 def test_dunder_div_complex_with_nan_returns_nan_complex(self):
3923 import math
3924
3925 res = complex(1, 2).__truediv__(complex(2, float("nan")))
3926 self.assertTrue(math.isnan(res.real))
3927 self.assertTrue(math.isnan(res.imag))
3928
3929 def test_dunder_div_zero_raises_error(self):
3930 with self.assertRaises(ZeroDivisionError):
3931 complex(1, 2).__truediv__(complex(0, 0))
3932
3933 def test_dunder_repr_with_int_real_and_imag_returns_string(self):
3934 self.assertEqual(complex.__repr__(complex(1, 2)), "(1+2j)")
3935 self.assertEqual(complex.__repr__(complex(1, -2)), "(1-2j)")
3936 self.assertEqual(complex.__repr__(complex(-1, 2)), "(-1+2j)")
3937 self.assertEqual(complex.__repr__(complex(-1, -2)), "(-1-2j)")
3938
3939 def test_dunder_repr_with_float_real_and_imag_returns_string(self):
3940 self.assertEqual(complex.__repr__(complex(1.1, 2.3)), "(1.1+2.3j)")
3941 self.assertEqual(complex.__repr__(complex(1.1, -2.3)), "(1.1-2.3j)")
3942 self.assertEqual(complex.__repr__(complex(-1.1, 2.3)), "(-1.1+2.3j)")
3943 self.assertEqual(complex.__repr__(complex(-1.1, -2.3)), "(-1.1-2.3j)")
3944
3945 def test_dunder_repr_with_int_real_and_float_imag_returns_string(self):
3946 self.assertEqual(complex.__repr__(complex(1, 2.3)), "(1+2.3j)")
3947 self.assertEqual(complex.__repr__(complex(1, -2.3)), "(1-2.3j)")
3948 self.assertEqual(complex.__repr__(complex(-1, 2.3)), "(-1+2.3j)")
3949 self.assertEqual(complex.__repr__(complex(-1, -2.3)), "(-1-2.3j)")
3950
3951 def test_dunder_repr_with_float_real_and_int_imag_returns_string(self):
3952 self.assertEqual(complex.__repr__(complex(1.1, 2)), "(1.1+2j)")
3953 self.assertEqual(complex.__repr__(complex(1.1, -2)), "(1.1-2j)")
3954 self.assertEqual(complex.__repr__(complex(-1.1, 2)), "(-1.1+2j)")
3955 self.assertEqual(complex.__repr__(complex(-1.1, -2)), "(-1.1-2j)")
3956
3957 def test_dunder_repr_with_positive_zero_real_returns_string(self):
3958 self.assertEqual(complex.__repr__(complex(0, 2.3)), "2.3j")
3959 self.assertEqual(complex.__repr__(complex(0, -2.3)), "-2.3j")
3960 self.assertEqual(complex.__repr__(complex(0, 2)), "2j")
3961 self.assertEqual(complex.__repr__(complex(0, -2)), "-2j")
3962
3963 def test_dunder_repr_with_negative_zero_real_returns_string(self):
3964 self.assertEqual(complex.__repr__(complex(-0.0, 2.3)), "(-0+2.3j)")
3965 self.assertEqual(complex.__repr__(complex(-0.0, -2.3)), "(-0-2.3j)")
3966 self.assertEqual(complex.__repr__(complex(-0.0, 2)), "(-0+2j)")
3967 self.assertEqual(complex.__repr__(complex(-0.0, -2)), "(-0-2j)")
3968
3969 def test_dunder_repr_with_non_complex_self_raises_type_error(self):
3970 with self.assertRaises(TypeError):
3971 complex.__repr__(1.0)
3972 with self.assertRaises(TypeError):
3973 complex.__repr__("a")
3974 with self.assertRaises(TypeError):
3975 complex.__repr__(None)
3976
3977 def test_dunder_lt_with_complex_returns_not_implemented(self):
3978 self.assertIs(complex(1, 1).__lt__(complex(1, 1)), NotImplemented)
3979 self.assertIs(complex(1, 1).__lt__(float(1)), NotImplemented)
3980
3981 def test_dunder_le_with_complex_returns_not_implemented(self):
3982 self.assertIs(complex(1, 1).__le__(complex(1, 1)), NotImplemented)
3983 self.assertIs(complex(1, 1).__le__(float(1)), NotImplemented)
3984
3985 def test_dunder_gt_with_complex_returns_not_implemented(self):
3986 self.assertIs(complex(1, 1).__gt__(complex(1, 1)), NotImplemented)
3987 self.assertIs(complex(1, 1).__gt__(float(1)), NotImplemented)
3988
3989 def test_dunder_ge_with_complex_returns_not_implemented(self):
3990 self.assertIs(complex(1, 1).__ge__(complex(1, 1)), NotImplemented)
3991 self.assertIs(complex(1, 1).__ge__(float(1)), NotImplemented)
3992
3993
3994class CoroutineTests(unittest.TestCase):
3995 class MyError(Exception):
3996 pass
3997
3998 class Awaitable:
3999 def __init__(self, yield_value):
4000 self._yield_value = yield_value
4001
4002 def __await__(self):
4003 yield self._yield_value
4004
4005 @staticmethod
4006 async def simple_coro():
4007 await CoroutineTests.Awaitable(1)
4008 await CoroutineTests.Awaitable(2)
4009
4010 @staticmethod
4011 async def catching_coro():
4012 try:
4013 await CoroutineTests.Awaitable(1)
4014 except CoroutineTests.MyError:
4015 await CoroutineTests.Awaitable("caught")
4016
4017 @staticmethod
4018 async def catching_returning_coro():
4019 try:
4020 await CoroutineTests.Awaitable(1)
4021 except CoroutineTests.MyError:
4022 return "all done!" # noqa
4023
4024 def test_calling_iter_raises_type_error(self):
4025 with contextlib.closing(self.simple_coro()) as g:
4026 with self.assertRaises(TypeError):
4027 iter(g)
4028
4029 def test_calling_next_raises_type_error(self):
4030 with contextlib.closing(self.simple_coro()) as g:
4031 with self.assertRaises(TypeError):
4032 next(g)
4033
4034 def test_dunder_await_with_invalid_self_raises_type_error(self):
4035 with contextlib.closing(self.simple_coro()) as g:
4036 with self.assertRaises(TypeError):
4037 type(g).__await__(None)
4038
4039 def test_dunder_await_returns_iterable(self):
4040 it = self.simple_coro().__await__()
4041 self.assertEqual(next(it), 1)
4042 self.assertEqual(next(it), 2)
4043
4044 def test_close_with_invalid_self_raises_type_error(self):
4045 with contextlib.closing(self.simple_coro()) as g:
4046 with self.assertRaises(TypeError):
4047 type(g).close(None)
4048
4049 def test_close_when_exhausted_returns_none(self):
4050 g = self.simple_coro()
4051 self.assertEqual(g.send(None), 1)
4052 self.assertEqual(g.send(None), 2)
4053 self.assertRaises(StopIteration, g.send, None)
4054 self.assertIsNone(g.close())
4055
4056 def test_close_when_generator_exit_propagates_returns_none(self):
4057 saw_generator_exit = False
4058
4059 async def f():
4060 nonlocal saw_generator_exit
4061 try:
4062 await CoroutineTests.Awaitable(1)
4063 except GeneratorExit:
4064 saw_generator_exit = True
4065 raise
4066
4067 g = f()
4068 self.assertEqual(g.send(None), 1)
4069 self.assertIsNone(g.close())
4070 self.assertTrue(saw_generator_exit)
4071
4072 def test_close_when_generator_exit_derived_exception_raised_returns_none(self):
4073 class GeneratorExitDerived(GeneratorExit):
4074 pass
4075
4076 async def f():
4077 try:
4078 await CoroutineTests.Awaitable(1)
4079 except GeneratorExit:
4080 raise GeneratorExitDerived
4081
4082 g = f()
4083 self.assertEqual(g.send(None), 1)
4084 self.assertIsNone(g.close())
4085
4086 def test_close_when_stop_iteration_raised_returns_none(self):
4087 saw_generator_exit = False
4088
4089 async def f():
4090 nonlocal saw_generator_exit
4091 try:
4092 await CoroutineTests.Awaitable(1)
4093 except GeneratorExit:
4094 saw_generator_exit = True
4095 # Implicitly raises StopIteration(2)
4096 return 2
4097
4098 g = f()
4099 self.assertEqual(g.send(None), 1)
4100 self.assertIsNone(g.close())
4101 self.assertTrue(saw_generator_exit)
4102
4103 def test_close_generator_raises_exception_propagates(self):
4104 async def f():
4105 try:
4106 await CoroutineTests.Awaitable(1)
4107 except GeneratorExit:
4108 raise ValueError
4109
4110 g = f()
4111 self.assertEqual(g.send(None), 1)
4112 self.assertRaises(ValueError, g.close)
4113
4114 def test_close_generator_awaits_raises_runtime_error(self):
4115 async def f():
4116 try:
4117 await CoroutineTests.Awaitable(1)
4118 except GeneratorExit:
4119 await CoroutineTests.Awaitable(2)
4120
4121 g = f()
4122 self.assertEqual(g.send(None), 1)
4123 self.assertRaises(RuntimeError, g.close)
4124
4125 def test_throw(self):
4126 g = self.simple_coro()
4127 self.assertRaises(CoroutineTests.MyError, g.throw, CoroutineTests.MyError())
4128
4129 def test_throw_caught(self):
4130 g = self.catching_coro()
4131 self.assertEqual(g.send(None), 1)
4132 self.assertEqual(g.throw(CoroutineTests.MyError()), "caught")
4133
4134 def test_throw_type(self):
4135 g = self.catching_coro()
4136 self.assertEqual(g.send(None), 1)
4137 self.assertEqual(g.throw(CoroutineTests.MyError), "caught")
4138
4139 def test_throw_type_and_value(self):
4140 g = self.catching_coro()
4141 self.assertEqual(g.send(None), 1)
4142 self.assertEqual(
4143 g.throw(CoroutineTests.MyError, CoroutineTests.MyError()), "caught"
4144 )
4145
4146 def test_throw_uncaught_type(self):
4147 g = self.catching_coro()
4148 self.assertEqual(g.send(None), 1)
4149 self.assertRaises(RuntimeError, g.throw, RuntimeError)
4150
4151 def test_throw_finished(self):
4152 g = self.catching_returning_coro()
4153 self.assertEqual(g.send(None), 1)
4154 self.assertRaises(StopIteration, g.throw, CoroutineTests.MyError)
4155
4156 def test_throw_two_values(self):
4157 g = self.catching_coro()
4158 self.assertEqual(g.send(None), 1)
4159 self.assertRaises(
4160 TypeError, g.throw, CoroutineTests.MyError(), CoroutineTests.MyError()
4161 )
4162
4163 def test_throw_bad_traceback(self):
4164 g = self.catching_coro()
4165 self.assertEqual(g.send(None), 1)
4166 self.assertRaises(
4167 TypeError, g.throw, CoroutineTests.MyError, CoroutineTests.MyError(), 5
4168 )
4169
4170 def test_throw_bad_type(self):
4171 g = self.catching_coro()
4172 self.assertEqual(g.send(None), 1)
4173 self.assertRaises(TypeError, g.throw, 1234)
4174
4175 def test_coroutine_awaiting_on_further_coroutine_with_no_arguments(self):
4176 async def f():
4177 pass
4178
4179 async def g():
4180 return await f()
4181
4182 # Send in None to trigger initial execution of coroutine
4183 with self.assertRaises(StopIteration) as exc:
4184 g().send(None)
4185
4186 self.assertIs(exc.exception.value, None)
4187
4188 def test_coroutine_awaiting_on_further_coroutine_with_an_argument(self):
4189 v = "foo"
4190
4191 async def f(v):
4192 return v
4193
4194 async def g():
4195 return await f(v)
4196
4197 # Send in None to trigger initial execution of coroutine
4198 with self.assertRaises(StopIteration) as exc:
4199 g().send(None)
4200
4201 self.assertIs(exc.exception.value, v)
4202
4203 def test_stop_iteration_raised_from_coroutine_turns_into_runtime_error(self):
4204 async def f():
4205 raise StopIteration
4206
4207 # Send in None to trigger initial execution of coroutine
4208 with self.assertRaises(RuntimeError):
4209 f().send(None)
4210
4211 def test_stop_iteration_raised_from_coroutine_but_caught_can_return_a_value(self):
4212 async def f():
4213 try:
4214 raise StopIteration
4215 except StopIteration:
4216 return 1
4217
4218 # Send in None to trigger initial execution of coroutine
4219 with self.assertRaises(StopIteration) as exc:
4220 f().send(None)
4221
4222 self.assertEqual(exc.exception.value, 1)
4223
4224 def test_stop_iteration_raised_from_inner_coroutine_turns_into_runtime_error(self):
4225 async def f():
4226 raise StopIteration
4227
4228 async def g():
4229 return await f()
4230
4231 # Send in None to trigger initial execution of coroutine
4232 with self.assertRaises(RuntimeError):
4233 g().send(None)
4234
4235 def test_sub_classed_stop_iteration_raised_from_coroutine_turns_into_runtime_error(
4236 self,
4237 ):
4238 class SubClassedStopIteration(AttributeError, StopIteration):
4239 pass
4240
4241 async def f():
4242 raise SubClassedStopIteration
4243
4244 # Send in None to trigger initial execution of coroutine
4245 with self.assertRaises(RuntimeError):
4246 f().send(None)
4247
4248 def test_yield_from_coroutine_in_non_coroutine_iter_raises_exception(self):
4249 async def coro():
4250 pass
4251
4252 def f(coro_inst):
4253 yield from coro_inst
4254
4255 with contextlib.closing(coro()) as coro_inst:
4256 with self.assertRaises(TypeError):
4257 f(coro_inst).send(None)
4258
4259 def test_awaiting_already_awaited_coroutine_raises_runtime_error(self):
4260 class Awaitable:
4261 def __await__(self):
4262 return self
4263
4264 def __next__(self):
4265 return None
4266
4267 async def f():
4268 await Awaitable()
4269
4270 coro = f()
4271
4272 async def g():
4273 nonlocal coro
4274 await coro
4275
4276 coro.send(None)
4277
4278 with self.assertRaisesRegex(RuntimeError, "coroutine is being awaited already"):
4279 g().send(None)
4280
4281 def test_send_into_finished_coro_raises_runtime_error(self):
4282 g = self.simple_coro()
4283 self.assertEqual(g.send(None), 1)
4284 self.assertEqual(g.send(None), 2)
4285 with self.assertRaises(StopIteration):
4286 g.send(None)
4287 with self.assertRaises(RuntimeError):
4288 g.send(None)
4289
4290 def test_throw_into_finshed_coro_raises_runtime_error(self):
4291 g = self.simple_coro()
4292 self.assertEqual(g.send(None), 1)
4293 self.assertEqual(g.send(None), 2)
4294 with self.assertRaises(StopIteration):
4295 g.send(None)
4296 with self.assertRaises(RuntimeError):
4297 g.throw(CoroutineTests.MyError())
4298
4299 def test_close_finshed_coro_raises_is_no_op(self):
4300 g = self.simple_coro()
4301 self.assertEqual(g.send(None), 1)
4302 self.assertEqual(g.send(None), 2)
4303 with self.assertRaises(StopIteration):
4304 g.send(None)
4305 self.assertIsNone(g.close())
4306
4307 def test_exception_context_captured_across_further_awaits(self):
4308 async def raises():
4309 raise ValueError
4310
4311 async def double_raises():
4312 try:
4313 raise RuntimeError
4314 except RuntimeError:
4315 await raises()
4316
4317 with self.assertRaises(ValueError) as exc:
4318 double_raises().send(None)
4319
4320 self.assertIsInstance(exc.exception.__context__, RuntimeError)
4321
4322 def test_coroutine_returning_explicit_stop_iteration_value_passes_through_unchanged(
4323 self,
4324 ):
4325 v = StopIteration(10)
4326
4327 async def f():
4328 return v
4329
4330 # Send in None to trigger initial execution of coroutine
4331 with self.assertRaises(StopIteration) as exc:
4332 f().send(None)
4333
4334 self.assertIs(exc.exception.value, v)
4335 self.assertEqual(exc.exception.args, (v,))
4336
4337 def test_coroutine_returning_stop_iteration_sub_class_passes_through_unchanged(
4338 self,
4339 ):
4340 class SubClassedStopIteration(StopIteration):
4341 pass
4342
4343 v = SubClassedStopIteration(1)
4344
4345 async def f():
4346 return v
4347
4348 # Send in None to trigger initial execution of coroutine
4349 with self.assertRaises(StopIteration) as exc:
4350 f().send(None)
4351
4352 self.assertIs(exc.exception.value, v)
4353 self.assertEqual(exc.exception.args, (v,))
4354
4355 def test_coroutine_returning_tuple_passes_through_as_tuple(self):
4356 v = (1,)
4357
4358 async def f():
4359 return v
4360
4361 # Send in None to trigger initial execution of coroutine
4362 with self.assertRaises(StopIteration) as exc:
4363 f().send(None)
4364
4365 self.assertIs(exc.exception.value, v)
4366 self.assertEqual(exc.exception.args, (v,))
4367
4368 def test_coroutine_returning_tuple_sub_class_passes_through_unchanged(self):
4369 class NewTuple(tuple):
4370 pass
4371
4372 v = NewTuple()
4373
4374 async def f():
4375 return v
4376
4377 # Send in None to trigger initial execution of coroutine
4378 with self.assertRaises(StopIteration) as exc:
4379 f().send(None)
4380
4381 self.assertIs(exc.exception.value, v)
4382 self.assertEqual(exc.exception.args, (v,))
4383
4384 def test_coroutine_returning_arbitrary_exception_does_not_get_context_updated(self):
4385 value_error = ValueError()
4386
4387 async def f():
4388 nonlocal value_error
4389 return value_error
4390
4391 async def g():
4392 try:
4393 raise KeyError
4394 except KeyError:
4395 return await f()
4396
4397 self.assertIsNone(value_error.__context__)
4398 with self.assertRaises(StopIteration) as exc:
4399 g().send(None)
4400 self.assertIs(exc.exception.value, value_error)
4401 self.assertIsNone(exc.exception.value.__context__)
4402
4403
4404class CoroutineWrapperTests(unittest.TestCase):
4405 def test_dunder_iter_with_invalid_self_raises_type_error(self):
4406 async def f():
4407 pass
4408
4409 with contextlib.closing(f()) as g:
4410 with self.assertRaises(TypeError):
4411 type(g.__await__()).__iter__(None)
4412
4413 def test_dunder_next_with_invalid_self_raises_type_error(self):
4414 async def f():
4415 pass
4416
4417 with contextlib.closing(f()) as g:
4418 with self.assertRaises(TypeError):
4419 type(g.__await__()).__next__(None)
4420
4421 def test_close_with_invalid_self_raises_type_error(self):
4422 async def f():
4423 pass
4424
4425 with contextlib.closing(f()) as g:
4426 with self.assertRaises(TypeError):
4427 type(g.__await__()).close(None)
4428
4429 def test_send_with_invalid_self_raises_type_error(self):
4430 async def f():
4431 pass
4432
4433 with contextlib.closing(f()) as g:
4434 with self.assertRaises(TypeError):
4435 type(g.__await__()).send(None, None)
4436
4437 def test_throw_with_invalid_self_raises_type_error(self):
4438 async def f():
4439 pass
4440
4441 with contextlib.closing(f()) as g:
4442 with self.assertRaises(TypeError):
4443 type(g.__await__()).throw(None, None, None, None)
4444
4445 def test_dunder_iter_returns_self(self):
4446 async def f():
4447 pass
4448
4449 with contextlib.closing(f()) as g:
4450 wrapper = g.__await__()
4451 self.assertIs(wrapper.__iter__(), wrapper)
4452
4453 def test_dunder_next_raises_stop_iteration_with_yielded_value(self):
4454 async def f():
4455 return 1
4456
4457 with contextlib.closing(f()) as g:
4458 with self.assertRaises(StopIteration) as exc:
4459 g.__await__().__next__()
4460 self.assertEqual(exc.exception.value, 1)
4461
4462 def test_dunder_repr(self):
4463 async def f():
4464 return 1
4465
4466 with contextlib.closing(f()) as g:
4467 self.assertTrue(
4468 g.__await__().__repr__().startswith("<coroutine_wrapper object at ")
4469 )
4470
4471 def test_close_throws_in_generator_exit(self):
4472 saw_generator_exit = False
4473
4474 async def f():
4475 nonlocal saw_generator_exit
4476
4477 class Awaitable:
4478 def __await__(self):
4479 yield 1
4480
4481 try:
4482 await Awaitable()
4483 except GeneratorExit:
4484 saw_generator_exit = True
4485
4486 g = f()
4487 self.assertEqual(g.send(None), 1)
4488 g.__await__().close()
4489 self.assertTrue(saw_generator_exit)
4490
4491 def test_send_raises_stop_iteration_with_yielded_value(self):
4492 async def f():
4493 return 1
4494
4495 with contextlib.closing(f()) as g:
4496 with self.assertRaises(StopIteration) as exc:
4497 g.__await__().send(None)
4498 self.assertEqual(exc.exception.value, 1)
4499
4500 def test_throw_raises_in_generator(self):
4501 saw_value_error = False
4502
4503 async def f():
4504 nonlocal saw_value_error
4505
4506 class Awaitable:
4507 def __await__(self):
4508 yield 1
4509
4510 try:
4511 await Awaitable()
4512 except ValueError:
4513 saw_value_error = True
4514
4515 with contextlib.closing(f()) as g:
4516 self.assertEqual(g.send(None), 1)
4517 with self.assertRaises(StopIteration):
4518 g.__await__().throw(ValueError, None)
4519 self.assertTrue(saw_value_error)
4520
4521
4522class DelattrTests(unittest.TestCase):
4523 def test_non_str_as_name_raises_type_error(self):
4524 with self.assertRaises(TypeError) as context:
4525 delattr("str instance", None)
4526 self.assertIn(
4527 "attribute name must be string, not 'NoneType'", str(context.exception)
4528 )
4529
4530 def test_delete_non_existing_instance_attribute_raises_attribute_error(self):
4531 class C:
4532 fld = 4
4533
4534 c = C()
4535 with self.assertRaises(AttributeError):
4536 delattr(c, "fld")
4537
4538 def test_calls_dunder_delattr_and_returns_none_if_successful(self):
4539 class C:
4540 def __init__(self):
4541 self.fld = ""
4542
4543 def __delattr__(self, name):
4544 self.fld = name
4545 return "unused value"
4546
4547 c = C()
4548 self.assertIs(delattr(c, "passed to __delattr__"), None)
4549 self.assertEqual(c.fld, "passed to __delattr__")
4550
4551 def test_passes_exception_raised_by_dunder_delattr(self):
4552 class C:
4553 def __delattr__(self, name):
4554 raise UserWarning("delattr failed")
4555
4556 c = C()
4557 with self.assertRaises(UserWarning) as context:
4558 delattr(c, "foo")
4559 self.assertIn("delattr failed", str(context.exception))
4560
4561 def test_deletes_existing_instance_attribute(self):
4562 class C:
4563 def __init__(self):
4564 self.fld = 0
4565
4566 c = C()
4567 self.assertTrue(hasattr(c, "fld"))
4568 delattr(c, "fld")
4569 self.assertFalse(hasattr(c, "fld"))
4570
4571 def test_accepts_str_subclass_as_name(self):
4572 class C:
4573 def __init__(self):
4574 self.fld = 0
4575
4576 class S(str):
4577 pass
4578
4579 c = C()
4580 self.assertTrue(hasattr(c, "fld"))
4581 delattr(c, S("fld"))
4582 self.assertFalse(hasattr(c, "fld"))
4583
4584
4585class DirTests(unittest.TestCase):
4586 def test_without_args_returns_locals_keys(self):
4587 def foo():
4588 a = 4
4589 a = a # noqa: F841
4590 b = 5
4591 b = b # noqa: F841
4592 return dir()
4593
4594 result = foo()
4595 self.assertIsInstance(result, list)
4596 self.assertEqual(len(result), 2)
4597 self.assertEqual(result[0], "a")
4598 self.assertEqual(result[1], "b")
4599
4600 def test_with_arg_returns_dunder_dir_result(self):
4601 class C:
4602 def __dir__(self):
4603 return ["1", "2"]
4604
4605 c = C()
4606 self.assertEqual(dir(c), ["1", "2"])
4607
4608
4609class DunderBuildClassTests(unittest.TestCase):
4610 def test_bases_updated_with_dunder_mro_entries(self):
4611 observed_bases = []
4612
4613 class GenericAlias:
4614 def __init__(self, origin, item):
4615 self.origin = origin
4616 self.item = item
4617
4618 def __mro_entries__(self, bases):
4619 nonlocal observed_bases
4620 observed_bases.append(bases)
4621 return (self.origin,)
4622
4623 def __eq__(self, other):
4624 return self.origin == other.origin and self.item == other.item
4625
4626 class NewList:
4627 def __class_getitem__(cls, item):
4628 return GenericAlias(cls, item)
4629
4630 class NewTuple:
4631 def __class_getitem__(cls, item):
4632 return GenericAlias(cls, item)
4633
4634 class Tokens(NewList[int], NewTuple[float]):
4635 pass
4636
4637 self.assertIs(type(Tokens.__orig_bases__), tuple)
4638 self.assertEqual(Tokens.__orig_bases__, (NewList[int], NewTuple[float]))
4639 self.assertIs(type(Tokens.__bases__), tuple)
4640 self.assertEqual(Tokens.__bases__, (NewList, NewTuple))
4641 self.assertEqual(Tokens.__mro__, (Tokens, NewList, NewTuple, object))
4642
4643 self.assertEqual(observed_bases, [Tokens.__orig_bases__, Tokens.__orig_bases__])
4644
4645 def test_bases_with_non_class_invokes_metaclass(self):
4646 class Meta: # noqa: B903
4647 def __init__(self, *args, **kwargs):
4648 self.init_args = args
4649 self.init_kwargs = kwargs
4650
4651 pseudo_type = Meta()
4652
4653 class C(pseudo_type):
4654 pass
4655
4656 self.assertIsInstance(C, Meta)
4657 self.assertIsNot(C, pseudo_type)
4658 self.assertEqual(len(C.init_args), 3)
4659 self.assertEqual(C.init_args[0], "C")
4660 self.assertEqual(C.init_args[1], (pseudo_type,))
4661 self.assertIsInstance(C.init_args[2], dict)
4662 self.assertEqual(C.init_kwargs, {})
4663
4664 def test_exceptions_propagated_from_dunder_mro_entries(self):
4665 class GenericAlias:
4666 def __init__(self, origin, item):
4667 pass
4668
4669 def __mro_entries__(self, bases):
4670 raise UserWarning("GenericAlias.__mro__entries__")
4671
4672 class NewList:
4673 def __class_getitem__(cls, item):
4674 return GenericAlias(cls, item)
4675
4676 class NewTuple:
4677 def __class_getitem__(cls, item):
4678 return GenericAlias(cls, item)
4679
4680 with self.assertRaises(UserWarning) as context:
4681
4682 class Tokens(NewList[int]):
4683 pass
4684
4685 self.assertIn("GenericAlias.__mro__entries__", str(context.exception))
4686
4687
4688class EllipsisTypeTests(unittest.TestCase):
4689 def test_repr_returns_not_implemented(self):
4690 self.assertEqual(Ellipsis.__repr__(), "Ellipsis")
4691
4692
4693class ExceptionTests(unittest.TestCase):
4694 def test_oserror_with_errno_enoent_returns_file_not_found_error(self):
4695 result = OSError(errno.ENOENT, "foo", "bar.py")
4696 self.assertIsInstance(result, FileNotFoundError)
4697 self.assertEqual(result.errno, errno.ENOENT)
4698 self.assertEqual(result.strerror, "foo")
4699 self.assertEqual(result.filename, "bar.py")
4700
4701 def test_oserror_with_not_whitelisted_errno_returns_os_error(self):
4702 result = OSError(999, "foo", "bar.py")
4703 self.assertIsInstance(result, OSError)
4704 self.assertEqual(result.errno, 999)
4705 self.assertEqual(result.strerror, "foo")
4706 self.assertEqual(result.filename, "bar.py")
4707
4708 def test_oserror_with_errno_eacces_returns_permission_error(self):
4709 result = OSError(errno.EACCES, "foo", "bar.py")
4710 self.assertIsInstance(result, PermissionError)
4711
4712 def test_oserror_with_errno_eagain_returns_blocking_io_error(self):
4713 result = OSError(errno.EAGAIN, "foo", "bar.py")
4714 self.assertIsInstance(result, BlockingIOError)
4715
4716 def test_oserror_with_errno_ealready_returns_blocking_io_error(self):
4717 result = OSError(errno.EALREADY, "foo", "bar.py")
4718 self.assertIsInstance(result, BlockingIOError)
4719
4720 def test_oserror_with_errno_einprogress_returns_blocking_io_error(self):
4721 result = OSError(errno.EINPROGRESS, "foo", "bar.py")
4722 self.assertIsInstance(result, BlockingIOError)
4723
4724 def test_oserror_with_errno_echild_returns_child_process_error(self):
4725 result = OSError(errno.ECHILD, "foo", "bar.py")
4726 self.assertIsInstance(result, ChildProcessError)
4727
4728 def test_oserror_with_errno_econnaborted_returns_connection_aborted_error(self):
4729 result = OSError(errno.ECONNABORTED, "foo", "bar.py")
4730 self.assertIsInstance(result, ConnectionAbortedError)
4731
4732 def test_oserror_with_errno_econnrefused_returns_connection_refused_error(self):
4733 result = OSError(errno.ECONNREFUSED, "foo", "bar.py")
4734 self.assertIsInstance(result, ConnectionRefusedError)
4735
4736 def test_oserror_with_errno_econnreset_returns_connection_reset_error(self):
4737 result = OSError(errno.ECONNRESET, "foo", "bar.py")
4738 self.assertIsInstance(result, ConnectionResetError)
4739
4740 def test_oserror_with_errno_eexist_returns_file_exists_error(self):
4741 result = OSError(errno.EEXIST, "foo", "bar.py")
4742 self.assertIsInstance(result, FileExistsError)
4743
4744 def test_oserror_with_errno_eintr_returns_interrupted_error(self):
4745 result = OSError(errno.EINTR, "foo", "bar.py")
4746 self.assertIsInstance(result, InterruptedError)
4747
4748 def test_oserror_with_errno_eisdir_returns_is_a_directory_error(self):
4749 result = OSError(errno.EISDIR, "foo", "bar.py")
4750 self.assertIsInstance(result, IsADirectoryError)
4751
4752 def test_oserror_with_errno_enotdir_returns_not_a_directory_error(self):
4753 result = OSError(errno.ENOTDIR, "foo", "bar.py")
4754 self.assertIsInstance(result, NotADirectoryError)
4755
4756 def test_oserror_with_errno_eperm_returns_permission_error(self):
4757 result = OSError(errno.EPERM, "foo", "bar.py")
4758 self.assertIsInstance(result, PermissionError)
4759
4760 def test_oserror_with_errno_epipe_returns_broken_pipe_error(self):
4761 result = OSError(errno.EPIPE, "foo", "bar.py")
4762 self.assertIsInstance(result, BrokenPipeError)
4763
4764 def test_oserror_with_esrch_returns_process_lookup_error(self):
4765 result = OSError(errno.ESRCH, "foo", "bar.py")
4766 self.assertIsInstance(result, ProcessLookupError)
4767
4768 def test_oserror_with_errno_etimedout_returns_timeout_error(self):
4769 result = OSError(errno.ETIMEDOUT, "foo", "bar.py")
4770 self.assertIsInstance(result, TimeoutError)
4771
4772 def test_oserror_with_errno_ewouldblock_returns_blocking_io_error(self):
4773 result = OSError(errno.EWOULDBLOCK, "foo", "bar.py")
4774 self.assertIsInstance(result, BlockingIOError)
4775
4776 def test_oserror_dunder_new_with_subclass_return_subclass_instance(self):
4777 result = OSError.__new__(FileNotFoundError)
4778 self.assertIsInstance(result, FileNotFoundError)
4779
4780 def test_oserror_dunder_init_with_no_args_does_not_set_attrs(self):
4781 exc = OSError()
4782 self.assertIs(exc.errno, None)
4783 self.assertIs(exc.strerror, None)
4784 self.assertIs(exc.filename, None)
4785 self.assertIs(exc.filename2, None)
4786
4787 def test_oserror_dunder_init_with_args_sets_attrs(self):
4788 exc = OSError(1, "some error", "file", 0, "file2")
4789 self.assertIs(exc.errno, 1)
4790 self.assertIs(exc.strerror, "some error")
4791 self.assertIs(exc.filename, "file")
4792 self.assertIs(exc.filename2, "file2")
4793
4794 def test_oserror_dunder_str_without_errno_or_strerror(self):
4795 exc = OSError()
4796 self.assertEqual(OSError.__str__(exc), "")
4797
4798 exc = OSError(999)
4799 self.assertEqual(OSError.__str__(exc), "999")
4800
4801 def test_oserror_dunder_str_without_filename(self):
4802 exc = OSError(999, "some error")
4803 self.assertEqual(OSError.__str__(exc), "[Errno 999] some error")
4804
4805 def test_oserror_dunder_str_with_filename(self):
4806 exc = OSError(999, "some error", "file")
4807 self.assertEqual(OSError.__str__(exc), "[Errno 999] some error: 'file'")
4808
4809 def test_oserror_dunder_str_with_filename_and_filename2(self):
4810 exc = OSError(999, "some error", "file", 0, "file2")
4811 self.assertEqual(
4812 OSError.__str__(exc), "[Errno 999] some error: 'file' -> 'file2'"
4813 )
4814
4815 def test_maybe_unbound_attributes(self):
4816 exc = BaseException()
4817 exc2 = BaseException()
4818 self.assertIs(exc.__cause__, None)
4819 self.assertIs(exc.__context__, None)
4820 self.assertIs(exc.__traceback__, None)
4821
4822 # Test setter for __cause__.
4823 self.assertRaises(TypeError, setattr, exc, "__cause__", 123)
4824 exc.__cause__ = exc2
4825 self.assertIs(exc.__cause__, exc2)
4826 exc.__cause__ = None
4827 self.assertIs(exc.__cause__, None)
4828
4829 # Test setter for __context__.
4830 self.assertRaises(TypeError, setattr, exc, "__context__", 456)
4831 exc.__context__ = exc2
4832 self.assertIs(exc.__context__, exc2)
4833 exc.__context__ = None
4834 self.assertIs(exc.__context__, None)
4835
4836 # Test setter for __traceback__.
4837 self.assertRaises(TypeError, setattr, "__traceback__", "some string")
4838 # TODO(bsimmers): Set a real traceback once we support them.
4839 exc.__traceback__ = None
4840 self.assertIs(exc.__traceback__, None)
4841
4842 def test_context_chaining(self):
4843 inner_exc = None
4844 outer_exc = None
4845 try:
4846 try:
4847 raise RuntimeError("whoops")
4848 except RuntimeError as exc:
4849 inner_exc = exc
4850 raise TypeError("darn")
4851 except TypeError as exc:
4852 outer_exc = exc
4853
4854 self.assertIsInstance(inner_exc, RuntimeError)
4855 self.assertIsInstance(outer_exc, TypeError)
4856 self.assertIs(outer_exc.__context__, inner_exc)
4857 self.assertIsNone(inner_exc.__context__)
4858
4859 def test_context_chaining_cycle_avoidance(self):
4860 exc0 = None
4861 exc1 = None
4862 exc2 = None
4863 exc3 = None
4864 try:
4865 try:
4866 try:
4867 try:
4868 raise RuntimeError("inner")
4869 except RuntimeError as exc:
4870 exc0 = exc
4871 raise RuntimeError("middle")
4872 except RuntimeError as exc:
4873 exc1 = exc
4874 raise RuntimeError("outer")
4875 except RuntimeError as exc:
4876 exc2 = exc
4877 # The __context__ link between exc1 and exc0 should be broken
4878 # by this raise.
4879 raise exc0
4880 except RuntimeError as exc:
4881 exc3 = exc
4882
4883 self.assertIs(exc3, exc0)
4884 self.assertIs(exc3.__context__, exc2)
4885 self.assertIs(exc2.__context__, exc1)
4886 self.assertIs(exc1.__context__, None)
4887
4888 def test_dunder_dict_doesnt_expose_dunder_attrs(self):
4889 instance_dict = Exception().__dict__
4890 self.assertFalse(hasattr(instance_dict, "__cause__"))
4891 self.assertFalse(hasattr(instance_dict, "__context__"))
4892 self.assertFalse(hasattr(instance_dict, "__traceback__"))
4893
4894 def test_reraise_exception_appends_traceback(self):
4895 def raise_exc():
4896 raise ValueError("Hello")
4897
4898 def reraise():
4899 try:
4900 raise_exc()
4901 except ValueError as e:
4902 raise e
4903
4904 def catch():
4905 try:
4906 reraise()
4907 except Exception as e:
4908 tb = e.__traceback__
4909 frames = []
4910 while tb is not None:
4911 frames.append(tb.tb_frame)
4912 tb = tb.tb_next
4913 return frames
4914
4915 frames = catch()
4916 names = [frame.f_code.co_name for frame in frames]
4917 self.assertIn("catch", names)
4918 self.assertIn("reraise", names)
4919 self.assertIn("raise_exc", names)
4920
4921 def test_with_traceback_sets_none_as_dunder_traceback(self):
4922 e = BaseException()
4923 self.assertIs(e, e.with_traceback(None))
4924 self.assertIs(e.__traceback__, None)
4925
4926 def test_with_traceback_sets_traceback_as_dunder_traceback(self):
4927 traceback_obj = None
4928 try:
4929 raise Exception("test")
4930 except Exception as e:
4931 traceback_obj = e.__traceback__
4932 self.assertIsNot(traceback_obj, None)
4933
4934 e = BaseException()
4935 self.assertIs(e, e.with_traceback(traceback_obj))
4936 self.assertIs(e.__traceback__, traceback_obj)
4937
4938 def test_with_traceback_with_non_traceback_raises_type_error(self):
4939 e = BaseException()
4940 with self.assertRaises(TypeError):
4941 e.with_traceback("not_a_traceback_obj")
4942
4943 def test_system_exit_with_value_sets_code(self):
4944 exc = SystemExit(1111)
4945 self.assertEqual(exc.code, 1111)
4946
4947 def test_set_name_attr_on_import_error_subclass_with_property_sets_attr(self):
4948 class C(ModuleNotFoundError):
4949 # Modeled after PackageNotFoundError in
4950 # importlib_metadata/__init__.py
4951 @property
4952 def name(self):
4953 (name,) = self.args
4954 return name
4955
4956 c = C("a name")
4957 self.assertEqual(c.name, "a name")
4958 self.assertEqual(c.path, None)
4959
4960 def test_set_path_attr_on_import_error_subclass_with_property_sets_attr(self):
4961 class C(ModuleNotFoundError):
4962 # Modeled after PackageNotFoundError in
4963 # importlib_metadata/__init__.py
4964 @property
4965 def path(self):
4966 (path,) = self.args
4967 return path
4968
4969 c = C("a path")
4970 self.assertEqual(c.name, None)
4971 self.assertEqual(c.path, "a path")
4972
4973
4974class EvalTests(unittest.TestCase):
4975 def test_globals_none_accesses_function_globals(self):
4976 from types import ModuleType
4977
4978 module = ModuleType("")
4979 exec("def foo(): return eval('globals(), locals()', None, {})", module.__dict__)
4980 eval_globals, eval_locals = module.foo()
4981 self.assertIs(eval_globals, module.__dict__)
4982 self.assertEqual(eval_locals, {})
4983
4984 def test_globals_and_locals_none_accesses_function_locals(self):
4985 from types import ModuleType
4986
4987 module = ModuleType("")
4988 exec(
4989 "def foo(): bar = 42; return eval('globals(), locals(), bar', None, None)",
4990 module.__dict__,
4991 )
4992 eval_globals, eval_locals, bar = module.foo()
4993 self.assertIs(eval_globals, module.__dict__)
4994 self.assertEqual(eval_locals, {"bar": 42})
4995 self.assertEqual(bar, 42)
4996
4997 def test_globals_and_locals_none_accesses_implicit_globals(self):
4998 class C:
4999 foo = 42
5000 globals, locals = eval("globals(), locals()", None, None)
5001
5002 self.assertIs(C.globals, globals())
5003 self.assertIn("foo", C.locals)
5004 self.assertEqual(C.locals["foo"], 42)
5005
5006 def test_locals_none_accesses_globals(self):
5007 from types import ModuleType
5008
5009 module = ModuleType("")
5010 module.foo = 42
5011 eval_globals, eval_locals = eval("globals(), locals()", module.__dict__, None)
5012 self.assertIs(eval_globals, module.__dict__)
5013 self.assertIs(eval_locals, module.__dict__)
5014
5015 def test_builtins_is_added(self):
5016 import builtins
5017
5018 globals = {}
5019 exec("", globals, globals)
5020 self.assertIn("__builtins__", globals)
5021 self.assertIs(globals["__builtins__"], builtins.__dict__)
5022
5023 def test_bytes_source(self):
5024 self.assertEqual(eval(b"4 * 5"), 20) # noqa: P204
5025
5026 def test_bytearray_source(self):
5027 self.assertEqual(eval(bytearray(b"20 / 5")), 4) # noqa: P204
5028
5029 def test_str_with_left_whitespace_returns(self):
5030 res = eval(" 1 + 1")
5031 self.assertEqual(res, 2)
5032
5033 def test_bytes_with_left_whitespace_returns(self):
5034 res = eval(b" 1 + 1") # noqa: P204
5035 self.assertEqual(res, 2)
5036
5037 def test_bytearray_with_left_whitespace_returns(self):
5038 res = eval(bytearray(b" 1 + 1")) # noqa: P204
5039 self.assertEqual(res, 2)
5040
5041 def test_str_with_right_whitespace_returns(self):
5042 res = eval("1 + 1 ")
5043 self.assertEqual(res, 2)
5044
5045 def test_bytes_with_right_whitespace_returns(self):
5046 res = eval(b"1 + 1 ") # noqa: P204
5047 self.assertEqual(res, 2)
5048
5049 def test_bytearray_with_left_whitespace_returns(self):
5050 res = eval(bytearray(b"1 + 1 ")) # noqa: P204
5051 self.assertEqual(res, 2)
5052
5053 def test_code_source(self):
5054 from types import CodeType
5055
5056 code = compile("20 - 4", "", "eval", 0, True, -1)
5057 self.assertIsInstance(code, CodeType)
5058 self.assertEqual(eval(code), 16) # noqa: P204
5059
5060 # TODO(T78726269): Investigate why this test fails
5061 @cpython_only
5062 def test_inherits_compile_flags(self):
5063 import __future__
5064
5065 from types import CodeType
5066
5067 code = compile(
5068 "eval('8 <> 9')", "", "eval", __future__.CO_FUTURE_BARRY_AS_BDFL, True, -1
5069 )
5070 self.assertIsInstance(code, CodeType)
5071 self.assertTrue(code.co_flags & __future__.CO_FUTURE_BARRY_AS_BDFL != 0)
5072 self.assertTrue(eval(code)) # noqa: P204
5073
5074 def test_int_source_raises_type_error(self):
5075 with self.assertRaises(TypeError):
5076 eval(123)
5077
5078 def test_non_dict_globals_raise_type_error(self):
5079 with self.assertRaises(TypeError):
5080 eval("0", "not a dict")
5081
5082 class Mapping:
5083 def __setitem__(self, key, name):
5084 pass
5085
5086 def __getitem__(self, key):
5087 pass
5088
5089 with self.assertRaises(TypeError):
5090 eval("0", Mapping())
5091
5092 def test_non_mapping_locals_raises_type_error(self):
5093 with self.assertRaises(TypeError):
5094 not_a_mapping = 42.4
5095 eval("0", None, not_a_mapping)
5096
5097 def test_code_with_freevars_raises_type_error(self):
5098 def func(x):
5099 return lambda: x
5100
5101 code = func(42).__code__
5102 with self.assertRaisesRegex(TypeError, "may not contain free variables"):
5103 eval(code) # noqa: P204
5104
5105 def test_globals_dict_reads_dict(self):
5106 d = {"a": 1}
5107 res = eval("a + 1", d)
5108 self.assertEqual(res, 2)
5109
5110 def test_globals_dict_updates_dict(self):
5111 d = {"a": 1}
5112 code = compile("a = 2", "<string>", "exec")
5113 eval(code, d) # noqa: P204
5114 self.assertEqual(d["a"], 2)
5115
5116 def test_instance_has_dunder_dict(self):
5117 instance = Exception()
5118 self.assertTrue(hasattr(instance, "__dict__"))
5119 instance.foo = "bar"
5120 self.assertEqual(instance.__dict__["foo"], "bar")
5121
5122 def test_subclass_instance_has_dunder_dict(self):
5123 class ExceptionSub(Exception):
5124 def __init__(self):
5125 self.foo = "bar"
5126
5127 instance = ExceptionSub()
5128 self.assertEqual(instance.__dict__["foo"], "bar")
5129
5130
5131class ExecTests(unittest.TestCase):
5132 def test_globals_none_accesses_function_globals(self):
5133 from types import ModuleType
5134
5135 module = ModuleType("")
5136 module.foo = 42
5137 module.locals = {}
5138 exec("exec('result = foo', None, locals)", module.__dict__)
5139 self.assertIn("result", module.locals)
5140 self.assertEqual(module.locals["result"], 42)
5141
5142 def test_globals_and_locals_none_accesses_function_locals(self):
5143 def f():
5144 foo = 42 # noqa: F841
5145 result = []
5146 exec("result.append(foo)", None, None)
5147 return result
5148
5149 self.assertEqual(f(), [42])
5150
5151 def test_globals_and_locals_none_accesses_implicit_globals(self):
5152 class C:
5153 foo = 42
5154 exec("result = foo", None, None)
5155
5156 self.assertTrue(hasattr(C, "result"))
5157 self.assertEqual(C.result, 42)
5158
5159 def test_locals_none_accesses_globals(self):
5160 from types import ModuleType
5161
5162 module = ModuleType("")
5163 module.foo = 42
5164 exec("result = foo", module.__dict__, None)
5165 self.assertTrue(hasattr(module, "result"))
5166 self.assertEqual(module.result, 42)
5167
5168 def test_bytes_source(self):
5169 from types import ModuleType
5170
5171 module = ModuleType("")
5172 module.foo = 13
5173 exec(b"result = foo", module.__dict__, None)
5174 self.assertTrue(hasattr(module, "result"))
5175 self.assertEqual(module.result, 13)
5176
5177 def test_bytearray_source(self):
5178 from types import ModuleType
5179
5180 module = ModuleType("")
5181 module.foo = 7
5182 exec(bytearray(b"result = foo"), module.__dict__, None)
5183 self.assertTrue(hasattr(module, "result"))
5184 self.assertEqual(module.result, 7)
5185
5186 def test_code_source(self):
5187 from types import CodeType
5188 from types import ModuleType
5189
5190 code = compile("result = foo", "", "exec", 0, True, -1)
5191 self.assertIsInstance(code, CodeType)
5192 module = ModuleType("")
5193 module.foo = 99
5194 self.assertIs(exec(code, module.__dict__), None)
5195 self.assertEqual(module.result, 99)
5196
5197 def test_inherits_compile_flags(self):
5198 import __future__
5199
5200 from types import CodeType
5201 from types import ModuleType
5202
5203 code = compile(
5204 "result0 = 4 <> 4\nexec('result1 = 8 <> 9')",
5205 "",
5206 "exec",
5207 __future__.CO_FUTURE_BARRY_AS_BDFL,
5208 True,
5209 -1,
5210 )
5211 self.assertIsInstance(code, CodeType)
5212 self.assertTrue(code.co_flags & __future__.CO_FUTURE_BARRY_AS_BDFL != 0)
5213 module = ModuleType("")
5214 self.assertIs(exec(code, module.__dict__), None)
5215 self.assertFalse(module.result0)
5216 self.assertTrue(module.result1)
5217
5218 def test_int_source_raises_type_error(self):
5219 with self.assertRaises(TypeError):
5220 exec(123)
5221
5222 def test_non_dict_globals_raise_type_error(self):
5223 with self.assertRaises(TypeError):
5224 exec("pass", "not a dict")
5225
5226 class Mapping:
5227 def __setitem__(self, key, name):
5228 pass
5229
5230 def __getitem__(self, key):
5231 pass
5232
5233 with self.assertRaises(TypeError):
5234 exec("pass", Mapping())
5235
5236 def test_non_mapping_locals_raises_type_error(self):
5237 with self.assertRaises(TypeError):
5238 not_a_mapping = 42.4
5239 exec("pass", None, not_a_mapping)
5240
5241 def test_code_with_freevars_raises_type_error(self):
5242 def func(x):
5243 return lambda: x
5244
5245 code = func(42).__code__
5246 with self.assertRaisesRegex(TypeError, "may not contain free variables"):
5247 exec(code)
5248
5249 def test_globals_dict_reads_dict(self):
5250 d = {"a": 1}
5251 exec("b = a + 1", d)
5252 self.assertEqual(d["b"], 2)
5253
5254 def test_globals_dict_updates_dict(self):
5255 d = {"a": 1}
5256 exec("a = 2", d)
5257 self.assertEqual(d["a"], 2)
5258
5259 def test_coroutine_returning_arbitrary_exception_passes_through_unchanged(self):
5260 v = RuntimeError("banana")
5261
5262 async def f():
5263 return v
5264
5265 # Send in None to trigger initial execution of coroutine
5266 with self.assertRaises(StopIteration) as exc:
5267 f().send(None)
5268
5269 self.assertIs(exc.exception.value, v)
5270 self.assertEqual(exc.exception.args, (v,))
5271
5272
5273class FormatTests(unittest.TestCase):
5274 def test_format_calls_types_dunder_format(self):
5275 class Format:
5276 def __format__(self, str):
5277 return "Class"
5278
5279 template = "{}"
5280 self.assertEqual(template.format(1), "1")
5281 self.assertEqual(template.format(int), "<class 'int'>")
5282 instance = Format()
5283 instance.__format__ = lambda *args: "instance"
5284 self.assertEqual(template.format(Format()), "Class")
5285 self.assertEqual(template.format(instance), "Class")
5286
5287
5288class FrozensetTests(unittest.TestCase):
5289 def test_deepcopy_with_frozenset_returns_frozenset(self):
5290 s = frozenset([1, 2, 3])
5291 self.assertEqual(s, copy.deepcopy(s))
5292
5293 def test_deepcopy_with_frozenset_subclass_returns_subclass(self):
5294 class C(frozenset):
5295 pass
5296
5297 s = C([1, 2, 3])
5298 self.assertEqual(s, copy.deepcopy(s))
5299
5300 def test_dunder_and_with_non_frozenset_raises_type_error(self):
5301 with self.assertRaises(TypeError):
5302 frozenset.__and__(set(), frozenset())
5303
5304 def test_dunder_hash_returns_int(self):
5305 self.assertEqual(frozenset.__hash__(frozenset()), 133146708735736)
5306 self.assertEqual(frozenset.__hash__(frozenset((1, 2, 3))), -272375401224217160)
5307
5308 def test_dunder_new_with_failing_iterable_propagates_error(self):
5309 class C:
5310 def __iter__(self):
5311 return self
5312
5313 def __next__(self):
5314 raise RuntimeError("foo")
5315
5316 with self.assertRaises(RuntimeError) as context:
5317 frozenset(C())
5318 self.assertEqual(str(context.exception), "foo")
5319
5320 def test_dunder_new_with_subclass_and_iterable_creates_instance_of_subclass(self):
5321 class Bad:
5322 def __iter__(self):
5323 return self
5324
5325 def __next__(self):
5326 raise RuntimeError("foo")
5327
5328 class C(frozenset):
5329 pass
5330
5331 with self.assertRaises(RuntimeError) as context:
5332 frozenset.__new__(frozenset, Bad())
5333 self.assertEqual(str(context.exception), "foo")
5334
5335 result = frozenset.__new__(C, [1, 2, 3])
5336 self.assertIsInstance(result, C)
5337
5338 def test_dunder_or_with_non_frozenset_self_raises_type_error(self):
5339 with self.assertRaises(TypeError):
5340 frozenset.__or__(set(), frozenset())
5341
5342 def test_dunder_or_with_missing_other_raises_type_error(self):
5343 with self.assertRaises(TypeError):
5344 frozenset.__or__(frozenset())
5345
5346 def test_dunder_or_with_non_anyset_other_returns_notimplemented(self):
5347 self.assertIs(frozenset.__or__(frozenset(), []), NotImplemented)
5348
5349 def test_dunder_or_with_id_equal_self_and_other_returns_self_copy(self):
5350 left = frozenset((1, 2, 3))
5351 result = left.__or__(left)
5352 self.assertIsInstance(result, frozenset)
5353 self.assertIsNot(result, left)
5354 self.assertEqual(result, left)
5355
5356 def test_dunder_or_returns_union(self):
5357 left = frozenset((1, 2, 3))
5358 result = left.__or__({2, 3, 4})
5359 self.assertIsInstance(result, frozenset)
5360 self.assertEqual(result, frozenset((1, 2, 3, 4)))
5361
5362 def test_dunder_or_with_empty_left_returns_elements_from_right(self):
5363 result = frozenset().__or__({2, 3, 4})
5364 self.assertIsInstance(result, frozenset)
5365 self.assertEqual(result, frozenset((2, 3, 4)))
5366
5367 def test_dunder_or_with_empty_right_returns_elements_from_left(self):
5368 result = frozenset((1, 2, 3)).__or__(set())
5369 self.assertIsInstance(result, frozenset)
5370 self.assertEqual(result, frozenset((1, 2, 3)))
5371
5372 def test_dunder_or_with_empty_left_and_right_returns_empty_frozenset(self):
5373 empty = frozenset()
5374 result = empty.__or__(set())
5375 self.assertIsInstance(result, frozenset)
5376 self.assertIsNot(result, empty)
5377 self.assertEqual(result, frozenset())
5378
5379 def test_dunder_or_with_subclass_returns_exact_frozenset(self):
5380 class C(frozenset):
5381 pass
5382
5383 left = C()
5384 right = C()
5385 self.assertIs(type(left | right), frozenset)
5386 self.assertIs(type(left | left), frozenset)
5387
5388 def test_dunder_reduce_with_frozenset_returns_tuple(self):
5389 a_frozenset = frozenset({1, 2, 3})
5390 result = a_frozenset.__reduce__()
5391 cls, value, state = result
5392 self.assertEqual(type(result), tuple)
5393 self.assertEqual(type(cls), type)
5394 self.assertEqual(cls, frozenset)
5395 self.assertEqual(type(value), tuple)
5396 self.assertEqual(len(value), 1)
5397 self.assertEqual(value[0], [1, 2, 3])
5398 self.assertEqual(state, None)
5399
5400 def test_dunder_reduce_with_frozenset_subclass_returns_tuple(self):
5401 class C(frozenset):
5402 pass
5403
5404 c = C({1, 2, 3})
5405 c.test_value = "test_value"
5406 result = c.__reduce__()
5407 cls, value, state = result
5408 self.assertEqual(type(result), tuple)
5409 self.assertEqual(type(cls), type)
5410 self.assertEqual(cls, C)
5411 self.assertEqual(type(value), tuple)
5412 self.assertEqual(len(value), 1)
5413 self.assertEqual(type(value[0]), list)
5414 self.assertEqual(value[0], [1, 2, 3])
5415 self.assertEqual(len(state), 1)
5416 self.assertEqual(state["test_value"], "test_value")
5417
5418 def test_dunder_repr_with_non_frozenset_self_raises_type_error(self):
5419 with self.assertRaises(TypeError):
5420 frozenset.difference(set())
5421
5422 def test_dunder_repr_with_empty_frozenset(self):
5423 self.assertEqual(frozenset().__repr__(), "frozenset()")
5424
5425 def test_dunder_repr_with_non_empty_frozenset(self):
5426 self.assertEqual(frozenset({1, 2, 3}).__repr__(), "frozenset({1, 2, 3})")
5427
5428 def test_dunder_repr_with_subclass_prints_subclass_name(self):
5429 class C(frozenset):
5430 pass
5431
5432 self.assertEqual(C().__repr__(), "C()")
5433 self.assertEqual(C({1, 2, 3}).__repr__(), "C({1, 2, 3})")
5434
5435 def test_dunder_repr_with_recursive_frozenset_prints_ellipsis(self):
5436 class C:
5437 def __init__(self):
5438 self.value = frozenset((self,))
5439
5440 def __hash__(self):
5441 return 1
5442
5443 def __repr__(self):
5444 return self.value.__repr__()
5445
5446 self.assertEqual(C().__repr__(), "frozenset({frozenset(...)})")
5447
5448 def test_dunder_sub_with_non_frozenset_self_raises_type_error(self):
5449 with self.assertRaises(TypeError):
5450 frozenset.__sub__(set(), frozenset())
5451
5452 def test_dunder_sub_same_frozensets_returns_empty_frozenset(self):
5453 a_frozenset = frozenset({1, 2, 3})
5454 self.assertFalse(frozenset.__sub__(a_frozenset, a_frozenset))
5455
5456 def test_dunder_sub_two_frozensets_returns_difference(self):
5457 frozenset1 = frozenset({1, 2, 3, 4, 5, 6, 7})
5458 frozenset2 = frozenset({1, 3, 5, 7})
5459 self.assertEqual(frozenset.__sub__(frozenset1, frozenset2), {2, 4, 6})
5460
5461 def test_dunder_sub_set_from_frozenset_returns_difference(self):
5462 frozenset1 = frozenset({1, 2, 3, 4, 5, 6, 7})
5463 set2 = set({1, 3, 5, 7})
5464 self.assertEqual(frozenset.__sub__(frozenset1, set2), {2, 4, 6})
5465
5466 def test_copy_with_non_frozenset_self_raises_type_error(self):
5467 self.assertRaisesRegex(
5468 TypeError,
5469 "'copy' .* 'frozenset' object.* a 'set'",
5470 frozenset.copy,
5471 set(),
5472 )
5473
5474 def test_difference_with_non_frozenset_self_raises_type_error(self):
5475 with self.assertRaises(TypeError):
5476 frozenset.difference(set(), frozenset())
5477
5478 def test_difference_no_others_copies_self(self):
5479 a_frozenset = frozenset({1, 2, 3})
5480 self.assertIsNot(frozenset.difference(a_frozenset), a_frozenset)
5481
5482 def test_difference_same_frozensets_returns_empty_frozenset(self):
5483 a_frozenset = frozenset({1, 2, 3})
5484 self.assertFalse(frozenset.difference(a_frozenset, a_frozenset))
5485
5486 def test_difference_two_frozensets_returns_difference(self):
5487 frozenset1 = frozenset({1, 2, 3, 4, 5, 6, 7})
5488 frozenset2 = frozenset({1, 3, 5, 7})
5489 self.assertEqual(frozenset.difference(frozenset1, frozenset2), {2, 4, 6})
5490
5491 def test_difference_many_frozensets_returns_difference(self):
5492 a_frozenset = frozenset({1, 10, 100, 1000})
5493 self.assertEqual(frozenset.difference(a_frozenset, {10}, {100}, {1000}), {1})
5494
5495 def test_issuperset_with_non_frozenset_raises_type_error(self):
5496 with self.assertRaises(TypeError):
5497 frozenset.issuperset(None, frozenset())
5498
5499 def test_issuperset_with_set_raises_type_error(self):
5500 with self.assertRaises(TypeError):
5501 frozenset.issuperset(set(), frozenset())
5502
5503 def test_issuperset_with_empty_sets_returns_true(self):
5504 self.assertTrue(frozenset.issuperset(frozenset(), frozenset()))
5505 self.assertTrue(frozenset.issuperset(frozenset(), set()))
5506
5507 def test_issuperset_with_anyset_subset_returns_true(self):
5508 self.assertTrue(frozenset({1}).issuperset(set()))
5509 self.assertTrue(frozenset({1}).issuperset(frozenset()))
5510
5511 self.assertTrue(frozenset({1}).issuperset({1}))
5512 self.assertTrue(frozenset({1}).issuperset(frozenset({1})))
5513
5514 self.assertTrue(frozenset({1, 2}).issuperset({1}))
5515 self.assertTrue(frozenset({1, 2}).issuperset(frozenset({1})))
5516
5517 self.assertTrue(frozenset({1, 2}).issuperset({1, 2}))
5518 self.assertTrue(frozenset({1, 2}).issuperset(frozenset({1, 2})))
5519
5520 self.assertTrue(frozenset({1, 2, 3}).issuperset({1, 2}))
5521 self.assertTrue(frozenset({1, 2, 3}).issuperset(frozenset({1, 2})))
5522
5523 def test_issuperset_with_iterable_subset_returns_true(self):
5524 self.assertTrue(frozenset({1}).issuperset([]))
5525 self.assertTrue(frozenset({1}).issuperset(range(1, 1)))
5526
5527 self.assertTrue(frozenset({1}).issuperset([1]))
5528 self.assertTrue(frozenset({1}).issuperset(range(1, 2)))
5529
5530 self.assertTrue(frozenset({1, 2}).issuperset([1]))
5531 self.assertTrue(frozenset({1, 2}).issuperset(range(1, 2)))
5532
5533 self.assertTrue(frozenset({1, 2}).issuperset([1, 2]))
5534 self.assertTrue(frozenset({1, 2}).issuperset(range(1, 3)))
5535
5536 self.assertTrue(frozenset({1, 2, 3}).issuperset([1, 2]))
5537 self.assertTrue(frozenset({1, 2, 3}).issuperset(range(1, 3)))
5538
5539 def test_issuperset_with_superset_returns_false(self):
5540 self.assertFalse(frozenset({}).issuperset({1}))
5541 self.assertFalse(frozenset({}).issuperset(frozenset({1})))
5542 self.assertFalse(frozenset({}).issuperset([1]))
5543 self.assertFalse(frozenset({}).issuperset(range(1, 2)))
5544
5545 self.assertFalse(frozenset({1}).issuperset({1, 2}))
5546 self.assertFalse(frozenset({1}).issuperset(frozenset({1, 2})))
5547 self.assertFalse(frozenset({1}).issuperset([1, 2]))
5548 self.assertFalse(frozenset({1}).issuperset(range(1, 3)))
5549
5550 self.assertFalse(frozenset({1, 2}).issuperset({1, 2, 3}))
5551 self.assertFalse(frozenset({1, 2}).issuperset(frozenset({1, 2, 3})))
5552 self.assertFalse(frozenset({1, 2}).issuperset([1, 2, 3]))
5553 self.assertFalse(frozenset({1, 2}).issuperset(range(1, 4)))
5554
5555 def test_union_with_non_frozenset_as_self_raises_type_error(self):
5556 with self.assertRaises(TypeError):
5557 frozenset.union(set(), set())
5558
5559 def test_union_with_frozenset_returns_union(self):
5560 set1 = frozenset({1, 2})
5561 set2 = frozenset({2, 3})
5562 set3 = frozenset({4, 5})
5563 self.assertEqual(frozenset.union(set1, set2, set3), frozenset({1, 2, 3, 4, 5}))
5564
5565 def test_union_with_self_returns_copy(self):
5566 a_set = frozenset({1, 2, 3})
5567 self.assertIs(type(frozenset.union(a_set)), frozenset)
5568 self.assertIsNot(frozenset.union(a_set), a_set)
5569 self.assertIsNot(frozenset.union(a_set, a_set), a_set)
5570 self.assertEqual(frozenset.union(a_set, a_set), a_set)
5571
5572 def test_union_with_iterable_contains_iterable_items(self):
5573 a_set = frozenset({1, 2})
5574 a_dict = {2: True, 3: True}
5575 self.assertEqual(frozenset.union(a_set, a_dict), frozenset({1, 2, 3}))
5576
5577 def test_union_with_custom_iterable(self):
5578 class C:
5579 def __init__(self, start, end):
5580 self.pos = start
5581 self.end = end
5582
5583 def __iter__(self):
5584 return self
5585
5586 def __next__(self):
5587 if self.pos == self.end:
5588 raise StopIteration
5589 result = self.pos
5590 self.pos += 1
5591 return result
5592
5593 self.assertEqual(
5594 frozenset.union(frozenset(), C(1, 3), C(6, 9)), frozenset({1, 2, 6, 7, 8})
5595 )
5596
5597 def test_union_with_non_iterable_raises_typeerror(self):
5598 with self.assertRaises(TypeError):
5599 frozenset.union(frozenset({1, 2, 3}), 1.5)
5600
5601
5602class FunctionTests(unittest.TestCase):
5603 def test_dunder_closure_returns_none_if_function_is_not_a_closure(self):
5604 def foo():
5605 pass
5606
5607 self.assertIsNone(foo.__closure__)
5608
5609 def test_dunder_closure_returns_tuple_with_cell_if_function_is_closure(self):
5610 def foo(x):
5611 def bar(n):
5612 return x + n
5613
5614 return bar
5615
5616 add_three = foo(3)
5617 self.assertIsInstance(add_three.__closure__, tuple)
5618 self.assertEqual(len(add_three.__closure__), 1)
5619 self.assertEqual(type(add_three.__closure__[0]).__name__, "cell")
5620 self.assertEqual(add_three.__closure__[0].cell_contents, 3)
5621
5622 def test_dunder_closure_is_read_only_attribute(self):
5623 def foo():
5624 pass
5625
5626 with self.assertRaises(AttributeError):
5627 foo.__closure__ = 8
5628
5629 def test_dunder_dict_matches_attributes(self):
5630 def foo():
5631 pass
5632
5633 d = foo.__dict__
5634 self.assertEqual(len(d), 0)
5635 foo.bar = 42
5636 self.assertEqual(d["bar"], 42)
5637 d["baz"] = -8
5638 self.assertEqual(foo.baz, -8)
5639
5640 def test_dunder_dict_setter_update_matches_attributes(self):
5641 def foo():
5642 pass
5643
5644 foo.__dict__ = {"baz": 500}
5645 self.assertEqual(len(foo.__dict__), 1)
5646 self.assertEqual(foo.baz, 500)
5647
5648 def test_dunder_dict_setters_with_non_dict_raises_type_error(self):
5649 def foo():
5650 pass
5651
5652 with self.assertRaises(TypeError):
5653 foo.__dict__ = 100
5654
5655 def test_dunder_dict_after_dunder_class_succeeds(self):
5656 class C:
5657 pass
5658
5659 class D:
5660 def __init__(self):
5661 self.x = 10
5662 self.y = 20
5663
5664 c = C()
5665 c.__class__ = D
5666 c.__dict__ = {"baz": 100}
5667 self.assertIs(c.baz, 100)
5668
5669 def test_dunder_dict_with_in_object_attributes_after_dunder_class_succeeds(self):
5670 class C:
5671 def __init__(self):
5672 self.fish = -100
5673
5674 class D:
5675 def __init__(self):
5676 self.x = 10
5677 self.y = 20
5678
5679 c = C()
5680 c.__class__ = D
5681 c.__dict__ = {"baz": 100}
5682 self.assertIs(c.baz, 100)
5683
5684 def test_dunder_dict_after_dunder_class_multiple_times_succeeds(self):
5685 class C:
5686 def __init__(self):
5687 self.fish = -100
5688
5689 class D:
5690 def __init__(self):
5691 self.x = 10
5692 self.y = 20
5693
5694 class E:
5695 def __init__(self):
5696 self.z = 5000
5697
5698 c = C()
5699 c.__class__ = D
5700 c.__dict__ = {"baz": 100}
5701 self.assertIs(c.baz, 100)
5702
5703 c.__class__ = E
5704 c.__dict__ = {"baf": 200}
5705 self.assertIs(c.baf, 200)
5706
5707 def test_dunder_get_with_single_none_argument_raises_type_error(self):
5708 def foo():
5709 pass
5710
5711 with self.assertRaises(TypeError) as context:
5712 foo.__get__(None)
5713 self.assertIn("__get__(None, None) is invalid", str(context.exception))
5714
5715 def test_dunder_get_with_none_instance_and_none_owner_raises_type_error(self):
5716 def foo():
5717 pass
5718
5719 with self.assertRaises(TypeError) as context:
5720 foo.__get__(None, None)
5721 self.assertIn("__get__(None, None) is invalid", str(context.exception))
5722
5723 def test_dunder_get_with_none_instance_and_any_owner_returns_self(self):
5724 def foo():
5725 pass
5726
5727 self.assertEqual(foo.__get__(None, foo), foo)
5728 self.assertEqual(foo.__get__(None, type(foo)), foo)
5729 self.assertEqual(foo.__get__(None, "anything"), foo)
5730
5731 def test_dunder_get_with_instance_binds_instance_to_method(self):
5732 def foo():
5733 pass
5734
5735 self.assertEqual(foo.__get__(foo).__self__, foo)
5736 self.assertEqual(foo.__get__(foo, foo).__self__, foo)
5737 self.assertEqual(foo.__get__(foo, "anything").__self__, foo)
5738 self.assertEqual(foo.__get__("anything").__self__, "anything")
5739 self.assertEqual(foo.__get__("anything", foo).__self__, "anything")
5740 self.assertEqual(foo.__get__("anything", "anything").__self__, "anything")
5741
5742 def test_dunder_globals_returns_identical_object(self):
5743 def foo():
5744 pass
5745
5746 self.assertIs(foo.__globals__, foo.__globals__)
5747
5748 def test_dunder_globals_returns_dict_of_defining_module_dict(self):
5749 from types import ModuleType
5750
5751 module = ModuleType("test_module")
5752 module_code = """
5753def foo():
5754 pass
5755 """
5756 exec(module_code, module.__dict__)
5757 self.assertIs(module.__dict__["foo"].__globals__, module.__dict__)
5758
5759 @pyro_only
5760 def test_dunder_globals_with_extension_function_returns_empty_dict(self):
5761 import atexit
5762
5763 self.assertIn("BuiltinImporter", str(atexit.__loader__))
5764 dunder_globals = atexit.register.__globals__
5765 self.assertEqual(dunder_globals, {})
5766 self.assertIsInstance(dunder_globals, dict)
5767
5768 def test_dunder_defaults_returns_defaults(self):
5769 def foo(arg=42):
5770 return arg
5771
5772 self.assertEqual(foo.__defaults__, (42,))
5773
5774 def test_dunder_set_defaults(self):
5775 def foo(arg="bar"):
5776 return arg
5777
5778 self.assertEqual(foo(), "bar")
5779 foo.__defaults__ = ("baz",)
5780 self.assertEqual(foo(), "baz")
5781
5782 def test_dunder_set_defaults_with_tuple_subclass(self):
5783 class T(tuple):
5784 pass
5785
5786 def whereami(office=770):
5787 return office
5788
5789 self.assertEqual(whereami(), 770)
5790 whereami.__defaults__ = T((225,))
5791 self.assertEqual(whereami(), 225)
5792
5793 def test_dunder_set_defaults_with_non_tuple_raises_typeerror(self):
5794 def foo():
5795 pass
5796
5797 with self.assertRaises(TypeError):
5798 foo.__defaults__ = {}
5799
5800 def test_dunder_set_defaults_with_none_makes_function_require_arg(self):
5801 def foo(arg="bar"):
5802 return arg
5803
5804 foo.__defaults__ = None
5805 self.assertEqual(foo.__defaults__, None)
5806 self.assertEqual(foo(arg="abc"), "abc")
5807 with self.assertRaises(TypeError):
5808 foo()
5809
5810 def test_dunder_dir_returns_list(self):
5811 def foo():
5812 pass
5813
5814 self.assertIsInstance(foo.__dir__(), list)
5815
5816 def test_dunder_kwdefaults_returns_kwdefaults(self):
5817 def foo(*args, kwarg=42):
5818 return kwarg
5819
5820 self.assertEqual(foo.__kwdefaults__, {"kwarg": 42})
5821
5822 def test_dunder_set_kwdefaults(self):
5823 def foo(*args, kwarg="bar"):
5824 return kwarg
5825
5826 self.assertEqual(foo(), "bar")
5827 foo.__kwdefaults__ = {"kwarg": "baz"}
5828 self.assertEqual(foo(), "baz")
5829
5830 def test_dunder_set_kwdefaults_with_dict_subclass(self):
5831 class D(dict):
5832 pass
5833
5834 def whereami(*args, office=770):
5835 return office
5836
5837 self.assertEqual(whereami(), 770)
5838 whereami.__kwdefaults__ = D((("office", 225),))
5839 self.assertEqual(whereami(), 225)
5840
5841 def test_dunder_set_kwdefaults_with_none_makes_function_require_kwarg(self):
5842 def foo(*args, kwarg="bar"):
5843 return kwarg
5844
5845 foo.__kwdefaults__ = None
5846 self.assertEqual(foo.__kwdefaults__, None)
5847 self.assertEqual(foo(kwarg="abc"), "abc")
5848 with self.assertRaises(TypeError):
5849 foo()
5850
5851 def test_dunder_set_kwdefaults_with_non_dict_raises_typeerror(self):
5852 def foo():
5853 pass
5854
5855 with self.assertRaises(TypeError):
5856 foo.__kwdefaults__ = "not a dict"
5857
5858 def test_dunder_annotations_returns_annotations(self):
5859 def foo(arg: str):
5860 pass
5861
5862 self.assertEqual(foo.__annotations__, {"arg": str})
5863
5864 def test_dunder_set_annotations(self):
5865 def foo(arg: str):
5866 pass
5867
5868 foo.__annotations__ = {"arg": int}
5869 self.assertEqual(foo.__annotations__, {"arg": int})
5870 foo.__annotations__ = None
5871 self.assertEqual(foo.__annotations__, {})
5872
5873 def test_dunder_set_annotations_with_dict_subclass(self):
5874 class D(dict):
5875 pass
5876
5877 def foo(arg: str):
5878 pass
5879
5880 foo.__annotations__ = D((("arg", int),))
5881 self.assertEqual(foo.__annotations__, {"arg": int})
5882
5883 def test_dunder_set_annotations_with_non_dict_raises_typeerror(self):
5884 def foo():
5885 pass
5886
5887 with self.assertRaises(TypeError):
5888 foo.__annotations__ = (1, 2, 3)
5889
5890 def test_dunder_new_returns_function_object(self):
5891 import types
5892
5893 def _f():
5894 pass
5895
5896 new_func = types.FunctionType(_f.__code__, _f.__globals__)
5897 self.assertIsInstance(new_func, types.FunctionType)
5898 self.assertEqual(new_func.__name__, "_f")
5899
5900 def test_dunder_new_with_all_args_returns_function_object(self):
5901 import types
5902
5903 def _f():
5904 pass
5905
5906 new_func = types.FunctionType(
5907 _f.__code__, _f.__globals__, "hi", _f.__defaults__, _f.__closure__
5908 )
5909 self.assertIsInstance(new_func, types.FunctionType)
5910 self.assertEqual(new_func.__name__, "hi")
5911 self.assertEqual(new_func.__defaults__, _f.__defaults__)
5912 self.assertEqual(new_func.__closure__, _f.__closure__)
5913
5914 def test_dunder_new_with_name_override_as_subclassed_str_returns_function_object(
5915 self,
5916 ):
5917 import types
5918
5919 def _f():
5920 pass
5921
5922 class _s(str):
5923 pass
5924
5925 str_subclass = _s("reb00t")
5926 new_func = types.FunctionType(_f.__code__, _f.__globals__, name=str_subclass)
5927 self.assertIsInstance(new_func, types.FunctionType)
5928 self.assertEqual(new_func.__name__, "reb00t")
5929
5930 def test_dunder_new_with_closure_as_subclassed_tuple_returns_function_object(self):
5931 import types
5932
5933 def _f():
5934 pass
5935
5936 class _t(tuple):
5937 pass
5938
5939 tuple_subclass = _t()
5940 new_func = types.FunctionType(
5941 _f.__code__, _f.__globals__, closure=tuple_subclass
5942 )
5943 self.assertIsInstance(new_func, types.FunctionType)
5944 self.assertEqual(new_func.__closure__, ())
5945
5946 def test_dunder_new_with_non_code_type_value_raises_type_error(self):
5947 import types
5948
5949 def _f():
5950 pass
5951
5952 with self.assertRaises(TypeError):
5953 types.FunctionType("", _f.__globals__, name="hi")
5954
5955 def test_dunder_new_with_non_dict_globals_value_raises_type_error(self):
5956 import types
5957
5958 def _f():
5959 pass
5960
5961 with self.assertRaises(TypeError):
5962 types.FunctionType(_f.__code__, "", name="hi")
5963
5964 def test_dunder_new_with_dict_globals_returns_function(self):
5965 import types
5966
5967 def _f():
5968 global foo
5969 return foo
5970
5971 result = types.FunctionType(_f.__code__, {"foo": "bar"}, name="hi")
5972 self.assertIsInstance(result, types.FunctionType)
5973 self.assertEqual(result(), "bar")
5974
5975 def test_dunder_new_with_non_str_names_value_raises_type_error(self):
5976 import types
5977
5978 def _f():
5979 pass
5980
5981 with self.assertRaises(TypeError):
5982 types.FunctionType(_f.__code__, _f.__globals__, name=[])
5983
5984 def test_dunder_new_with_non_tuple_argdefs_value_raises_type_error(self):
5985 import types
5986
5987 def _f():
5988 pass
5989
5990 with self.assertRaises(TypeError):
5991 types.FunctionType(_f.__code__, _f.__globals__, argdefs="not a tuple")
5992
5993 def test_dunder_new_with_non_tuple_closure_value_raises_type_error(self):
5994 import types
5995
5996 def _f():
5997 pass
5998
5999 with self.assertRaises(TypeError):
6000 types.FunctionType(_f.__code__, _f.__globals__, closure="not a tuple")
6001
6002
6003class GeneratorTests(unittest.TestCase):
6004 def test_managed_yield_from_stop_iteration_turns_into_runtime_error(self):
6005 def inner_gen():
6006 raise StopIteration
6007
6008 def outer_gen():
6009 val = yield from inner_gen()
6010 yield val
6011
6012 g = outer_gen()
6013 with self.assertRaises(RuntimeError):
6014 next(g)
6015
6016 def test_managed_stop_iteration_turns_into_runtime_error(self):
6017 def gen():
6018 raise StopIteration
6019 yield
6020
6021 with self.assertRaises(RuntimeError):
6022 next(gen())
6023
6024 def test_gi_running(self):
6025 def gen():
6026 self.assertTrue(g.gi_running)
6027 yield 1
6028 self.assertTrue(g.gi_running)
6029 yield 2
6030
6031 g = gen()
6032 self.assertFalse(g.gi_running)
6033 next(g)
6034 self.assertFalse(g.gi_running)
6035 next(g)
6036 self.assertFalse(g.gi_running)
6037
6038 def test_gi_running_readonly(self):
6039 def gen():
6040 yield None
6041
6042 g = gen()
6043 self.assertRaises(AttributeError, setattr, g, "gi_running", 1234)
6044
6045 def test_running_gen_raises(self):
6046 def gen():
6047 self.assertRaises(ValueError, next, g)
6048 yield "done"
6049
6050 g = gen()
6051 self.assertEqual(next(g), "done")
6052
6053 class MyError(Exception):
6054 pass
6055
6056 @staticmethod
6057 def simple_gen():
6058 yield 1
6059 yield 2
6060
6061 @staticmethod
6062 def catching_gen():
6063 try:
6064 yield 1
6065 except GeneratorTests.MyError:
6066 yield "caught"
6067
6068 @staticmethod
6069 def catching_returning_gen():
6070 try:
6071 yield 1
6072 except GeneratorTests.MyError:
6073 return "all done!" # noqa
6074
6075 @staticmethod
6076 def delegate_gen(g):
6077 r = yield from g
6078 yield r
6079
6080 def test_close_with_invalid_self_raises_type_error(self):
6081 g = self.simple_gen()
6082 with self.assertRaises(TypeError):
6083 type(g).close(None)
6084
6085 def test_close_when_exhausted_returns_none(self):
6086 g = self.simple_gen()
6087 self.assertEqual(next(g), 1)
6088 self.assertEqual(next(g), 2)
6089 self.assertIsNone(g.close())
6090
6091 def test_close_when_generator_exit_propagates_returns_none(self):
6092 saw_generator_exit = False
6093
6094 def f():
6095 nonlocal saw_generator_exit
6096 try:
6097 yield 1
6098 except GeneratorExit:
6099 saw_generator_exit = True
6100 raise
6101
6102 g = f()
6103 self.assertEqual(next(g), 1)
6104 self.assertIsNone(g.close())
6105 self.assertTrue(saw_generator_exit)
6106
6107 def test_close_when_generator_exit_derived_exception_raised_returns_none(self):
6108 class GeneratorExitDerived(GeneratorExit):
6109 pass
6110
6111 def f():
6112 try:
6113 yield 1
6114 except GeneratorExit:
6115 raise GeneratorExitDerived
6116
6117 g = f()
6118 self.assertEqual(next(g), 1)
6119 self.assertIsNone(g.close())
6120
6121 def test_close_when_stop_iteration_raised_returns_none(self):
6122 saw_generator_exit = False
6123
6124 def f():
6125 nonlocal saw_generator_exit
6126 try:
6127 yield 1
6128 except GeneratorExit:
6129 saw_generator_exit = True
6130 # Implicitly raises StopIteration(2)
6131 return 2 # noqa
6132
6133 g = f()
6134 self.assertEqual(next(g), 1)
6135 self.assertIsNone(g.close())
6136 self.assertTrue(saw_generator_exit)
6137
6138 def test_close_generator_raises_exception_propagates(self):
6139 def f():
6140 try:
6141 yield 1
6142 except GeneratorExit:
6143 raise ValueError
6144
6145 g = f()
6146 self.assertEqual(next(g), 1)
6147 self.assertRaises(ValueError, g.close)
6148
6149 def test_close_generator_yields_raises_runtime_error(self):
6150 def f():
6151 try:
6152 yield 1
6153 except GeneratorExit:
6154 yield 2
6155
6156 g = f()
6157 self.assertEqual(g.send(None), 1)
6158 self.assertRaises(RuntimeError, g.close)
6159
6160 def test_throw(self):
6161 g = self.simple_gen()
6162 self.assertRaises(GeneratorTests.MyError, g.throw, GeneratorTests.MyError())
6163
6164 def test_throw_caught(self):
6165 g = self.catching_gen()
6166 self.assertEqual(next(g), 1)
6167 self.assertEqual(g.throw(GeneratorTests.MyError()), "caught")
6168
6169 def test_throw_type(self):
6170 g = self.catching_gen()
6171 self.assertEqual(next(g), 1)
6172 self.assertEqual(g.throw(GeneratorTests.MyError), "caught")
6173
6174 def test_throw_type_and_value(self):
6175 g = self.catching_gen()
6176 self.assertEqual(next(g), 1)
6177 self.assertEqual(
6178 g.throw(GeneratorTests.MyError, GeneratorTests.MyError()), "caught"
6179 )
6180
6181 def test_throw_uncaught_type(self):
6182 g = self.catching_gen()
6183 self.assertEqual(next(g), 1)
6184 self.assertRaises(RuntimeError, g.throw, RuntimeError)
6185
6186 def test_throw_finished(self):
6187 g = self.catching_returning_gen()
6188 self.assertEqual(next(g), 1)
6189 self.assertRaises(StopIteration, g.throw, GeneratorTests.MyError)
6190
6191 def test_throw_two_values(self):
6192 g = self.catching_gen()
6193 self.assertEqual(next(g), 1)
6194 self.assertRaises(
6195 TypeError, g.throw, GeneratorTests.MyError(), GeneratorTests.MyError()
6196 )
6197
6198 def test_throw_bad_traceback(self):
6199 g = self.catching_gen()
6200 self.assertEqual(next(g), 1)
6201 self.assertRaises(
6202 TypeError, g.throw, GeneratorTests.MyError, GeneratorTests.MyError(), 5
6203 )
6204
6205 def test_throw_bad_type(self):
6206 g = self.catching_gen()
6207 self.assertEqual(next(g), 1)
6208 self.assertRaises(TypeError, g.throw, 1234)
6209
6210 def test_throw_not_started(self):
6211 g = self.simple_gen()
6212 self.assertRaises(GeneratorTests.MyError, g.throw, GeneratorTests.MyError())
6213 self.assertRaises(StopIteration, next, g)
6214
6215 def test_throw_stopped(self):
6216 g = self.simple_gen()
6217 self.assertEqual(next(g), 1)
6218 self.assertEqual(next(g), 2)
6219 self.assertRaises(StopIteration, next, g)
6220 self.assertRaises(GeneratorTests.MyError, g.throw, GeneratorTests.MyError())
6221
6222 def test_throw_yield_from(self):
6223 g = self.delegate_gen(self.simple_gen())
6224 self.assertEqual(next(g), 1)
6225 self.assertRaises(GeneratorTests.MyError, g.throw, GeneratorTests.MyError)
6226
6227 def test_throw_yield_from_caught(self):
6228 g = self.delegate_gen(self.catching_gen())
6229 self.assertEqual(next(g), 1)
6230 self.assertEqual(g.throw(GeneratorTests.MyError), "caught")
6231
6232 def test_throw_yield_from_finishes(self):
6233 g = self.delegate_gen(self.catching_returning_gen())
6234 self.assertEqual(next(g), 1)
6235 self.assertEqual(g.throw(GeneratorTests.MyError), "all done!")
6236
6237 def test_throw_yield_from_non_gen(self):
6238 g = self.delegate_gen([1, 2, 3, 4])
6239 self.assertEqual(next(g), 1)
6240 self.assertRaises(RuntimeError, g.throw, RuntimeError)
6241
6242 def test_dunder_repr(self):
6243 def foo():
6244 yield 5
6245
6246 self.assertTrue(
6247 foo()
6248 .__repr__()
6249 .startswith(
6250 "<generator object GeneratorTests.test_dunder_repr.<locals>.foo at "
6251 )
6252 )
6253
6254 def test_exception_context_captured_across_further_yield_from(self):
6255 def raises():
6256 raise ValueError
6257 yield None
6258
6259 def double_raises():
6260 try:
6261 raise RuntimeError
6262 except RuntimeError:
6263 yield from raises()
6264
6265 with self.assertRaises(ValueError) as exc:
6266 double_raises().send(None)
6267
6268 self.assertIsInstance(exc.exception.__context__, RuntimeError)
6269
6270
6271class GlobalsTests(unittest.TestCase):
6272 def test_returns_module_dunder_dict(self):
6273 import sys
6274
6275 self.assertIs(globals(), sys.modules[__name__].__dict__)
6276
6277 def test_with_module_subclass_returns_module_proxy(self):
6278 from types import ModuleType
6279
6280 class C(ModuleType):
6281 pass
6282
6283 m_name = "testing.test_with_module_subclass_returns_module_proxy"
6284 m = C(m_name)
6285 import sys
6286
6287 try:
6288 # We currently only support `globals()` for modules registered in
6289 # `sys.modules`.
6290 sys.modules[m_name] = m
6291 exec("def foo(): return globals()", m.__dict__, m.__dict__)
6292 self.assertIs(m.foo(), m.__dict__)
6293 finally:
6294 del sys.modules[m_name]
6295
6296
6297class HasattrTests(unittest.TestCase):
6298 def test_hasattr_calls_dunder_getattribute(self):
6299 class C:
6300 def __getattribute__(self, name):
6301 if name == "foo":
6302 return 42
6303 raise AttributeError(name)
6304
6305 i = C()
6306 self.assertTrue(hasattr(i, "foo"))
6307 self.assertFalse(hasattr(i, "bar"))
6308
6309 def test_hasattr_propagates_error_from_dunder_getattribute(self):
6310 class C:
6311 def __getattribute__(self, name):
6312 raise UserWarning()
6313
6314 i = C()
6315 with self.assertRaises(UserWarning):
6316 hasattr(i, "foo")
6317
6318 def test_hasattr_calls_dunder_getattr(self):
6319 class C:
6320 def __getattribute__(self, name):
6321 nonlocal getattribute_called
6322 getattribute_called = True
6323 raise AttributeError(name)
6324
6325 def __getattr__(self, name):
6326 if name == "foo":
6327 return 42
6328 raise AttributeError(name)
6329
6330 i = C()
6331 getattribute_called = False
6332 self.assertTrue(hasattr(i, "foo"))
6333 self.assertTrue(getattribute_called)
6334
6335 getattribute_called = False
6336 self.assertFalse(hasattr(i, "bar"))
6337 self.assertTrue(getattribute_called)
6338
6339 def test_hasattr_propagates_error_from_dunder_getattr(self):
6340 class C:
6341 def __getattribute__(self, name):
6342 raise AttributeError(name)
6343
6344 def __getattr__(self, name):
6345 raise UserWarning()
6346
6347 i = C()
6348 with self.assertRaises(UserWarning):
6349 hasattr(i, "foo")
6350
6351 def test_hasattr_with_non_string_attr_raises_type_error(self):
6352 with self.assertRaises(TypeError) as context:
6353 hasattr(None, 42)
6354 self.assertIn("attribute name must be string", str(context.exception))
6355
6356
6357class HashTests(unittest.TestCase):
6358 def test_hash_with_raising_dunder_hash_descriptor_raises_type_error(self):
6359 class Desc:
6360 def __get__(self, obj, type):
6361 raise AttributeError("failed")
6362
6363 class Foo:
6364 __hash__ = Desc()
6365
6366 foo = Foo()
6367 with self.assertRaises(TypeError) as context:
6368 hash(foo)
6369 self.assertEqual(str(context.exception), "unhashable type: 'Foo'")
6370
6371 def test_hash_with_raising_dunder_hash_propagates_exceptions(self):
6372 class C:
6373 def __hash__(self):
6374 raise UserWarning()
6375
6376 i = C()
6377 with self.assertRaises(UserWarning):
6378 hash(i)
6379
6380 def test_hash_with_none_dunder_hash_raises_type_error(self):
6381 class Foo:
6382 __hash__ = None
6383
6384 foo = Foo()
6385 with self.assertRaises(TypeError) as context:
6386 hash(foo)
6387 self.assertEqual(str(context.exception), "unhashable type: 'Foo'")
6388
6389 def test_hash_with_non_int_dunder_hash_raises_type_error(self):
6390 class Foo:
6391 def __hash__(self):
6392 return "not an int"
6393
6394 foo = Foo()
6395 with self.assertRaises(TypeError) as context:
6396 hash(foo)
6397 self.assertEqual(
6398 str(context.exception), "__hash__ method should return an integer"
6399 )
6400
6401 def test_hash_with_int_subclass_dunder_hash_returns_int(self):
6402 class SubInt(int):
6403 pass
6404
6405 class Foo:
6406 def __hash__(self):
6407 return SubInt(42)
6408
6409 foo = Foo()
6410 result = hash(foo)
6411 self.assertEqual(42, result)
6412 self.assertEqual(type(42), int)
6413
6414 def test_hash_with_false_returns_zero(self):
6415 class C:
6416 def __hash__(self):
6417 return False
6418
6419 self.assertIs(type(hash(C())), int)
6420 self.assertEqual(hash(C()), 0)
6421
6422 def test_hash_with_true_returns_one(self):
6423 class C:
6424 def __hash__(self):
6425 return True
6426
6427 self.assertIs(type(hash(C())), int)
6428 self.assertEqual(hash(C()), 1)
6429
6430 def test_hash_replaces_minus_one_with_minus_two(self):
6431 class C:
6432 def __hash__(self):
6433 return -1
6434
6435 self.assertEqual(hash(C()), -2)
6436
6437 def test_hash_with_large_int_value_hashes_result(self):
6438 class C:
6439 def __hash__(self):
6440 return 0xB228AA4BB7326F5D697F47B0CC9230D4
6441
6442 self.assertEqual(hash(C()), int.__hash__(0xB228AA4BB7326F5D697F47B0CC9230D4))
6443
6444 def test_hash_returns_hash_value(self):
6445 class C(int):
6446 def __hash__(self):
6447 return self
6448
6449 self.assertEqual(hash(C(0)), 0)
6450 self.assertEqual(hash(C(1)), 1)
6451 self.assertEqual(hash(C(42)), 42)
6452 self.assertEqual(hash(C(-5)), -5)
6453
6454 def test_hash_with_max_hash_returns_max_hash(self):
6455 import sys
6456
6457 max_hash = (1 << (sys.hash_info.width - 1)) - 1
6458
6459 class C:
6460 def __hash__(self):
6461 nonlocal max_hash
6462 return max_hash
6463
6464 self.assertEqual(hash(C()), max_hash)
6465
6466
6467class HexTests(unittest.TestCase):
6468 def test_returns_string(self):
6469 self.assertEqual(hex(0), "0x0")
6470 self.assertEqual(hex(-1), "-0x1")
6471 self.assertEqual(hex(1), "0x1")
6472 self.assertEqual(hex(54321), "0xd431")
6473 self.assertEqual(hex(81985529216486895), "0x123456789abcdef")
6474 self.assertEqual(hex(18364758544493064720), "0xfedcba9876543210")
6475
6476 def test_with_large_int_returns_string(self):
6477 self.assertEqual(hex(1 << 63), "0x8000000000000000")
6478 self.assertEqual(hex(1 << 64), "0x10000000000000000")
6479 self.assertEqual(
6480 hex(0xDEE182DE2EC55F61B22A509ED1DC3EB), "0xdee182de2ec55f61b22a509ed1dc3eb"
6481 )
6482 self.assertEqual(
6483 hex(-0x53ADC651E593B1323158BFA776E8173F60C76519277B2BD6),
6484 "-0x53adc651e593b1323158bfa776e8173f60c76519277b2bd6",
6485 )
6486
6487 def test_calls_dunder_index(self):
6488 class C:
6489 def __int__(self):
6490 return 42
6491
6492 def __index__(self):
6493 return -99
6494
6495 self.assertEqual(hex(C()), "-0x63")
6496
6497 def test_with_int_subclass(self):
6498 class C(int):
6499 pass
6500
6501 self.assertEqual(hex(C(51)), "0x33")
6502
6503 def test_with_non_int_raises_type_error(self):
6504 with self.assertRaises(TypeError) as context:
6505 hex("not an int")
6506 self.assertEqual(
6507 str(context.exception), "'str' object cannot be interpreted as an integer"
6508 )
6509
6510
6511class DeleteStream(contextlib.AbstractContextManager):
6512 _stream = None
6513
6514 def __init__(self):
6515 self._old_targets = []
6516
6517 def __enter__(self):
6518 self._old_targets.append(getattr(sys, self._stream))
6519 delattr(sys, self._stream)
6520
6521 def __exit__(self, exctype, excinst, exctb):
6522 setattr(sys, self._stream, self._old_targets.pop())
6523
6524
6525class delete_stderr(DeleteStream):
6526 _stream = "stderr"
6527
6528
6529class delete_stdin(DeleteStream):
6530 _stream = "stdin"
6531
6532
6533class delete_stdout(DeleteStream):
6534 _stream = "stdout"
6535
6536
6537class redirect_stdin(contextlib._RedirectStream):
6538 _stream = "stdin"
6539
6540
6541class InputTests(unittest.TestCase):
6542 def test_input_with_deleted_stderr_raises_runtime_error(self):
6543
6544 with delete_stderr():
6545 with self.assertRaises(RuntimeError):
6546 input()
6547
6548 def test_input_with_deleted_stdin_raises_runtime_error(self):
6549
6550 with delete_stdin():
6551 with self.assertRaises(RuntimeError):
6552 input()
6553
6554 def test_input_with_deleted_stdout_raises_runtime_error(self):
6555
6556 with delete_stdout():
6557 with self.assertRaises(RuntimeError):
6558 input()
6559
6560 def test_input_with_none_stderr_raises_runtime_error(self):
6561
6562 with contextlib.redirect_stderr(None):
6563 with self.assertRaises(RuntimeError):
6564 input()
6565
6566 def test_input_with_none_stdin_raises_runtime_error(self):
6567
6568 with redirect_stdin(None):
6569 with self.assertRaises(RuntimeError):
6570 input()
6571
6572 def test_input_with_none_stdout_raises_runtime_error(self):
6573
6574 with contextlib.redirect_stdout(None):
6575 with self.assertRaises(RuntimeError):
6576 input()
6577
6578 def test_input_strips_trailing_newline(self):
6579 class MyInStream:
6580 def readline(self):
6581 return "foobar\n"
6582
6583 with redirect_stdin(MyInStream()):
6584 self.assertEqual(input(), "foobar")
6585
6586 def test_input_keeps_trailing_non_newline_char(self):
6587 class MyInStream:
6588 def readline(self):
6589 return "foobarX"
6590
6591 with redirect_stdin(MyInStream()):
6592 self.assertEqual(input(), "foobarX")
6593
6594 def test_input_does_not_strip_trailing_cr_nl(self):
6595 class MyInStream:
6596 def readline(self):
6597 return "foobar\r\n"
6598
6599 with redirect_stdin(MyInStream()):
6600 self.assertEqual(input(), "foobar\r")
6601
6602 def test_input_with_empty_input_raises_eof_error(self):
6603 class MyInStream:
6604 def readline(self):
6605 return ""
6606
6607 with redirect_stdin(MyInStream()):
6608 self.assertRaises(EOFError, input)
6609
6610 def test_input_with_prompt_writes_prompt(self):
6611 class MyInStream:
6612 def readline(self):
6613 return "foobar\n"
6614
6615 class MyOutStream:
6616 def write(self, value):
6617 self.value = value
6618
6619 with redirect_stdin(MyInStream()):
6620 with contextlib.redirect_stdout(MyOutStream()):
6621 self.assertEqual(input("> "), "foobar")
6622 self.assertEqual(sys.stdout.value, "> ")
6623
6624 def test_input_calls_stdout_flush(self):
6625 class MyInStream:
6626 def readline(self):
6627 return "foobar\n"
6628
6629 class MyOutStream:
6630 flush = Mock(name="flush")
6631
6632 with redirect_stdin(MyInStream()):
6633 with contextlib.redirect_stdout(MyOutStream()):
6634 self.assertEqual(input(), "foobar")
6635 MyOutStream.flush.assert_called_once()
6636
6637 def test_input_calls_stderr_flush(self):
6638 class MyInStream:
6639 def readline(self):
6640 return "foobar\n"
6641
6642 class MyOutStream:
6643 flush = Mock(name="flush")
6644
6645 with redirect_stdin(MyInStream()):
6646 with contextlib.redirect_stderr(MyOutStream()):
6647 self.assertEqual(input(), "foobar")
6648 MyOutStream.flush.assert_called_once()
6649
6650
6651@pyro_only
6652class InstanceProxyTests(unittest.TestCase):
6653 def test_dunder_eq_with_id_equal_proxy_returns_true(self):
6654 class C:
6655 pass
6656
6657 instance = C()
6658 proxy = instance.__dict__
6659 self.assertIs(instance_proxy.__eq__(proxy, proxy), True)
6660
6661 def test_dunder_eq_with_non_dict_other_returns_not_implemented(self):
6662 class C:
6663 pass
6664
6665 instance = C()
6666 proxy = instance.__dict__
6667 self.assertIs(instance_proxy.__eq__(proxy, 5), NotImplemented)
6668
6669 def test_dunder_eq_with_unequal_length_proxy_returns_false(self):
6670 class C:
6671 pass
6672
6673 left = C()
6674 right = C()
6675 right.a = 1
6676 self.assertIs(instance_proxy.__eq__(left.__dict__, right.__dict__), False)
6677
6678 def test_dunder_eq_with_unequal_length_dict_returns_false(self):
6679 class C:
6680 pass
6681
6682 left = C()
6683 self.assertIs(instance_proxy.__eq__(left.__dict__, {"a": 1}), False)
6684
6685 def test_dunder_eq_with_empty_proxies_returns_true(self):
6686 class C:
6687 pass
6688
6689 left = C()
6690 right = C()
6691 self.assertIs(instance_proxy.__eq__(left.__dict__, right.__dict__), True)
6692
6693 def test_dunder_eq_with_empty_proxy_and_empty_dict_returns_true(self):
6694 class C:
6695 pass
6696
6697 left = C()
6698 self.assertIs(instance_proxy.__eq__(left.__dict__, {}), True)
6699
6700 def test_dunder_eq_with_key_not_in_other_returns_false(self):
6701 class C:
6702 pass
6703
6704 left = C()
6705 left.a = 1
6706 right = C()
6707 right.b = 2
6708 self.assertIs(instance_proxy.__eq__(left.__dict__, right.__dict__), False)
6709
6710 def test_dunder_eq_with_key_not_in_other_dict_returns_false(self):
6711 class C:
6712 pass
6713
6714 left = C()
6715 left.a = 1
6716 self.assertIs(instance_proxy.__eq__(left.__dict__, {"b": 2}), False)
6717
6718 def test_dunder_eq_with_value_not_equal_in_other_returns_false(self):
6719 class C:
6720 pass
6721
6722 left = C()
6723 left.a = 1
6724 right = C()
6725 right.a = 2
6726 self.assertIs(instance_proxy.__eq__(left.__dict__, right.__dict__), False)
6727
6728 def test_dunder_eq_with_value_not_equal_in_other_dict_returns_false(self):
6729 class C:
6730 pass
6731
6732 left = C()
6733 left.a = 1
6734 self.assertIs(instance_proxy.__eq__(left.__dict__, {"a": 2}), False)
6735
6736 def test_dunder_eq_with_key_and_value_equal_in_other_returns_true(self):
6737 class C:
6738 pass
6739
6740 left = C()
6741 left.a = 1
6742 right = C()
6743 right.a = 1
6744 self.assertIs(instance_proxy.__eq__(left.__dict__, right.__dict__), True)
6745
6746 def test_dunder_eq_with_key_and_value_equal_in_other_dict_returns_true(self):
6747 class C:
6748 pass
6749
6750 left = C()
6751 left.a = 1
6752 self.assertIs(instance_proxy.__eq__(left.__dict__, {"a": 1}), True)
6753
6754 def test_dunder_eq_with_id_equal_values_returns_true(self):
6755 # There's no test for id equal keys but overridden __eq__ because we
6756 # don't support str subclasses with overridden __eq__ for attributes
6757 class C:
6758 pass
6759
6760 class D:
6761 def __eq__(self, other):
6762 raise RuntimeError("foo")
6763
6764 left = C()
6765 value = D()
6766 left.a = value
6767 self.assertIs(instance_proxy.__eq__(left.__dict__, {"a": value}), True)
6768
6769 def test_dunder_init_with_non_instance_raises_type_error(self):
6770 self.assertRaisesRegex(
6771 TypeError,
6772 "'__init__' .* 'instance' object.* a 'int'",
6773 instance_proxy,
6774 42,
6775 )
6776
6777 def test_copy_with_empty_instance_returns_empty_dict(self):
6778 class C:
6779 pass
6780
6781 result = C().__dict__.copy()
6782 self.assertIsInstance(result, dict)
6783 self.assertEqual(result, {})
6784
6785 def test_copy_returns_dict_with_attributes(self):
6786 class C:
6787 pass
6788
6789 instance = C()
6790 instance.a = 1
6791 instance.b = 2
6792 result = instance.__dict__.copy()
6793 self.assertIsInstance(result, dict)
6794 self.assertIsNot(result, instance.__dict__)
6795 self.assertEqual(result, {"a": 1, "b": 2})
6796
6797 def test_get_with_extant_key_returns_value(self):
6798 class C:
6799 pass
6800
6801 left = C()
6802 value = object()
6803 left.a = value
6804 self.assertIs(instance_proxy.get(left.__dict__, "a"), value)
6805
6806 def test_get_with_nonexistent_key_returns_none(self):
6807 class C:
6808 pass
6809
6810 left = C()
6811 self.assertIs(instance_proxy.get(left.__dict__, "a"), None)
6812
6813 def test_get_with_nonexistent_key_returns_default(self):
6814 class C:
6815 pass
6816
6817 left = C()
6818 value = object()
6819 self.assertIs(instance_proxy.get(left.__dict__, "a", value), value)
6820
6821 def test_dunder_repr_with_recursive_instance_prints_ellipsis(self):
6822 class C:
6823 pass
6824
6825 instance = C()
6826 instance.a = 1
6827 instance.b = instance.__dict__
6828 self.assertEqual(
6829 instance_proxy.__repr__(instance.__dict__),
6830 "instance_proxy({'a': 1, 'b': instance_proxy({'a': 1, 'b': instance_proxy({...})})})", # noqa
6831 )
6832
6833
6834class InstanceTests(unittest.TestCase):
6835 def test_dunder_dict_updates_instance_attributes(self):
6836 class C:
6837 def __init__(self):
6838 self.foo = 10
6839 self.bar = 20
6840
6841 c = C()
6842 d = {"bar": -10, "baz": -20}
6843 c.__dict__ = d
6844
6845 self.assertFalse(hasattr(c, "foo"))
6846 # Existing "bar" was overwritten.
6847 self.assertTrue(hasattr(c, "bar"))
6848 self.assertTrue(hasattr(c, "baz"))
6849
6850 self.assertEqual(c.bar, -10)
6851 self.assertEqual(c.baz, -20)
6852
6853 d["foo"] = "1"
6854 d["bar"] = "2"
6855 d["baz"] = "3"
6856
6857 self.assertEqual(c.foo, "1")
6858 self.assertEqual(c.bar, "2")
6859 self.assertEqual(c.baz, "3")
6860
6861 def test_dunder_dict_updates_instances_during_init(self):
6862 class C:
6863 shared_defaults = {"a": 42, "b": 13}
6864
6865 def __init__(self):
6866 self.__dict__ = C.shared_defaults
6867
6868 c0 = C()
6869 self.assertEqual(c0.a, 42)
6870 self.assertEqual(c0.b, 13)
6871
6872 c1 = C()
6873 c0.new_attribute = 99
6874
6875 self.assertEqual(c1.new_attribute, 99)
6876
6877 def test_dunder_dict_updates_with_non_dict_raises_type_error(self):
6878 class C:
6879 pass
6880
6881 c = C()
6882 with self.assertRaises(TypeError) as context:
6883 c.__dict__ = None
6884 self.assertEqual(
6885 str(context.exception),
6886 "__dict__ must be set to a dictionary, not a 'NoneType'",
6887 )
6888
6889 def test_dunder_dict_keys_with_instance_with_dict_overflow_returns_keys(self):
6890 class C:
6891 def __init__(self):
6892 self.a = 1
6893 self.b = 2
6894
6895 instance = C()
6896 # This is the current idiomatic way to force an instance's layout into
6897 # the dict overflow state.
6898 instance.__dict__ = {"hello": "world"}
6899 self.assertEqual(list(instance.__dict__.keys()), ["hello"])
6900
6901 def test_vars_update_with_no_args_does_not_raise(self):
6902 class C:
6903 pass
6904
6905 instance = C()
6906 vars(instance).update()
6907
6908 def test_vars_update_with_only_kwargs_sets_attribute(self):
6909 class C:
6910 pass
6911
6912 instance = C()
6913 vars(instance).update(hello=1)
6914 self.assertEqual(instance.hello, 1)
6915
6916 def test_vars_update_with_args_and_kwargs_sets_attributes(self):
6917 class C:
6918 pass
6919
6920 instance = C()
6921 vars(instance).update({"hello": 1}, world=2)
6922 self.assertEqual(instance.hello, 1)
6923 self.assertEqual(instance.world, 2)
6924
6925
6926class IsInstanceTests(unittest.TestCase):
6927 def test_isinstance_with_same_types_returns_true(self):
6928 self.assertIs(isinstance(1, int), True)
6929
6930 def test_isinstance_with_subclass_returns_true(self):
6931 self.assertIs(isinstance(False, int), True)
6932
6933 def test_isinstance_with_superclass_returns_false(self):
6934 self.assertIs(isinstance(2, bool), False)
6935
6936 def test_isinstance_with_type_and_metaclass_returns_true(self):
6937 self.assertIs(isinstance(list, type), True)
6938
6939 def test_isinstance_with_type_returns_true(self):
6940 self.assertIs(isinstance(type, type), True)
6941
6942 def test_isinstance_with_object_type_returns_true(self):
6943 self.assertIs(isinstance(object, object), True)
6944
6945 def test_isinstance_with_int_type_returns_false(self):
6946 self.assertIs(isinstance(int, int), False)
6947
6948 def test_isinstance_with_unrelated_types_returns_false(self):
6949 self.assertIs(isinstance(int, (dict, bytes, str)), False)
6950
6951 def test_isinstance_with_superclass_tuple_returns_true(self):
6952 self.assertIs(isinstance(True, (int, "bad - not a type")), True)
6953
6954 def test_isinstance_with_non_type_superclass_raises_type_error(self):
6955 self.assertRaisesRegex(
6956 TypeError,
6957 r"isinstance\(\) arg 2 must be a type.* tuple of types",
6958 isinstance,
6959 4,
6960 "bad - not a type",
6961 )
6962
6963 def test_isinstance_with_non_type_in_tuple_raises_type_error(self):
6964 self.assertRaisesRegex(
6965 TypeError,
6966 r"isinstance\(\) arg 2 must be a type.* tuple of types",
6967 isinstance,
6968 5,
6969 ("bad - not a type", int),
6970 )
6971
6972 def test_isinstance_with_multiple_inheritance_returns_true(self):
6973 class A:
6974 pass
6975
6976 class B(A):
6977 pass
6978
6979 class C(A):
6980 pass
6981
6982 class D(B, C):
6983 pass
6984
6985 d = D()
6986
6987 # D() is an instance of all specified superclasses
6988 self.assertIs(isinstance(d, A), True)
6989 self.assertIs(isinstance(d, B), True)
6990 self.assertIs(isinstance(d, C), True)
6991 self.assertIs(isinstance(d, D), True)
6992
6993 # D() is not an instance of builtin types except object
6994 self.assertIs(isinstance(d, object), True)
6995 self.assertIs(isinstance(d, list), False)
6996
6997 # D is an instance type, but D() is not
6998 self.assertIs(isinstance(D, type), True)
6999 self.assertIs(isinstance(d, type), False)
7000
7001 def test_isinstance_with_type_checks_instance_type_and_dunder_class(self):
7002 class A(int):
7003 __class__ = list
7004
7005 a = A()
7006 self.assertIs(isinstance(a, int), True)
7007 self.assertIs(isinstance(a, list), True)
7008
7009 def test_isinstance_with_nontype_checks_dunder_bases_and_dunder_class(self):
7010 class A:
7011 __bases__ = ()
7012
7013 a = A()
7014
7015 class B:
7016 __bases__ = (a,)
7017
7018 b = B()
7019
7020 class C(int):
7021 __class__ = b
7022 __bases__ = (int,)
7023
7024 c = C()
7025 self.assertIs(isinstance(c, a), True)
7026 self.assertIs(isinstance(c, b), True)
7027 self.assertIs(isinstance(c, c), False)
7028
7029 def test_isinstance_with_non_tuple_dunder_bases_raises_type_error(self):
7030 class A:
7031 __bases__ = 5
7032
7033 self.assertRaisesRegex(
7034 TypeError,
7035 r"isinstance\(\) arg 2 must be a type.* tuple of types",
7036 isinstance,
7037 5,
7038 A(),
7039 )
7040
7041 def test_isinstance_calls_custom_instancecheck_true(self):
7042 class Meta(type):
7043 def __instancecheck__(cls, obj):
7044 return [1]
7045
7046 class A(metaclass=Meta):
7047 pass
7048
7049 self.assertIs(isinstance(0, A), True)
7050
7051 def test_isinstance_calls_custom_instancecheck_false(self):
7052 class Meta(type):
7053 def __instancecheck__(cls, obj):
7054 return None
7055
7056 class A(metaclass=Meta):
7057 pass
7058
7059 class B(A):
7060 pass
7061
7062 self.assertIs(isinstance(A(), A), True)
7063 self.assertIs(isinstance(B(), A), False)
7064
7065 def test_isinstance_with_raising_instancecheck_propagates_error(self):
7066 class Desc:
7067 def __get__(self, obj, type):
7068 raise AttributeError("failed")
7069
7070 class Meta(type):
7071 __instancecheck__ = Desc()
7072
7073 class A(metaclass=Meta):
7074 pass
7075
7076 with self.assertRaises(AttributeError) as context:
7077 isinstance(2, A)
7078 self.assertEqual(str(context.exception), "failed")
7079
7080 def test_dunder_dict_copy_with_empty_instance_returns_empty_dict(self):
7081 class C:
7082 pass
7083
7084 result = C().__dict__.copy()
7085 self.assertIsInstance(result, dict)
7086 self.assertEqual(result, {})
7087
7088 def test_dunder_dict_copy_returns_dict_with_attributes(self):
7089 class C:
7090 pass
7091
7092 instance = C()
7093 instance.a = 1
7094 instance.b = 2
7095 result = instance.__dict__.copy()
7096 self.assertIsInstance(result, dict)
7097 self.assertEqual(result, {"a": 1, "b": 2})
7098
7099
7100class IsSubclassTests(unittest.TestCase):
7101 def test_issubclass_with_same_types_returns_true(self):
7102 self.assertIs(issubclass(int, int), True)
7103
7104 def test_issubclass_with_subclass_returns_true(self):
7105 self.assertIs(issubclass(bool, int), True)
7106
7107 def test_issubclass_with_superclass_returns_false(self):
7108 self.assertIs(issubclass(int, bool), False)
7109
7110 def test_issubclass_with_unrelated_types_returns_false(self):
7111 self.assertIs(issubclass(int, (dict, bytes, str)), False)
7112
7113 def test_issubclass_with_superclass_tuple_returns_true(self):
7114 self.assertIs(issubclass(bool, (int, "bad - not a type")), True)
7115
7116 def test_issubclass_with_non_type_subclass_raises_type_error(self):
7117 with self.assertRaises(TypeError) as context:
7118 issubclass("bad - not a type", str)
7119 self.assertEqual(str(context.exception), "issubclass() arg 1 must be a class")
7120
7121 def test_issubclass_with_non_type_superclass_raises_type_error(self):
7122 with self.assertRaises(TypeError) as context:
7123 issubclass(int, "bad - not a type")
7124 self.assertEqual(
7125 str(context.exception),
7126 "issubclass() arg 2 must be a class or tuple of classes",
7127 )
7128
7129 def test_issubclass_with_non_type_in_tuple_raises_type_error(self):
7130 with self.assertRaises(TypeError) as context:
7131 issubclass(bool, ("bad - not a type", int))
7132 self.assertEqual(
7133 str(context.exception),
7134 "issubclass() arg 2 must be a class or tuple of classes",
7135 )
7136
7137 def test_issubclass_with_non_type_subclass_uses_bases(self):
7138 class A:
7139 __bases__ = (list,)
7140
7141 self.assertIs(issubclass(A(), list), True)
7142
7143 def test_issubclass_calls_custom_subclasscheck_true(self):
7144 class Meta(type):
7145 def __subclasscheck__(cls, subclass):
7146 return 1
7147
7148 class A(metaclass=Meta):
7149 pass
7150
7151 self.assertIs(issubclass(list, A), True)
7152
7153 def test_issubclass_calls_custom_subclasscheck_false(self):
7154 class Meta(type):
7155 def __subclasscheck__(cls, subclass):
7156 return []
7157
7158 class A(metaclass=Meta):
7159 pass
7160
7161 class B(A):
7162 pass
7163
7164 self.assertIs(issubclass(B, A), False)
7165
7166 def test_issubclass_with_raising_subclasscheck_propagates_error(self):
7167 class Desc:
7168 def __get__(self, obj, type):
7169 raise AttributeError("failed")
7170
7171 class Meta(type):
7172 __subclasscheck__ = Desc()
7173
7174 class A(metaclass=Meta):
7175 pass
7176
7177 with self.assertRaises(AttributeError) as context:
7178 issubclass(bool, A)
7179 self.assertEqual(str(context.exception), "failed")
7180
7181
7182class IterTests(unittest.TestCase):
7183 def test_iter_with_no_dunder_iter_raises_type_error(self):
7184 class C:
7185 pass
7186
7187 c = C()
7188
7189 with self.assertRaises(TypeError) as context:
7190 iter(c)
7191
7192 self.assertEqual(str(context.exception), "'C' object is not iterable")
7193
7194 def test_iter_with_dunder_iter_calls_dunder_iter(self):
7195 class C:
7196 def __iter__(self):
7197 raise UserWarning("foo")
7198
7199 c = C()
7200
7201 with self.assertRaises(UserWarning) as context:
7202 iter(c)
7203
7204 self.assertEqual(str(context.exception), "foo")
7205
7206 def test_iter_with_raising_descriptor_dunder_iter_raises_type_error(self):
7207 dunder_get_called = False
7208
7209 class Desc:
7210 def __get__(self, obj, type):
7211 nonlocal dunder_get_called
7212 dunder_get_called = True
7213 raise UserWarning("foo")
7214
7215 class C:
7216 __iter__ = Desc()
7217
7218 c = C()
7219
7220 with self.assertRaises(TypeError) as context:
7221 iter(c)
7222
7223 self.assertEqual(str(context.exception), "'C' object is not iterable")
7224 self.assertTrue(dunder_get_called)
7225
7226 def test_iter_with_non_iterator_raises_type_error(self):
7227 class NonIter:
7228 pass
7229
7230 class Foo:
7231 def __iter__(self):
7232 return NonIter()
7233
7234 foo = Foo()
7235 with self.assertRaises(TypeError) as context:
7236 iter(foo)
7237 self.assertEqual(
7238 str(context.exception), "iter() returned non-iterator of type 'NonIter'"
7239 )
7240
7241 def test_iter_with_none_dunder_iter_raises_type_error(self):
7242 class Foo:
7243 __iter__ = None
7244
7245 foo = Foo()
7246 with self.assertRaises(TypeError) as context:
7247 iter(foo)
7248 self.assertEqual(str(context.exception), "'Foo' object is not iterable")
7249
7250
7251class LenTests(unittest.TestCase):
7252 def test_len_without_class_dunder_len_raises_type_error(self):
7253 class Foo:
7254 pass
7255
7256 foo = Foo()
7257 foo.__len__ = lambda: 0
7258 with self.assertRaises(TypeError) as context:
7259 len(foo)
7260 self.assertEqual(str(context.exception), "object of type 'Foo' has no len()")
7261
7262 def test_len_without_non_int_dunder_len_raises_type_error(self):
7263 class Foo:
7264 def __len__(self):
7265 return "not an int"
7266
7267 foo = Foo()
7268 with self.assertRaises(TypeError) as context:
7269 len(foo)
7270 self.assertEqual(
7271 str(context.exception), "'str' object cannot be interpreted as an integer"
7272 )
7273
7274 def test_len_with_dunder_len_returns_int(self):
7275 class Foo:
7276 def __len__(self):
7277 return 5
7278
7279 self.assertEqual(len(Foo()), 5)
7280
7281 def test_len_with_list_returns_list_length(self):
7282 self.assertEqual(len([1, 2, 3]), 3)
7283
7284 def test_len_with_non_container_raises_type_error(self):
7285 self.assertRaises(TypeError, len, 1)
7286
7287
7288class ListTests(unittest.TestCase):
7289 def test_list_with_empty_iterable(self):
7290 actual = list() # noqa: C408
7291 self.assertEqual(actual, [])
7292
7293 def test_list_with_iterable_as_list(self):
7294 actual = list([1, 2, 3]) # noqa: C410
7295 self.assertEqual(actual, [1, 2, 3])
7296
7297 def test_list_with_iterable_as_tuple(self):
7298 actual = list((1, 2, 3)) # noqa: C410
7299 self.assertEqual(actual, [1, 2, 3])
7300
7301 def test_list_with_general_iterable(self):
7302 actual = list({1: -1, 2: -1, 3: -1}) # noqa: C410
7303 self.assertEqual(actual, [1, 2, 3])
7304
7305
7306class LocalsTests(unittest.TestCase):
7307 def test_returns_local_vars(self):
7308 def foo():
7309 a = 4
7310 b = 5
7311 return locals()
7312
7313 result = foo()
7314 self.assertIsInstance(result, dict)
7315 self.assertEqual(len(result), 2)
7316 self.assertEqual(result["a"], 4)
7317 self.assertEqual(result["b"], 5)
7318
7319 def test_returns_free_vars(self):
7320 def foo():
7321 a = 4
7322
7323 def bar():
7324 nonlocal a
7325 a = 5
7326 return locals()
7327
7328 return bar()
7329
7330 result = foo()
7331 self.assertIsInstance(result, dict)
7332 self.assertEqual(len(result), 1)
7333 self.assertEqual(result["a"], 5)
7334
7335 def test_returns_cell_vars(self):
7336 def foo():
7337 a = 4
7338
7339 def bar(b):
7340 return a + b
7341
7342 return locals()
7343
7344 result = foo()
7345 self.assertIsInstance(result, dict)
7346 self.assertEqual(len(result), 2)
7347 self.assertEqual(result["a"], 4)
7348 from types import FunctionType
7349
7350 self.assertIsInstance(result["bar"], FunctionType)
7351
7352 def test_caller_locals_in_class_body_returns_dict_with_class_variables(self):
7353 class C:
7354 foo = 4
7355 bar = 5
7356 baz = locals()
7357
7358 result = C.baz
7359 self.assertIsInstance(result, dict)
7360 self.assertEqual(result["foo"], 4)
7361 self.assertEqual(result["bar"], 5)
7362
7363 def test_caller_locals_in_exec_scope_returns_given_locals_instance(self):
7364 result_key = None
7365 result_value = None
7366
7367 class C:
7368 def __getitem__(self, key):
7369 if key == "locals":
7370 return locals
7371 raise Exception
7372
7373 def __setitem__(self, key, value):
7374 nonlocal result_key
7375 nonlocal result_value
7376 result_key = key
7377 result_value = value
7378
7379 c = C()
7380
7381 exec("result = locals()", {}, c)
7382 self.assertEqual(result_key, "result")
7383 self.assertIs(result_value, c)
7384
7385
7386class LongRangeIteratorTests(unittest.TestCase):
7387 def test_dunder_iter_returns_self(self):
7388 large_int = 2 ** 123
7389 it = iter(range(large_int))
7390 self.assertEqual(iter(it), it)
7391
7392 def test_dunder_length_hint_returns_pending_length(self):
7393 large_int = 2 ** 123
7394 it = iter(range(large_int))
7395 self.assertEqual(it.__length_hint__(), large_int)
7396 it.__next__()
7397 self.assertEqual(it.__length_hint__(), large_int - 1)
7398
7399 def test_dunder_next_returns_ints(self):
7400 large_int = 2 ** 123
7401 it = iter(range(large_int))
7402 for i in [0, 1, 2, 3]:
7403 self.assertEqual(it.__next__(), i)
7404
7405
7406class MappingProxyTests(unittest.TestCase):
7407 def setUp(self):
7408 self.mappingproxy_type = type(type.__dict__)
7409 self.proxy = self.mappingproxy_type({"a": 4})
7410
7411 def test_dunder_contains_with_non_mappingproxy_raises_type_error(self):
7412 with self.assertRaises(TypeError):
7413 self.mappingproxy_type.__contains__(None, None)
7414
7415 def test_dunder_contains_returns_result_from_mapping(self):
7416 self.assertTrue("a" in self.proxy)
7417 self.assertFalse("b" in self.proxy)
7418
7419 def test_dunder_delitem_doesn_not_exist(self):
7420 self.assertFalse(hasattr(self.mappingproxy_type, "__delitem__"))
7421
7422 def test_dunder_getitem_with_non_mappingproxy_type_error(self):
7423 with self.assertRaises(TypeError):
7424 self.mappingproxy_type.__getitem__(None, None)
7425
7426 def test_dunder_getitem_from_mapping(self):
7427 self.assertEqual(self.proxy["a"], 4)
7428
7429 def test_dunder_init_with_non_mapping_type_error(self):
7430 with self.assertRaises(TypeError) as context:
7431 self.mappingproxy_type(1)
7432 self.assertIn(
7433 "mappingproxy() argument must be a mapping, not int", str(context.exception)
7434 )
7435
7436 def test_dunder_init_with_mapping_returns_mappingproxy(self):
7437 m = self.mappingproxy_type({"age": 999, "dexterity": -34})
7438 self.assertIsInstance(m, self.mappingproxy_type)
7439
7440 def test_dunder_iter_with_non_mappingproxy_type_error(self):
7441 with self.assertRaises(TypeError):
7442 self.mappingproxy_type.__iter__(None)
7443
7444 def test_dunder_iter_returns_result_from_mapping(self):
7445 it = iter(self.proxy)
7446 self.assertEqual(next(it), "a")
7447 with self.assertRaises(StopIteration):
7448 next(it)
7449
7450 def test_dunder_len_with_non_mappingproxy_type_error(self):
7451 with self.assertRaises(TypeError):
7452 self.mappingproxy_type.__len__(None)
7453
7454 def test_dunder_len_returns_result_from_mapping(self):
7455 self.assertEqual(len(self.proxy), 1)
7456
7457 def test_dunder_repr_with_non_mappingproxy_type_error(self):
7458 with self.assertRaises(TypeError):
7459 self.mappingproxy_type.__repr__(None)
7460
7461 def test_dunder_repr_returns_result_from_mapping_with_mappingproxy_prefix(self):
7462 self.assertEqual(repr(self.proxy), "mappingproxy({'a': 4})")
7463
7464 def test_dunder_setitem_doesn_not_exist(self):
7465 self.assertFalse(hasattr(self.mappingproxy_type, "__setitem__"))
7466
7467 def test_clear_doesn_not_exist(self):
7468 self.assertFalse(hasattr(self.mappingproxy_type, "clear"))
7469
7470 def test_copy_with_non_mappingproxy_type_error(self):
7471 with self.assertRaises(TypeError):
7472 self.mappingproxy_type.copy(None)
7473
7474 def test_items_returns_result_from_mapping(self):
7475 it = iter(self.proxy.items())
7476 self.assertEqual(next(it), ("a", 4))
7477 with self.assertRaises(StopIteration):
7478 next(it)
7479
7480 def test_keys_with_non_mappingproxy_type_error(self):
7481 with self.assertRaises(TypeError):
7482 self.mappingproxy_type.keys(None)
7483
7484 def test_keys_returns_result_from_mapping(self):
7485 it = iter(self.proxy.keys())
7486 self.assertEqual(next(it), "a")
7487 with self.assertRaises(StopIteration):
7488 next(it)
7489
7490 def test_pop_doesn_not_exist(self):
7491 self.assertFalse(hasattr(self.mappingproxy_type, "pop"))
7492
7493 def test_popitem_doesn_not_exist(self):
7494 self.assertFalse(hasattr(self.mappingproxy_type, "popitem"))
7495
7496 def test_setdefault_doesn_not_exist(self):
7497 self.assertFalse(hasattr(self.mappingproxy_type, "setdefault"))
7498
7499 def test_update_doesn_not_exist(self):
7500 self.assertFalse(hasattr(self.mappingproxy_type, "update"))
7501
7502 def test_values_with_non_mappingproxy_type_error(self):
7503 with self.assertRaises(TypeError):
7504 self.mappingproxy_type.values(None)
7505
7506 def test_values_with_non_mappingproxy_type_error(self):
7507 it = iter(self.proxy.values())
7508 self.assertEqual(next(it), 4)
7509 with self.assertRaises(StopIteration):
7510 next(it)
7511
7512
7513class MemoryviewTests(unittest.TestCase):
7514 def test_ndim_returns_default_value(self):
7515 view = memoryview(b"foobar")
7516 self.assertEqual(view.ndim, 1)
7517
7518 def test_strides_returns_default_value(self):
7519 view = memoryview(b"foobar")
7520 self.assertEqual(view.strides, (1,))
7521
7522 def test_shape_returns_default_value(self):
7523 view = memoryview(b"foobar")
7524 self.assertEqual(view.shape, (6,))
7525
7526 def test_dunder_eq_with_non_memoryview_self_raises_type_error(self):
7527 with self.assertRaises(TypeError):
7528 memoryview.__eq__(1, 2)
7529
7530 def test_dunder_eq_with_non_memoryview_other_returns_not_implemented(self):
7531 view = memoryview(b"foobar")
7532 self.assertIs(view.__eq__(1), NotImplemented)
7533
7534 def test_dunder_eq_with_same_object_returns_true(self):
7535 view = memoryview(b"foobar")
7536 self.assertIs(True, view.__eq__(view))
7537
7538 def test_dunder_eq_with_same_bytes_object_returns_true(self):
7539 content = b"foobar"
7540 view = memoryview(content)
7541 comp = memoryview(content)
7542 self.assertIs(True, view.__eq__(comp))
7543
7544 def test_dunder_eq_with_matching_bytes_returns_true(self):
7545 content = b"foobar"
7546 view = memoryview(content)
7547 self.assertIs(True, view.__eq__(content))
7548
7549 def test_dunder_eq_with_matching_bytearray_returns_true(self):
7550 content = bytearray(b"foobar")
7551 view = memoryview(content)
7552 self.assertIs(True, view.__eq__(content))
7553
7554 def test_dunder_eq_with_sliced_memoryview_returns_false(self):
7555 view = memoryview(b"123456")
7556 sliced = view[:2]
7557 result = memoryview(b"12")
7558 self.assertIs(True, sliced.__eq__(result))
7559
7560 def test_dunder_eq_different_memoryview_values_returns_false(self):
7561 view = memoryview(b"123456")
7562 comp = memoryview(b"135")
7563 self.assertIs(False, view.__eq__(comp))
7564
7565 def test_dunder_enter_and_dunder_exit(self):
7566 view = memoryview(b"foobar")
7567 with view as ctx:
7568 self.assertIs(view, ctx)
7569
7570 def test_format_returns_format_string(self):
7571 view = memoryview(b"asde")
7572 self.assertEqual(view.format, "B")
7573 self.assertEqual(view.cast("h").format, "h")
7574
7575 def test_format_is_read_only(self):
7576 view = memoryview(b"asde")
7577 with self.assertRaises(AttributeError):
7578 view.format = "h"
7579
7580 def test_object_with_bytes_returns_original_object(self):
7581 b = b"foo"
7582 bytes_mem = memoryview(b)
7583 self.assertIs(bytes_mem.obj, b)
7584
7585 ba = bytearray(b"foo")
7586 bytearray_mem = memoryview(ba)
7587 self.assertIs(bytearray_mem.obj, ba)
7588
7589 def test_object_with_bytes_subclass_returns_original_object(self):
7590 class BytesSub(bytes):
7591 pass
7592
7593 bytes_sub = BytesSub(b"foo")
7594 bytes_sub_mem = memoryview(bytes_sub)
7595 self.assertIs(bytes_sub_mem.obj, bytes_sub)
7596
7597 def test_object_with_mmap_returns_original_object(self):
7598 from mmap import mmap
7599
7600 memory = mmap(-1, 4)
7601 memory_mem = memoryview(memory)
7602 self.assertIs(memory_mem.obj, memory)
7603 memory_mem_mem = memoryview(memory_mem)[1:]
7604 self.assertIs(memory_mem_mem.obj, memory)
7605
7606 def test_dunder_getitem_with_non_memoryview_raises_type_error(self):
7607 self.assertRaisesRegex(
7608 TypeError,
7609 "'__getitem__' .* 'memoryview' object.* a 'NoneType'",
7610 memoryview.__getitem__,
7611 None,
7612 1,
7613 )
7614
7615 def test_dunder_getitem_index_too_large_raises_index_error(self):
7616 view = memoryview(b"12345678").cast("I")
7617 with self.assertRaises(IndexError) as context:
7618 memoryview.__getitem__(view, 2)
7619 self.assertIn("index out of bounds", str(context.exception))
7620
7621 def test_dunder_getitem_index_too_small_raises_index_error(self):
7622 view = memoryview(bytes())
7623 with self.assertRaises(IndexError) as context:
7624 memoryview.__getitem__(view, -1)
7625 self.assertIn("index out of bounds", str(context.exception))
7626
7627 def test_dunder_getitem_with_positive_index_returns_value(self):
7628 view = memoryview(b"hello")
7629 self.assertEqual(view[1], ord("e"))
7630
7631 def test_dunder_getitem_with_positive_index_returns_value_on_sliced_mv(self):
7632 view = memoryview(b"drive")
7633 sliced = view[2:]
7634 self.assertEqual(sliced[1], ord("v"))
7635
7636 def test_dunder_getitem_with_negative_index_returns_value(self):
7637 view = memoryview(b"negative")
7638 self.assertEqual(view[-2], ord("v"))
7639
7640 def test_dunder_getitem_with_negative_index_returns_value_on_sliced_mv(self):
7641 view = memoryview(b"negativo")
7642 sliced = view[:3]
7643 self.assertEqual(sliced[-2], ord("e"))
7644
7645 def test_dunder_getitem_with_negative_index_relative_to_end_value(self):
7646 view = memoryview(b"bam")
7647 self.assertEqual(memoryview.__getitem__(view, -3), ord("b"))
7648
7649 def test_dunder_getitem_with_valid_indices_returns_submemoryview(self):
7650 view = memoryview(b"movie")
7651 self.assertEqual(memoryview.__getitem__(view, slice(2, -1)), b"vi")
7652
7653 def test_dunder_getitem_with_negative_start_returns_trailing(self):
7654 view = memoryview(b"bam")
7655 self.assertEqual(memoryview.__getitem__(view, slice(-2, 5)), b"am")
7656
7657 def test_dunder_getitem_with_positive_stop_returns_leading(self):
7658 view = memoryview(b"bam")
7659 self.assertEqual(memoryview.__getitem__(view, slice(2)), b"ba")
7660
7661 def test_dunder_getitem_with_negative_stop_returns_all_but_trailing(self):
7662 view = memoryview(b"bam")
7663 self.assertEqual(memoryview.__getitem__(view, slice(-2)), b"b")
7664
7665 def test_dunder_getitem_with_large_negative_start_returns_copy(self):
7666 view = memoryview(b"bam")
7667 self.assertEqual(memoryview.__getitem__(view, slice(-10, 10)), view)
7668
7669 def test_dunder_getitem_with_large_positive_start_returns_empty(self):
7670 view = memoryview(b"bam")
7671 self.assertEqual(memoryview.__getitem__(view, slice(10, 10)), b"")
7672
7673 def test_dunder_getitem_with_large_negative_stop_returns_empty(self):
7674 view = memoryview(b"bam")
7675 self.assertEqual(memoryview.__getitem__(view, slice(-10)), b"")
7676
7677 def test_dunder_getitem_with_int_subclass_does_not_call_dunder_index(self):
7678 class C(int):
7679 def __index__(self):
7680 raise ValueError("foo")
7681
7682 view = memoryview(b"asde")
7683 self.assertEqual(memoryview.__getitem__(view, C(0)), ord("a"))
7684
7685 def test_dunder_getitem_with_raising_descriptor_propagates_exception(self):
7686 class Desc:
7687 def __get__(self, obj, type):
7688 raise AttributeError("foo")
7689
7690 class C:
7691 __index__ = Desc()
7692
7693 view = memoryview(b"asde")
7694 with self.assertRaises(AttributeError) as context:
7695 memoryview.__getitem__(view, C())
7696 self.assertEqual(str(context.exception), "foo")
7697
7698 def test_dunder_getitem_with_non_int_raises_type_error(self):
7699 view = memoryview(b"asde")
7700 with self.assertRaises(TypeError):
7701 memoryview.__getitem__(view, "3")
7702
7703 def test_dunder_getitem_with_dunder_index_calls_dunder_index(self):
7704 class C:
7705 def __index__(self):
7706 return 2
7707
7708 view = memoryview(b"asde")
7709 self.assertEqual(memoryview.__getitem__(view, C()), ord("d"))
7710
7711 def test_dunder_getitem_with_class_with_index(self):
7712 class IndSet:
7713 def __index__(self):
7714 return 0
7715
7716 view = memoryview(b"hello")
7717 self.assertEqual(view[IndSet()], ord("h"))
7718
7719 def test_dunder_new_with_bytes_subclass_returns_memoryview(self):
7720 class C(bytes):
7721 pass
7722
7723 view = memoryview(C(b"hello"))
7724 self.assertIsInstance(view, memoryview)
7725 self.assertEqual(view, b"hello")
7726
7727 def test_itemsize_returns_size_of_item_chars(self):
7728 src = b"abcd"
7729 view = memoryview(src)
7730 self.assertEqual(view.itemsize, 1)
7731
7732 def test_itemsize_returns_size_of_item_ints(self):
7733 src = b"abcdefgh"
7734 view = memoryview(src).cast("i")
7735 self.assertEqual(view.itemsize, 4)
7736
7737 def test_mmap_creates_memoryview_with_correct_permissions(self):
7738 import mmap
7739
7740 writable = mmap.mmap(-1, 6)
7741 writable_view = memoryview(writable)
7742 self.assertEqual(writable_view.readonly, False)
7743 self.assertEqual(writable_view.format, "B")
7744 self.assertEqual(writable_view.nbytes, 6)
7745 del writable_view
7746 writable.close()
7747
7748 readable = mmap.mmap(-1, 6, access=mmap.ACCESS_READ)
7749 readable_view = memoryview(readable)
7750 self.assertEqual(readable_view.readonly, True)
7751 self.assertEqual(readable_view.format, "B")
7752 self.assertEqual(readable_view.nbytes, 6)
7753 del readable_view
7754 readable.close()
7755
7756 def test_nbytes_returns_size_of_memoryview(self):
7757 view = memoryview(b"foobar")
7758 self.assertEqual(view.nbytes, 6)
7759
7760 def test_release_does_nothing(self):
7761 view = memoryview(b"foobar")
7762 view.release()
7763
7764 def test_setitem_with_non_memoryview_raises_type_error(self):
7765 self.assertRaisesRegex(
7766 TypeError,
7767 "'__setitem__' .* 'memoryview' object.* a 'NoneType'",
7768 memoryview.__setitem__,
7769 None,
7770 1,
7771 1,
7772 )
7773
7774 def test_setitem_with_bytes_memoryview_raises_type_error(self):
7775 view = memoryview(b"foobar")
7776 with self.assertRaises(TypeError) as context:
7777 view[0] = 1
7778 self.assertIn("cannot modify read-only memory", str(context.exception))
7779
7780 def test_setitem_with_too_big_index_raises_index_error(self):
7781 view = memoryview(bytearray(b"12345678")).cast("I")
7782 with self.assertRaises(IndexError) as context:
7783 view[2] = None
7784 self.assertIn("index out of bounds", str(context.exception))
7785
7786 def test_setitem_with_negative_index(self):
7787 view = memoryview(bytearray(b"hello"))
7788 m = ord("m")
7789 view[-2] = m
7790 self.assertEqual(view[3], m)
7791
7792 def test_setitem_with_class_with_index(self):
7793 class IndSet:
7794 def __index__(self):
7795 return 0
7796
7797 view = memoryview(bytearray(b"hello"))
7798 m = ord("m")
7799 view[IndSet()] = m
7800 self.assertEqual(view[0], m)
7801
7802 def test_setitem_with_slices_and_non_byteslike_raises_type_error(self):
7803 view = memoryview(bytearray(b"hello"))
7804 with self.assertRaises(TypeError) as context:
7805 view[:1] = 0
7806 self.assertIn(
7807 "a bytes-like object is required, not 'int'", str(context.exception)
7808 )
7809
7810 def test_setitem_with_bytes_and_different_format_raises_value_error(self):
7811 view = memoryview(bytearray(b"0000")).cast("h")
7812 with self.assertRaises(ValueError) as context:
7813 view[:1] = b"a"
7814 self.assertIn(
7815 "memoryview assignment: lvalue and rvalue have different structures",
7816 str(context.exception),
7817 )
7818
7819 def test_setitem_with_bytearray_and_different_format_raises_value_error(self):
7820 view = memoryview(bytearray(b"0000")).cast("h")
7821 with self.assertRaises(ValueError) as context:
7822 view[:1] = bytearray(b"a")
7823 self.assertIn(
7824 "memoryview assignment: lvalue and rvalue have different structures",
7825 str(context.exception),
7826 )
7827
7828 def test_setitem_with_memoryview_and_different_format_raises_value_error(self):
7829 view = memoryview(bytearray(b"0000")).cast("h")
7830 with self.assertRaises(ValueError) as context:
7831 view[:1] = memoryview(b"a")
7832 self.assertIn(
7833 "memoryview assignment: lvalue and rvalue have different structures",
7834 str(context.exception),
7835 )
7836
7837 def test_setitem_with_byteslike_of_wrong_size_raises_value_error(self):
7838 view = memoryview(bytearray(b"0000"))
7839 with self.assertRaises(ValueError) as context:
7840 view[:2] = memoryview(b"a")
7841 self.assertIn(
7842 "memoryview assignment: lvalue and rvalue have different structures",
7843 str(context.exception),
7844 )
7845
7846 def test_setitem_with_zero_len_slice_and_empty_bytes_raises_type_error(self):
7847 content = b"foobar"
7848 view = memoryview(content)
7849 with self.assertRaises(TypeError) as context:
7850 view[:0] = b""
7851 self.assertIn("cannot modify read-only memory", str(context.exception))
7852
7853 def test_setitem_with_zero_len_slice_and_nonempty_bytes_raises_value_error(self):
7854 content = bytearray(b"foobar")
7855 view = memoryview(content)
7856 with self.assertRaises(ValueError) as context:
7857 view[:0] = b"123"
7858 self.assertIn(
7859 "memoryview assignment: lvalue and rvalue have different structures",
7860 str(context.exception),
7861 )
7862
7863 def test_setitem_with_zero_len_slice_and_empty_bytes_value_returns_mv_unmodified(
7864 self,
7865 ):
7866 content = bytearray(b"foobar")
7867 view = memoryview(content)
7868 view[:0] = b""
7869 self.assertEqual(view, b"foobar")
7870
7871 def test_setitem_with_zero_len_slice_and_empty_mv_value_returns_mv_unmodified(self):
7872 content = bytearray(b"foobar")
7873 view = memoryview(content)
7874 view[:0] = memoryview(b"")
7875 self.assertEqual(view, b"foobar")
7876
7877 def test_setitem_with_zero_len_slice_and_negative_stop_returns_mv_unmodified(self):
7878 content = bytearray(b"foobar")
7879 view = memoryview(content)
7880 view[:-6] = b""
7881 self.assertEqual(view, b"foobar")
7882
7883 def test_setitem_with_slices_and_bytes_and_step_1(self):
7884 view = memoryview(bytearray(b"0000"))
7885 view[:2] = b"zz"
7886 self.assertEqual(view, b"zz00")
7887
7888 def test_setitem_with_slices_and_bytearray_and_step_1(self):
7889 view = memoryview(bytearray(b"0000"))
7890 view[1:3] = bytearray(b"zz")
7891 self.assertEqual(view, b"0zz0")
7892
7893 def test_setitem_with_slices_and_memoryview_byte_format_and_step_1(self):
7894 view = memoryview(bytearray(b"0000"))
7895 view[:2] = memoryview(b"zz")
7896 self.assertEqual(view, b"zz00")
7897
7898 def test_setitem_with_slices_and_memoryview_short_format_and_step_1(self):
7899 view = memoryview(bytearray(b"0000"))
7900 short_view = view.cast("h")
7901 short_view[:1] = memoryview(b"zz").cast("h")
7902 self.assertEqual(view, b"zz00")
7903
7904 def test_setitem_with_slices_and_bytes_and_step_2(self):
7905 view = memoryview(bytearray(b"0000"))
7906 view[::2] = b"zz"
7907 self.assertEqual(view, b"z0z0")
7908
7909 def test_setitem_with_slices_and_bytearray_and_step_2(self):
7910 view = memoryview(bytearray(b"0000"))
7911 view[1::2] = bytearray(b"zz")
7912 self.assertEqual(view, b"0z0z")
7913
7914 def test_setitem_with_slices_and_memoryview_byte_format_and_step_2(self):
7915 view = memoryview(bytearray(b"0000"))
7916 view[::2] = memoryview(b"zz")
7917 self.assertEqual(view, b"z0z0")
7918
7919 def test_setitem_with_slices_and_memoryview_short_format_and_step_2(self):
7920 view = memoryview(bytearray(b"000000"))
7921 short_view = view.cast("h")
7922 short_view[1::2] = memoryview(b"zz").cast("h")
7923 self.assertEqual(view, b"00zz00")
7924
7925 def test_tobytes_with_non_memoryview_raises_type_error(self):
7926 with self.assertRaisesRegex(
7927 TypeError, "'tobytes'.*'memoryview' object.* a 'int'"
7928 ):
7929 memoryview.tobytes(42)
7930
7931 def test_tobytes_with_bytes_returns_bytes(self):
7932 self.assertEqual(memoryview(b"").tobytes(), b"")
7933 self.assertEqual(memoryview(b"short").tobytes(), b"short")
7934 self.assertEqual(memoryview(b"hello world").tobytes(), b"hello world")
7935 v0 = memoryview(b"hello")
7936 self.assertEqual(v0[0:3].tobytes(), b"hel")
7937 self.assertEqual(v0[:4].cast("i").tobytes(), b"hell")
7938
7939 def test_tobytes_with_bytearray_returns_bytes(self):
7940 self.assertEqual(memoryview(bytearray(b"")).tobytes(), b"")
7941 self.assertEqual(memoryview(bytearray(b"short")).tobytes(), b"short")
7942 self.assertEqual(memoryview(bytearray(b"hello world")).tobytes(), b"hello world")
7943 v0 = memoryview(bytearray(b"hello"))
7944 self.assertEqual(v0[0:3].tobytes(), b"hel")
7945 self.assertEqual(v0[:4].cast("i").tobytes(), b"hell")
7946
7947 def test_tolist_with_non_memoryview_raises_type_error(self):
7948 self.assertRaisesRegex(
7949 TypeError,
7950 "'tolist' .* 'memoryview' object.* a 'NoneType'",
7951 memoryview.tolist,
7952 None,
7953 )
7954
7955 def test_tolist_returns_list_of_elements(self):
7956 src = b"hello"
7957 view = memoryview(src)
7958 self.assertEqual(view.tolist(), [104, 101, 108, 108, 111])
7959
7960 def test_tolist_withitemsize_greater_than_one(self):
7961 src = b"abcd"
7962 view = memoryview(src).cast("i")
7963 self.assertEqual(view.tolist(), [1684234849])
7964
7965 def test_tolist_with_empty_memoryview_returns_empty_list(self):
7966 src = b""
7967 view = memoryview(src)
7968 self.assertEqual(view.tolist(), [])
7969
7970
7971class MethodTests(unittest.TestCase):
7972 def test_dunder_new_with_non_callable_func_raises_type_error(self):
7973 class C:
7974 def method(self):
7975 pass
7976
7977 instance = C()
7978 method_type = type(instance.method)
7979 with self.assertRaises(TypeError) as context:
7980 method_type.__new__(method_type, 1, "foo")
7981
7982 self.assertEqual(str(context.exception), "first argument must be callable")
7983
7984 def test_dunder_new_with_none_self_raises_type_error(self):
7985 class C:
7986 def method(self):
7987 pass
7988
7989 def non_method_function(self):
7990 return self.value
7991
7992 instance = C()
7993 method_type = type(instance.method)
7994 with self.assertRaises(TypeError) as context:
7995 method_type.__new__(method_type, non_method_function, None)
7996
7997 self.assertEqual(str(context.exception), "self must not be None")
7998
7999 def test_dunder_new_returns_bound_method(self):
8000 class C:
8001 def __init__(self, value):
8002 self.value = value
8003
8004 def method(self):
8005 pass
8006
8007 def non_method_function(self):
8008 return self.value
8009
8010 instance = C(10)
8011 method_type = type(instance.method)
8012 result = method_type.__new__(method_type, non_method_function, instance)
8013 self.assertIsInstance(result, method_type)
8014 self.assertEqual(result.__func__, non_method_function)
8015 self.assertEqual(result.__self__, instance)
8016 self.assertEqual(result(), 10)
8017
8018 def test_has_dunder_call(self):
8019 class C:
8020 def bar(self):
8021 pass
8022
8023 C().bar.__getattribute__("__call__")
8024
8025
8026class ModuleTests(unittest.TestCase):
8027 def test_delattr_deletes_module_attribute(self):
8028 from types import ModuleType
8029
8030 m = ModuleType("")
8031 m.fld = 4
8032 self.assertTrue(hasattr(m, "fld"))
8033 self.assertIs(m.__delattr__("fld"), None)
8034 self.assertFalse(hasattr(m, "fld"))
8035
8036 def test_delattr_raises_type_error_with_instance(self):
8037 from types import ModuleType
8038
8039 class C:
8040 fld = 4
8041
8042 c = C()
8043 self.assertRaisesRegex(
8044 TypeError,
8045 "'__delattr__' .* 'module' object.* a 'C'",
8046 ModuleType.__delattr__,
8047 c,
8048 "fld",
8049 )
8050
8051 def test_del_invalidates_cache(self):
8052 from types import ModuleType
8053
8054 mymodule = ModuleType("mymodule")
8055 mymodule.x = 40
8056 exec("def foo(): return x", mymodule.__dict__)
8057 result = mymodule.foo()
8058 self.assertEqual(result, 40)
8059
8060 del mymodule.x
8061
8062 with self.assertRaises(NameError) as context:
8063 mymodule.foo()
8064 self.assertEqual(str(context.exception), "name 'x' is not defined")
8065
8066 def test_dunder_dict_with_non_module_raises_type_error(self):
8067 from types import ModuleType
8068
8069 with self.assertRaises(TypeError):
8070 ModuleType.__dict__["__dict__"].__get__(42)
8071
8072 def test_dunder_dir_returns_newly_created_list_object(self):
8073 from types import ModuleType
8074
8075 mymodule = ModuleType("mymodule")
8076 self.assertEqual(type(mymodule.__dir__()), list)
8077 self.assertIsNot(mymodule.__dir__(), mymodule.__dir__())
8078
8079 def test_dunder_dir_returns_list_containing_module_attributes(self):
8080 from types import ModuleType
8081
8082 mymodule = ModuleType("mymodule")
8083 mymodule.x = 40
8084 mymodule.y = 50
8085 result = mymodule.__dir__()
8086 self.assertIn("x", result)
8087 self.assertIn("y", result)
8088
8089 def test_dunder_dir_returns_list_containing_added_module_attributes(self):
8090 from types import ModuleType
8091
8092 mymodule = ModuleType("mymodule")
8093 self.assertNotIn("z", mymodule.__dir__())
8094
8095 mymodule.z = 60
8096 self.assertIn("z", mymodule.__dir__())
8097
8098 def test_dunder_dir_returns_list_not_containing_deleted_module_attributes(self):
8099 from types import ModuleType
8100
8101 mymodule = ModuleType("mymodule")
8102 mymodule.x = 40
8103 self.assertIn("x", mymodule.__dir__())
8104
8105 del mymodule.x
8106 self.assertNotIn("x", mymodule.__dir__())
8107
8108 def test_dunder_new_with_subclass_returns_object(self):
8109 from types import ModuleType
8110
8111 class C(ModuleType):
8112 pass
8113
8114 m = ModuleType.__new__(C)
8115 self.assertEqual(type(m), C)
8116 self.assertIsInstance(m, ModuleType)
8117 # Do some sanity checking that half-initialized modules do not crash.
8118 self.assertEqual(repr(m), "<module '?'>")
8119 with self.assertRaises(AttributeError) as context:
8120 ModuleType.__getattribute__(m, "foo")
8121 self.assertEqual(str(context.exception), "module has no attribute 'foo'")
8122
8123 def test_dunder_new_accepts_extra_arguments(self):
8124 from types import ModuleType
8125
8126 m = ModuleType.__new__(ModuleType, 42, "foo", bar=None)
8127 self.assertIsInstance(m, ModuleType)
8128 self.assertEqual(repr(m), "<module '?'>")
8129
8130 def test_dunder_init_sets_fields(self):
8131 from types import ModuleType
8132
8133 m = ModuleType.__new__(ModuleType)
8134 ModuleType.__init__(m, "foo")
8135 self.assertEqual(
8136 dir(m), ["__doc__", "__loader__", "__name__", "__package__", "__spec__"]
8137 )
8138 self.assertIs(m.__doc__, None)
8139 self.assertIs(m.__loader__, None)
8140 self.assertEqual(m.__name__, "foo")
8141 self.assertIs(m.__package__, None)
8142 self.assertIs(m.__spec__, None)
8143
8144 def test_dunder_new_with_non_type_raises_type_error(self):
8145 from types import ModuleType
8146
8147 with self.assertRaises(TypeError) as context:
8148 ModuleType.__new__(42, "")
8149 self.assertEqual(
8150 str(context.exception), "module.__new__(X): X is not a type object (int)"
8151 )
8152
8153 def test_dunder_new_with_non_module_subtype_raise_type_error(self):
8154 from types import ModuleType
8155
8156 class C:
8157 pass
8158
8159 with self.assertRaises(TypeError) as context:
8160 ModuleType.__new__(C, "")
8161 self.assertEqual(
8162 str(context.exception), "module.__new__(C): C is not a subtype of module"
8163 )
8164
8165 def test_non_module_with_module_getattribute(self):
8166 from types import ModuleType
8167
8168 class C:
8169 __getattribute__ = ModuleType.__getattribute__
8170
8171 c = C()
8172 with self.assertRaises(TypeError):
8173 c.foo
8174
8175 def test_module_subclass_getattribute(self):
8176 from types import ModuleType
8177
8178 class M(ModuleType):
8179 pass
8180
8181 mod = M("a_module")
8182 mod.foo = "bar"
8183 # TODO(T58719879): Add a test that reliably uses LOAD_ATTR_MODULE as
8184 # appropriate in Pyro.
8185 for _i in range(2):
8186 self.assertEqual(mod.foo, "bar")
8187
8188
8189class ModuleProxyTests(unittest.TestCase):
8190 def setUp(self):
8191 from types import ModuleType
8192
8193 self.module = ModuleType("test_module")
8194 self.module_proxy = self.module.__dict__
8195
8196 # Create a placeholder in the module dict for a builtin.
8197 module_code = """
8198def make_placeholder():
8199 return placeholder
8200 """
8201 exec(module_code, self.module_proxy)
8202
8203 builtins = ModuleType("builtins")
8204 builtins.placeholder = "builtin_value"
8205 self.module.__builtins__ = builtins
8206 self.assertEqual(self.module.make_placeholder(), "builtin_value")
8207
8208 def test_dunder_contains_with_non_module_proxy_raises_type_error(self):
8209 with self.assertRaises(TypeError):
8210 type(self.module_proxy).__contains__(None, None)
8211
8212 def test_dunder_contains_returns_true_for_existing_item(self):
8213 self.module.x = 40
8214 self.assertTrue(self.module_proxy.__contains__("x"))
8215
8216 def test_dunder_contains_returns_false_for_not_existing_item(self):
8217 self.assertFalse(self.module_proxy.__contains__("x"))
8218
8219 def test_dunder_contains_returns_false_for_placeholder(self):
8220 self.assertFalse(self.module_proxy.__contains__("placeholder"))
8221
8222 def test_dunder_repr_returns_string(self):
8223 from types import ModuleType
8224
8225 module_proxy = ModuleType("my_module").__dict__
8226 for key in tuple(module_proxy.keys()):
8227 if key != "__name__":
8228 del module_proxy[key]
8229
8230 self.assertEqual(module_proxy.__repr__(), "{'__name__': 'my_module'}")
8231
8232 def test_dunder_repr_with_recursion_returns_string_with_ellipsis(self):
8233 from types import ModuleType
8234
8235 module_proxy = ModuleType("my_module").__dict__
8236 for key in tuple(module_proxy.keys()):
8237 del module_proxy[key]
8238 module_proxy["self"] = module_proxy
8239
8240 self.assertEqual(module_proxy.__repr__(), "{'self': {...}}")
8241
8242 def test_copy_with_non_module_proxy_raises_type_error(self):
8243 with self.assertRaises(TypeError):
8244 type(self.module_proxy).copy(None)
8245
8246 def test_copy_returns_dict_copy(self):
8247 self.module.x = 40
8248 result = self.module_proxy.copy()
8249 self.assertEqual(type(result), dict)
8250 self.assertEqual(result["x"], 40)
8251 self.module.y = 50
8252 self.assertNotIn("y", result)
8253
8254 def test_dunder_delitem_with_non_module_proxy_raises_type_error(self):
8255 with self.assertRaises(TypeError):
8256 self.module_proxy.__delitem__(None, None)
8257
8258 def test_dunder_delitem_deletes_module_variable_and_raises_name_error(self):
8259 module_code = """
8260x = 40
8261def foo():
8262 return x
8263foo()
8264 """
8265 exec(module_code, self.module_proxy)
8266 self.assertEqual(self.module.foo(), 40)
8267
8268 self.module_proxy.__delitem__("x")
8269
8270 with self.assertRaises(NameError) as context:
8271 self.module.foo()
8272 self.assertIn("name 'x' is not defined", str(context.exception))
8273
8274 def test_dunder_delitem_for_non_existing_key_raises_key_error(self):
8275 with self.assertRaises(KeyError) as context:
8276 self.module_proxy.__delitem__("x")
8277 self.assertIn("'x'", str(context.exception))
8278
8279 def test_clear_with_non_module_proxy_raises_type_error(self):
8280 with self.assertRaises(TypeError):
8281 self.module_proxy.clear(None)
8282
8283 def test_clear_deletes_module_variables_and_raises_attribute_error(self):
8284 module_code = """
8285x = 40
8286def foo():
8287 return x
8288foo()
8289 """
8290 exec(module_code, self.module_proxy)
8291 self.assertEqual(self.module.foo(), 40)
8292
8293 self.module_proxy.clear()
8294
8295 self.assertEqual(len(self.module_proxy), 0)
8296 self.assertNotIn("x", self.module_proxy)
8297 self.assertNotIn("foo", self.module_proxy)
8298
8299 with self.assertRaises(AttributeError) as context:
8300 self.module.foo()
8301 self.assertIn("has no attribute 'foo'", str(context.exception))
8302
8303 def test_dunder_getitem_with_non_module_proxy_raises_type_error(self):
8304 with self.assertRaises(TypeError):
8305 type(self.module_proxy).__getitem__(None, None)
8306
8307 def test_dunder_getitem_for_existing_key_returns_that_item(self):
8308 self.module.x = 40
8309 self.assertEqual(self.module_proxy.__getitem__("x"), 40)
8310
8311 def test_dunder_getitem_for_not_existing_key_raises_key_error(self):
8312 with self.assertRaises(KeyError) as context:
8313 self.module_proxy.__getitem__("x")
8314 self.assertIn("'x'", str(context.exception))
8315
8316 def test_dunder_getitem_for_placeholder_raises_key_error(self):
8317 with self.assertRaises(KeyError) as context:
8318 self.module_proxy.__getitem__("placeholder")
8319 self.assertIn("'placeholder'", str(context.exception))
8320
8321 def test_dunder_iter_with_non_module_proxy_raises_type_error(self):
8322 with self.assertRaises(TypeError):
8323 type(self.module_proxy).__iter__(None)
8324
8325 def test_dunder_iter_returns_key_iterator(self):
8326 self.module.x = 40
8327 self.module.y = 50
8328 result = self.module_proxy.__iter__()
8329 self.assertTrue(hasattr(result, "__next__"))
8330 result_list = list(result)
8331 self.assertIn("x", result_list)
8332 self.assertIn("y", result_list)
8333
8334 def test_dunder_len_with_non_module_proxy_raises_type_error(self):
8335 with self.assertRaises(TypeError):
8336 type(self.module_proxy).__len__(None)
8337
8338 def test_dunder_len_returns_num_items(self):
8339 length = self.module_proxy.__len__()
8340 self.module.x = 40
8341 self.assertEqual(self.module_proxy.__len__(), length + 1)
8342
8343 def test_dunder_len_returns_num_items_excluding_placeholder(self):
8344 length = self.module_proxy.__len__()
8345 # Overwrite the existing placeholder by creating a real one under the same name.
8346 self.module.placeholder = 1
8347 self.assertEqual(self.module_proxy.__len__(), length + 1)
8348
8349 def test_dunder_repr_with_non_module_proxy_raises_type_error(self):
8350 with self.assertRaises(TypeError):
8351 type(self.module_proxy).__repr__(None)
8352
8353 def test_dunder_repr_returns_str_containing_existing_items(self):
8354 self.module.x = 40
8355 self.module.y = 50
8356 result = self.module_proxy.__repr__()
8357 self.assertIsInstance(result, str)
8358 self.assertIn("'x': 40", result)
8359 self.assertIn("'y': 50", result)
8360
8361 def test_dunder_repr_returns_str_not_containing_placeholder(self):
8362 result = self.module_proxy.__repr__()
8363 self.assertNotIn("'placeholder'", result)
8364
8365 def test_dunder_setitem_with_non_module_proxy_raises_type_error(self):
8366 with self.assertRaises(TypeError):
8367 type(self.module_proxy).__setitem__(None, None, None)
8368
8369 def test_dunder_setitem_sets_item_showing_up_in_module(self):
8370 self.module_proxy.__setitem__("a", 1)
8371 self.assertEqual(self.module.a, 1)
8372
8373 def test_dunder_setitem_with_existing_item_updates_module_variable(self):
8374 module_code = """
8375x = 40
8376def foo():
8377 return x
8378foo()
8379 """
8380 exec(module_code, self.module_proxy)
8381 self.assertEqual(self.module.foo(), 40)
8382
8383 self.module_proxy.__setitem__("x", 50)
8384 self.assertEqual(self.module.foo(), 50)
8385
8386 def test_dunder_setitem_with_placeholder_updates_module_variable(self):
8387 module_code = """
8388def foo():
8389 return x
8390 """
8391 exec(module_code, self.module_proxy)
8392
8393 from types import ModuleType
8394
8395 builtins = ModuleType("builtins")
8396 builtins.x = 40
8397 self.module.__builtins__ = builtins
8398 self.assertEqual(self.module.foo(), 40)
8399
8400 self.module_proxy.__setitem__("x", 50)
8401 self.assertEqual(self.module.foo(), 50)
8402
8403 def test_get_with_non_module_proxy_raises_type_error(self):
8404 with self.assertRaises(TypeError):
8405 type(self.module_proxy).get(None, None)
8406
8407 def test_get_returns_existing_item_value(self):
8408 self.module.x = 40
8409 self.assertEqual(self.module_proxy.get("x"), 40)
8410
8411 def test_get_with_default_for_non_existing_item_value_returns_that_default(self):
8412 self.assertEqual(self.module_proxy.get("x", -1), -1)
8413
8414 def test_get_for_non_existing_item_returns_none(self):
8415 self.assertIs(self.module_proxy.get("x"), None)
8416
8417 def test_get_for_placeholder_returns_none(self):
8418 self.assertIs(self.module_proxy.get("placeholder"), None)
8419
8420 def test_items_with_non_module_proxy_raises_type_error(self):
8421 with self.assertRaises(TypeError):
8422 type(self.module_proxy).items(None)
8423
8424 def test_items_returns_container_for_key_value_pairs(self):
8425 self.module.x = 40
8426 self.module.y = 50
8427 result = self.module_proxy.items()
8428 self.assertTrue(hasattr(result, "__iter__"))
8429 result_list = list(iter(result))
8430 self.assertIn(("x", 40), result_list)
8431 self.assertIn(("y", 50), result_list)
8432
8433 def test_keys_with_non_module_proxy_raises_type_error(self):
8434 with self.assertRaises(TypeError):
8435 type(self.module_proxy).keys(None)
8436
8437 def test_keys_returns_container_for_keys(self):
8438 self.module.x = 40
8439 self.module.y = 50
8440 result = self.module_proxy.keys()
8441 self.assertTrue(hasattr(result, "__iter__"))
8442 result_list = list(iter(result))
8443 self.assertIn("x", result_list)
8444 self.assertIn("y", result_list)
8445
8446 def test_keys_returns_key_iterator_excluding_placeholder(self):
8447 result = self.module_proxy.keys()
8448 self.assertNotIn("placeholder", result)
8449
8450 def test_pop_with_non_module_proxy_raises_type_error(self):
8451 with self.assertRaises(TypeError):
8452 type(self.module_proxy).pop(None)
8453
8454 def test_pop_for_existing_item_deletes_and_returns_that_item_value(self):
8455 self.module.x = 40
8456 value = self.module_proxy.pop("x")
8457 self.assertEqual(value, 40)
8458 self.assertFalse(self.module_proxy.__contains__("x"))
8459
8460 def test_pop_for_not_existing_item_raises_key_error(self):
8461 with self.assertRaises(KeyError) as context:
8462 self.module_proxy.pop("x")
8463 self.assertIn("'x'", str(context.exception))
8464
8465 def test_pop_with_default_for_not_existing_item_returns_default(self):
8466 value = self.module_proxy.pop("x", -1)
8467 self.assertEqual(value, -1)
8468
8469 def test_pop_for_placeholder_raises_key_error(self):
8470 with self.assertRaises(KeyError) as context:
8471 self.module_proxy.pop("placeholder")
8472 self.assertIn("'placeholder'", str(context.exception))
8473
8474 def test_setdefault_with_non_module_proxy_raises_type_error(self):
8475 with self.assertRaises(TypeError):
8476 type(self.module_proxy).setdefault(None, None)
8477
8478 def test_setdefault_for_existing_item_does_nothing(self):
8479 self.module.x = 40
8480 self.module_proxy.setdefault("x", -1)
8481 self.assertEqual(self.module_proxy.get("x"), 40)
8482
8483 def test_setdefault_for_not_existing_item_sets_default_value(self):
8484 self.module_proxy.setdefault("x", -1)
8485 self.assertEqual(self.module_proxy.get("x"), -1)
8486
8487 def test_update_with_non_module_proxy_raises_type_error(self):
8488 with self.assertRaises(TypeError):
8489 type(self.module_proxy).update(None)
8490
8491 def test_update_with_multiple_positional_arguments_raises_type_error(self):
8492 with self.assertRaises(TypeError):
8493 self.module_proxy.update({"x": 40}, {"y": 50})
8494
8495 def test_update_with_dict_updates_module_proxy_and_module(self):
8496 d = {"x": 40, "y": 50}
8497 self.assertIsNone(self.module_proxy.update(d))
8498 self.assertEqual(self.module_proxy.get("x"), 40)
8499 self.assertEqual(self.module_proxy.get("y"), 50)
8500 self.assertEqual(self.module.x, 40)
8501 self.assertEqual(self.module.y, 50)
8502
8503 def test_update_with_iterable_updates_module_proxy_and_module(self):
8504 class Iterable:
8505 def __iter__(self):
8506 return iter([("x", 40), ("y", 50)])
8507
8508 iterable = Iterable()
8509 self.assertIsNone(self.module_proxy.update(iterable))
8510 self.assertEqual(self.module_proxy.get("x"), 40)
8511 self.assertEqual(self.module_proxy.get("y"), 50)
8512 self.assertEqual(self.module.x, 40)
8513 self.assertEqual(self.module.y, 50)
8514
8515 def test_update_with_iterable_of_non_pair_tuple_raises_value_error(self):
8516 class Iterable:
8517 def __iter__(self):
8518 return iter([("x", 40), ("y", 50, 60)])
8519
8520 iterable = Iterable()
8521 with self.assertRaises(ValueError) as context:
8522 self.assertIsNone(self.module_proxy.update(iterable))
8523 self.assertIn(
8524 "dictionary update sequence element #1 has length 3; 2 is required",
8525 str(context.exception),
8526 )
8527
8528 def test_update_with_kwargs_updates_module_proxy_and_module(self):
8529 self.assertNotIn("x", self.module_proxy)
8530 self.assertNotIn("y", self.module_proxy)
8531 self.assertIsNone(self.module_proxy.update(y=50, x=40))
8532 self.assertEqual(self.module_proxy.get("x"), 40)
8533 self.assertEqual(self.module_proxy.get("y"), 50)
8534 self.assertEqual(self.module.x, 40)
8535 self.assertEqual(self.module.y, 50)
8536
8537 def test_update_with_dict_and_kwargs_updates_module_proxy_and_module(self):
8538 self.assertNotIn("x", self.module_proxy)
8539 self.assertNotIn("y", self.module_proxy)
8540 self.assertIsNone(self.module_proxy.update({"y": 50}, x=40))
8541 self.assertEqual(self.module_proxy.get("x"), 40)
8542 self.assertEqual(self.module_proxy.get("y"), 50)
8543 self.assertEqual(self.module.x, 40)
8544 self.assertEqual(self.module.y, 50)
8545
8546 def test_update_with_dict_and_kwargs_gives_kwargs_precedence(self):
8547 self.assertNotIn("y", self.module_proxy)
8548 self.assertIsNone(self.module_proxy.update({"y": 50}, y=60))
8549 self.assertEqual(self.module_proxy.get("y"), 60)
8550 self.assertEqual(self.module.y, 60)
8551
8552 def test_update_with_self_in_kwargs_puts_self_in_attributes(self):
8553 self.assertNotIn("self", self.module_proxy)
8554 self.assertIsNone(self.module_proxy.update(self=60))
8555 self.assertEqual(self.module_proxy.get("self"), 60)
8556 self.assertEqual(self.module.self, 60)
8557
8558 def test_values_with_non_module_proxy_raises_type_error(self):
8559 with self.assertRaises(TypeError):
8560 type(self.module_proxy).values(None)
8561
8562 def test_values_returns_container_for_values(self):
8563 self.module.x = 1243314135
8564 self.module.y = -1243314135
8565 result = self.module_proxy.values()
8566 self.assertTrue(hasattr(result, "__iter__"))
8567 result_list = list(iter(result))
8568 self.assertIn(1243314135, result_list)
8569 self.assertIn(-1243314135, result_list)
8570
8571 def test_values_returns_iterator_excluding_placeholder_value(self):
8572 result = self.module_proxy.values()
8573 self.assertNotIn("builtin_value", result)
8574
8575
8576class NextTests(unittest.TestCase):
8577 def test_next_with_raising_dunder_next_propagates_error(self):
8578 class Desc:
8579 def __get__(self, obj, type):
8580 raise AttributeError("failed")
8581
8582 class Foo:
8583 __next__ = Desc()
8584
8585 foo = Foo()
8586 with self.assertRaises(AttributeError) as context:
8587 next(foo)
8588 self.assertEqual(str(context.exception), "failed")
8589
8590 def test_next_with_dict_keyiterater_returns_next_item(self):
8591 d = {"a": 0}
8592 dict_keyiter = iter(d.keys())
8593 self.assertEqual(next(dict_keyiter), "a")
8594
8595 def test_next_with_empty_dict_keyiterator_returns_default(self):
8596 d = {}
8597 dict_keyiter = iter(d.keys())
8598 self.assertEqual(next(dict_keyiter, None), None)
8599
8600 def test_next_with_empty_dict_keyiterator_raises_stop_iteration(self):
8601 d = {}
8602 dict_keyiter = iter(d.keys())
8603 with self.assertRaises(StopIteration):
8604 next(dict_keyiter)
8605
8606 def test_next_with_list_iterater_returns_next_item(self):
8607 li = [1]
8608 list_iter = iter(li)
8609 self.assertEqual(next(list_iter), 1)
8610
8611 def test_next_with_empty_list_iterator_returns_default(self):
8612 li = []
8613 list_iter = iter(li)
8614 self.assertEqual(next(list_iter, None), None)
8615
8616 def test_next_with_empty_list_iterator_raises_stop_iteration(self):
8617 li = []
8618 list_iter = iter(li)
8619 with self.assertRaises(StopIteration):
8620 next(list_iter)
8621
8622 def test_next_with_range_iterater_returns_next_item(self):
8623 ran = range(1)
8624 range_iter = iter(ran)
8625 self.assertEqual(next(range_iter), 0)
8626
8627 def test_next_with_empty_range_iterator_returns_default(self):
8628 ran = range(0)
8629 range_iter = iter(ran)
8630 self.assertEqual(next(range_iter, None), None)
8631
8632 def test_next_with_empty_range_iterator_raises_stop_iteration(self):
8633 ran = range(0)
8634 range_iter = iter(ran)
8635 with self.assertRaises(StopIteration):
8636 next(range_iter)
8637
8638 def test_next_with_set_iterater_returns_next_item(self):
8639 s = {0}
8640 set_iter = iter(s)
8641 self.assertEqual(next(set_iter), 0)
8642
8643 def test_next_with_empty_set_iterator_returns_default(self):
8644 set_iter = iter(set())
8645 self.assertEqual(next(set_iter, None), None)
8646
8647 def test_next_with_empty_set_iterator_raises_stop_iteration(self):
8648 set_iter = iter(set())
8649 with self.assertRaises(StopIteration):
8650 next(set_iter)
8651
8652 def test_next_with_set_iterator_raises_stop_iteration(self):
8653 s = {0}
8654 set_iter = iter(s)
8655 self.assertEqual(next(set_iter), 0)
8656 with self.assertRaises(StopIteration):
8657 next(set_iter)
8658
8659 def test_next_with_str_iterater_returns_next_item(self):
8660 str = "a"
8661 str_iter = iter(str)
8662 self.assertEqual(next(str_iter), "a")
8663
8664 def test_next_with_empty_str_iterator_returns_default(self):
8665 str = ""
8666 str_iter = iter(str)
8667 self.assertEqual(next(str_iter, None), None)
8668
8669 def test_next_with_empty_str_iterator_raises_stop_iteration(self):
8670 str = ""
8671 str_iter = iter(str)
8672 with self.assertRaises(StopIteration):
8673 next(str_iter)
8674
8675 def test_next_with_str_iterator_raises_stop_iteration(self):
8676 str = "abc"
8677 str_iter = iter(str)
8678 self.assertEqual(next(str_iter), "a")
8679 self.assertEqual(next(str_iter), "b")
8680 self.assertEqual(next(str_iter), "c")
8681 with self.assertRaises(StopIteration):
8682 next(str_iter)
8683
8684 def test_next_with_tuple_iterater_returns_next_item(self):
8685 t = (1,)
8686 tuple_iter = iter(t)
8687 self.assertEqual(next(tuple_iter), 1)
8688
8689 def test_next_with_empty_tuple_iterator_returns_default(self):
8690 t = ()
8691 tuple_iter = iter(t)
8692 self.assertEqual(next(tuple_iter, None), None)
8693
8694 def test_next_with_empty_tuple_iterator_raises_stop_iteration(self):
8695 t = ()
8696 tuple_iter = iter(t)
8697 with self.assertRaises(StopIteration):
8698 next(tuple_iter)
8699
8700
8701class NoneTests(unittest.TestCase):
8702 def test_dunder_class_returns_type_of_none(self):
8703 self.assertEqual(None.__class__, type(None))
8704
8705 def test_dunder_class_assignment_raises_type_error(self):
8706 class C:
8707 pass
8708
8709 with self.assertRaises(TypeError):
8710 type(None).__class__ = C
8711
8712
8713class NotImplementedTypeTests(unittest.TestCase):
8714 def test_repr_returns_not_implemented(self):
8715 self.assertEqual(NotImplemented.__repr__(), "NotImplemented")
8716
8717
8718class ObjectTests(unittest.TestCase):
8719 def test_delattr_deletes_instance_attribute(self):
8720 class C:
8721 def __init__(self):
8722 self.fld = 4
8723
8724 c = C()
8725 self.assertTrue(hasattr(c, "fld"))
8726 self.assertIs(c.__delattr__("fld"), None)
8727 self.assertFalse(hasattr(c, "fld"))
8728
8729 def test_delattr_raises_type_error_with_type(self):
8730 class C:
8731 fld = 4
8732
8733 with self.assertRaises(TypeError) as context:
8734 object.__delattr__(C, "fld")
8735 self.assertIn("can't apply this __delattr__ to type", str(context.exception))
8736
8737 @pyro_only
8738 def test_delattr_raises_with_module(self):
8739 from types import ModuleType
8740
8741 m = ModuleType("")
8742 m.fld = 4
8743 with self.assertRaises(TypeError) as context:
8744 object.__delattr__(m, "fld")
8745 self.assertIn(
8746 "can't apply this __delattr__ to type 'module'", str(context.exception)
8747 )
8748
8749 def test_reduce_with_object(self):
8750 result = object().__reduce__()
8751 self.assertEqual(len(result), 2)
8752 self.assertEqual(result[1], (object, object, None))
8753
8754 def test_reduce_with_custom_type_without_attributes(self):
8755 class Foo:
8756 pass
8757
8758 result = Foo().__reduce__()
8759 self.assertEqual(len(result), 2)
8760 self.assertEqual(result[1], (Foo, object, None))
8761
8762 def test_reduce_with_custom_type(self):
8763 class Foo:
8764 def __init__(self):
8765 self.a = 1
8766
8767 result = Foo().__reduce__()
8768 self.assertEqual(len(result), 3)
8769 self.assertEqual(result[1:], ((Foo, object, None), {"a": 1}))
8770
8771 def test_reduce_with_custom_base(self):
8772 class Foo:
8773 def __init__(self):
8774 self.a = 1
8775
8776 class Bar(Foo):
8777 def __init__(self):
8778 Foo.__init__(self)
8779 self.b = 2
8780
8781 result = Bar().__reduce__()
8782 self.assertEqual(len(result), 3)
8783 self.assertEqual(result[1:], ((Bar, object, None), {"a": 1, "b": 2}))
8784
8785 def test_reduce_with_getstate(self):
8786 class Foo:
8787 def __init__(self):
8788 self.a = 1
8789
8790 def __getstate__(self):
8791 return {"b": 2}
8792
8793 result = Foo().__reduce__()
8794 self.assertEqual(len(result), 3)
8795 self.assertEqual(result[1], (Foo, object, None), {"b": 2})
8796
8797 def test_reduce_ex_with_object(self):
8798 result = object().__reduce_ex__(0)
8799 self.assertEqual(len(result), 2)
8800 self.assertEqual(result[1], (object, object, None))
8801
8802 def test_reduce_ex_with_object_and_proto_three(self):
8803 result = object().__reduce_ex__(3)
8804 self.assertEqual(len(result), 5)
8805 self.assertEqual(result[1:], ((object,), None, None, None))
8806
8807 def test_reduce_ex_with_custom_type_without_attributes(self):
8808 class Foo:
8809 pass
8810
8811 result = Foo().__reduce_ex__(0)
8812 self.assertEqual(len(result), 2)
8813 self.assertEqual(result[1], (Foo, object, None))
8814
8815 def test_reduce_ex_with_custom_type_without_attributes_and_proto_three(self):
8816 class Foo:
8817 pass
8818
8819 result = Foo().__reduce_ex__(3)
8820 self.assertEqual(len(result), 5)
8821 self.assertEqual(result[1:], ((Foo,), None, None, None))
8822
8823 def test_reduce_ex_with_custom_type(self):
8824 class Foo:
8825 def __init__(self):
8826 self.a = 1
8827
8828 result = Foo().__reduce_ex__(0)
8829 self.assertEqual(len(result), 3)
8830 self.assertEqual(result[1], (Foo, object, None), {"a": 1})
8831
8832 def test_reduce_ex_with_custom_type_and_proto_three(self):
8833 class Foo:
8834 def __init__(self):
8835 self.a = 1
8836
8837 result = Foo().__reduce_ex__(3)
8838 self.assertEqual(len(result), 5)
8839 self.assertEqual(result[1:], ((Foo,), {"a": 1}, None, None))
8840
8841 def test_reduce_ex_with_custom_base(self):
8842 class Foo:
8843 def __init__(self):
8844 self.a = 1
8845
8846 class Bar(Foo):
8847 def __init__(self):
8848 Foo.__init__(self)
8849 self.b = 2
8850
8851 result = Bar().__reduce_ex__(0)
8852 self.assertEqual(len(result), 3)
8853 self.assertEqual(result[1:], ((Bar, object, None), {"a": 1, "b": 2}))
8854
8855 def test_reduce_ex_with_custom_base_and_proto_three(self):
8856 class Foo:
8857 def __init__(self):
8858 self.a = 1
8859
8860 class Bar(Foo):
8861 def __init__(self):
8862 Foo.__init__(self)
8863 self.b = 2
8864
8865 result = Bar().__reduce_ex__(3)
8866 self.assertEqual(len(result), 5)
8867 self.assertEqual(result[1:], ((Bar,), {"a": 1, "b": 2}, None, None))
8868
8869 def test_reduce_ex_with_custom_reduce(self):
8870 class Foo:
8871 def __init__(self):
8872 self.a = 1
8873
8874 def __reduce__(self):
8875 return (Foo, (self.a))
8876
8877 result = Foo().__reduce_ex__(0)
8878 self.assertEqual(len(result), 2)
8879 self.assertEqual(result, (Foo, 1))
8880
8881 def test_reduce_ex_with_custom_reduce_and_proto_three(self):
8882 class Foo:
8883 def __init__(self):
8884 self.a = 1
8885
8886 def __reduce__(self):
8887 return (Foo, (self.a))
8888
8889 result = Foo().__reduce_ex__(3)
8890 self.assertEqual(len(result), 2)
8891 self.assertEqual(result, (Foo, 1))
8892
8893 def test_reduce_ex_with_getstate(self):
8894 class Foo:
8895 def __init__(self):
8896 self.a = 1
8897
8898 def __getstate__(self):
8899 return {"b": 2}
8900
8901 result = Foo().__reduce_ex__(1)
8902 self.assertEqual(len(result), 3)
8903 self.assertEqual(result[1:], ((Foo, object, None), {"b": 2}))
8904
8905 def test_reduce_ex_with_getstate_and_proto_three(self):
8906 class Foo:
8907 def __init__(self):
8908 self.a = 1
8909
8910 def __getstate__(self):
8911 return {"b": 2}
8912
8913 result = Foo().__reduce_ex__(3)
8914 self.assertEqual(len(result), 5)
8915 self.assertEqual(result[1:], ((Foo,), {"b": 2}, None, None))
8916
8917 def test_reduce_ex_with_empty_slots_and_proto_three(self):
8918 class Foo:
8919 __slots__ = ()
8920
8921 result = Foo().__reduce_ex__(3)
8922 self.assertEqual(len(result), 5)
8923 self.assertEqual(result[1:], ((Foo,), None, None, None))
8924
8925 def test_reduce_ex_with_slots_and_proto_three(self):
8926 class Foo:
8927 __slots__ = "a"
8928
8929 def __init__(self, value):
8930 self.a = value
8931
8932 result = Foo(1).__reduce_ex__(3)
8933 self.assertEqual(len(result), 5)
8934 self.assertEqual(result[1:], ((Foo,), (None, {"a": 1}), None, None))
8935
8936 def test_reduce_ex_with_dict_and_proto_three(self):
8937 d = {"a": 1}
8938 result = d.__reduce_ex__(3)
8939 self.assertEqual(len(result), 5)
8940 self.assertEqual(result[1:4], ((dict,), None, None))
8941 it = result[4]
8942 self.assertEqual(it.__next__(), ("a", 1))
8943 with self.assertRaises(StopIteration):
8944 it.__next__()
8945
8946 def test_reduce_ex_ignores_instance_reduce(self):
8947 class Foo:
8948 def __init__(self):
8949 self.a = 123
8950
8951 def reconstruct_foo(a):
8952 foo = Foo()
8953 foo.a = a
8954 return foo
8955
8956 def reduce_foo(self):
8957 return (reconstruct_foo, (self.a))
8958
8959 foo = Foo()
8960 foo.__reduce__ = reduce_foo.__get__(foo, Foo)
8961 self.assertEqual(foo.__reduce__()[0], reconstruct_foo)
8962 import copyreg
8963
8964 self.assertEqual(foo.__reduce_ex__(1)[0], copyreg._reconstructor)
8965
8966 def test_reduce_ex_with_getnewargs_ex_equals_none_raises_type_error(self):
8967 class Foo:
8968 __getnewargs_ex__ = None
8969
8970 with self.assertRaises(TypeError) as context:
8971 Foo().__reduce_ex__(3)
8972 self.assertEqual(str(context.exception), "'NoneType' object is not callable")
8973
8974 def test_reduce_ex_with_getnewargs_equals_none_raises_type_error(self):
8975 class Foo:
8976 __getnewargs__ = None
8977
8978 with self.assertRaises(TypeError) as context:
8979 Foo().__reduce_ex__(3)
8980 self.assertEqual(str(context.exception), "'NoneType' object is not callable")
8981
8982 def test_reduce_ex_with_getstate_equals_none_raises_type_error(self):
8983 class Foo:
8984 __getstate__ = None
8985
8986 with self.assertRaises(TypeError) as context:
8987 Foo().__reduce_ex__(3)
8988 self.assertEqual(str(context.exception), "'NoneType' object is not callable")
8989
8990 def test_dunder_repr_returns_string_with_module_and_name(self):
8991 class C:
8992 pass
8993
8994 self.assertTrue(
8995 object.__repr__(C()).startswith(
8996 "<__main__.ObjectTests.test_dunder_repr_returns_string_with_module_and_name.<locals>.C object at"
8997 )
8998 )
8999
9000 def test_dunder_repr_returns_string_with_only_name(self):
9001 self.assertTrue(object.__repr__(42).startswith("<int object at "))
9002 self.assertTrue(object.__repr__("").startswith("<str object at "))
9003
9004 def test_dir_without_dict_returns_type_attributes(self):
9005 o = dir(object())
9006 self.assertIn("__class__", o)
9007 self.assertIn("__repr__", o)
9008 self.assertIn("__doc__", o)
9009
9010 def test_dir_with_builtin_returns_attributes(self):
9011 s = dir("foo")
9012 self.assertIn("__class__", s)
9013 self.assertIn("__repr__", s)
9014 self.assertIn("__doc__", s)
9015 self.assertIn("lower", s)
9016 self.assertIn("strip", s)
9017
9018 def test_dir_with_builtin_subclass_returns_attributes(self):
9019 class Foo(str):
9020 def foo(self):
9021 pass
9022
9023 s = dir(Foo("bar"))
9024 self.assertIn("__class__", s)
9025 self.assertIn("__repr__", s)
9026 self.assertIn("__doc__", s)
9027 self.assertIn("lower", s)
9028 self.assertIn("strip", s)
9029 self.assertIn("foo", s)
9030
9031 def test_dir_with_custom_object_returns_attribtues(self):
9032 class Foo:
9033 def foo(self):
9034 pass
9035
9036 f = dir(Foo())
9037 self.assertIn("__class__", f)
9038 self.assertIn("__repr__", f)
9039 self.assertIn("__doc__", f)
9040 self.assertIn("foo", f)
9041
9042 def test_dir_with_inherited_object_returns_base_attribtues(self):
9043 class Foo:
9044 def foo(self):
9045 pass
9046
9047 class Bar(Foo):
9048 def bar(self):
9049 pass
9050
9051 b = dir(Bar())
9052 self.assertIn("__class__", b)
9053 self.assertIn("__repr__", b)
9054 self.assertIn("__doc__", b)
9055 self.assertIn("foo", b)
9056 self.assertIn("bar", b)
9057
9058 def test_dir_with_custom_dunder_dict_returns_attribtues(self):
9059 class Foo:
9060 __slots__ = ["__dict__"]
9061 __dict__ = "hey"
9062
9063 def foo(self):
9064 pass
9065
9066 f = dir(Foo())
9067 self.assertIn("__class__", f)
9068 self.assertIn("__repr__", f)
9069 self.assertIn("__doc__", f)
9070 self.assertIn("foo", f)
9071
9072 def test_dunder_class_getitem_becomes_classmethod(self):
9073 class C:
9074 def __class_getitem__(cls, item):
9075 return None
9076
9077 @classmethod
9078 def foo(cls):
9079 return cls
9080
9081 self.assertIs(type(C.__class_getitem__), type(C.foo))
9082
9083 def test_dunder_getattribute_with_raising_descr_propagates_exception(self):
9084 class D:
9085 def __get__(self, x, y):
9086 raise UserWarning("foo")
9087
9088 class C:
9089 __getattribute__ = D()
9090
9091 instance = C()
9092 with self.assertRaises(UserWarning):
9093 instance.foo
9094
9095 def test_dunder_new_with_builtin_type_raises_type_error(self):
9096 with self.assertRaisesRegex(
9097 TypeError, r"object\.__new__\(int\) is not safe.*int\.__new__\(\)"
9098 ):
9099 object.__new__(int)
9100
9101 def test_dunder_subclasshook_returns_not_implemented(self):
9102 self.assertIs(object.__subclasshook__(), NotImplemented)
9103 self.assertIs(object.__subclasshook__(int), NotImplemented)
9104
9105 def test_dunder_class_on_instance_returns_type(self):
9106 class Foo:
9107 pass
9108
9109 class Bar(Foo):
9110 pass
9111
9112 class Hello(Bar, list):
9113 pass
9114
9115 self.assertIs([].__class__, list)
9116 self.assertIs(Foo().__class__, Foo)
9117 self.assertIs(Bar().__class__, Bar)
9118 self.assertIs(Hello().__class__, Hello)
9119 self.assertIs(Foo.__class__, type)
9120 self.assertIs(super(Bar, Bar()).__class__, super)
9121
9122 def test_dunder_init_subclass_with_args_raises_type_error(self):
9123 with self.assertRaises(TypeError):
9124 object.__init_subclass__(str)
9125
9126 def test_dunder_init_subclass_with_kwargs_raises_type_error(self):
9127 with self.assertRaises(TypeError):
9128 object.__init_subclass__(name="foo")
9129
9130 def test_dunder_init_subclass_returns_none(self):
9131 self.assertIs(object.__init_subclass__(), None)
9132
9133 def test_dunder_setattr_raises_attribute_error(self):
9134 result = object()
9135 with self.assertRaisesRegex(AttributeError, ".*attribute 'foo'"):
9136 result.foo = "bar"
9137
9138 def test_dunder_setattr_on_exception_does_not_raise(self):
9139 result = Exception()
9140 result.foo = "bar"
9141 self.assertEqual(result.foo, "bar")
9142
9143 def test_dunder_dict_dunder_getitem_with_non_existent_key_raises_key_error(self):
9144 class C:
9145 pass
9146
9147 instance = C()
9148 with self.assertRaises(KeyError):
9149 instance.__dict__["non_key"]
9150
9151 def test_subclass_does_not_override_user_dunder_dict(self):
9152 class C(object):
9153 __dict__ = 5
9154
9155 class D(C):
9156 pass
9157
9158 self.assertEqual(C.__dict__["__dict__"], 5)
9159 self.assertNotIn("__dict__", D.__dict__)
9160
9161 def test_dunder_dict_dunder_setitem_sets_attribute(self):
9162 class C:
9163 pass
9164
9165 instance = C()
9166 with self.assertRaises(AttributeError):
9167 instance.foo
9168 instance.__dict__["foo"] = "bar"
9169 self.assertEqual(instance.foo, "bar")
9170
9171 def test_dunder_dict_items_returns_items_iterable(self):
9172 class C:
9173 pass
9174
9175 instance = C()
9176 d = instance.__dict__
9177 d["foo"] = "bar"
9178 self.assertEqual(list(d.items()), [("foo", "bar")])
9179
9180 def test_dunder_dict_keys_returns_keys_iterable(self):
9181 class C:
9182 pass
9183
9184 instance = C()
9185 d = instance.__dict__
9186 d["foo"] = "bar"
9187 d["baz"] = "quux"
9188 keys = d.keys()
9189 self.assertEqual(len(keys), 2)
9190 self.assertIn("foo", keys)
9191 self.assertIn("baz", keys)
9192
9193 def test_dunder_dict_update_sets_attributes(self):
9194 class C:
9195 pass
9196
9197 instance = C()
9198 d = instance.__dict__
9199 self.assertEqual(len(d), 0)
9200 d.update({"hello": "world", "foo": "bar"})
9201 self.assertEqual(len(d), 2)
9202 self.assertEqual(d["hello"], "world")
9203 self.assertEqual(d["foo"], "bar")
9204
9205 def test_int_subclass_has_dunder_dict(self):
9206 class C(int):
9207 pass
9208
9209 sub = C(5)
9210 self.assertTrue(hasattr(sub, "__dict__"))
9211
9212 def test_str_subclass_has_dunder_dict(self):
9213 class C(str):
9214 pass
9215
9216 sub = C("foo")
9217 self.assertTrue(hasattr(sub, "__dict__"))
9218
9219 def test_instance_dict_stays_synced_with_attribute_values(self):
9220 class C:
9221 pass
9222
9223 instance = C()
9224 d = instance.__dict__
9225 self.assertEqual(len(d), 0)
9226 instance.foo = 42
9227 self.assertEqual(len(d), 1)
9228 self.assertEqual(d["foo"], 42)
9229 d["bar"] = 7
9230 self.assertEqual(instance.bar, 7)
9231
9232 def test_dunder_dict_dunder_contains_returns_true_if_attr_exists(self):
9233 class C:
9234 pass
9235
9236 instance = C()
9237 d = instance.__dict__
9238 self.assertFalse(d.__contains__("foo"))
9239 instance.foo = "bar"
9240 self.assertTrue(d.__contains__("foo"))
9241 del instance.foo
9242 self.assertFalse(d.__contains__("foo"))
9243
9244 def test_dunder_dict_dunder_delitem_deletes_attribute(self):
9245 class C:
9246 pass
9247
9248 instance = C()
9249 d = instance.__dict__
9250 self.assertNotIn("foo", d)
9251 with self.assertRaisesRegex(AttributeError, "foo"):
9252 instance.foo
9253 instance.foo = "bar"
9254 self.assertIn("foo", d)
9255 d.__delitem__("foo")
9256 self.assertNotIn("foo", d)
9257 with self.assertRaisesRegex(AttributeError, "foo"):
9258 instance.foo
9259
9260 def test_dunder_dict_dunder_iter_iterates_over_keys(self):
9261 class C:
9262 pass
9263
9264 instance = C()
9265 d = instance.__dict__
9266 instance.foo = "bar"
9267 instance.bar = "baz"
9268 keys = (*d.__iter__(),)
9269 self.assertEqual(len(keys), 2)
9270 self.assertIn("foo", keys)
9271 self.assertIn("bar", keys)
9272
9273 def test_dunder_dict_pop_removes_and_returns_attribute(self):
9274 class C:
9275 pass
9276
9277 instance = C()
9278 d = instance.__dict__
9279 instance.foo = "bar"
9280 self.assertEqual(d.pop("foo"), "bar")
9281 self.assertNotIn("foo", d)
9282 with self.assertRaisesRegex(AttributeError, "foo"):
9283 instance.foo
9284
9285 def test_dunder_dict_pop_with_nonexistent_attr_returns_default(self):
9286 class C:
9287 pass
9288
9289 instance = C()
9290 d = instance.__dict__
9291 value = "bar"
9292 self.assertIs(d.pop("foo", value), value)
9293 self.assertNotIn("foo", d)
9294 with self.assertRaisesRegex(AttributeError, "foo"):
9295 instance.foo
9296
9297 def test_dunder_dict_pop_with_nonexistent_attr_raises_key_error(self):
9298 class C:
9299 pass
9300
9301 instance = C()
9302 d = instance.__dict__
9303 self.assertRaisesRegex(KeyError, "foo", d.pop, "foo")
9304 self.assertNotIn("foo", d)
9305 with self.assertRaisesRegex(AttributeError, "foo"):
9306 instance.foo
9307
9308 def test_dunder_dict_popitem_with_empty_dict_raises_key_error(self):
9309 class C:
9310 pass
9311
9312 instance = C()
9313 self.assertRaisesRegex(KeyError, "empty", instance.__dict__.popitem)
9314
9315 def test_dunder_dict_popitem_removes_attribute(self):
9316 class C:
9317 pass
9318
9319 instance = C()
9320 orig_value = "bar"
9321 instance.foo = orig_value
9322 d = instance.__dict__
9323 (key, value) = d.popitem()
9324 self.assertEqual(key, "foo")
9325 self.assertIs(value, orig_value)
9326 self.assertNotIn("foo", d)
9327
9328 def test_dunder_dict_removes_only_one_attribute(self):
9329 class C:
9330 pass
9331
9332 instance = C()
9333 instance.foo = "bar"
9334 instance.bar = "baz"
9335 d = instance.__dict__
9336 self.assertEqual(len(d), 2)
9337 (key, value) = d.popitem()
9338 self.assertEqual(len(d), 1)
9339 self.assertNotIn(key, d)
9340 self.assertIn((key, value), (("foo", "bar"), ("bar", "baz")))
9341
9342 def test_dunder_dict_clear_removes_attributes(self):
9343 class C:
9344 pass
9345
9346 instance = C()
9347 d = instance.__dict__
9348 self.assertEqual(len(d), 0)
9349 instance.foo = "bar"
9350 self.assertIn("foo", d)
9351 instance.bar = "foo"
9352 self.assertIn("bar", d)
9353 self.assertEqual(len(d), 2)
9354 d.clear()
9355 self.assertEqual(len(d), 0)
9356 self.assertNotIn("foo", d)
9357 with self.assertRaisesRegex(AttributeError, "foo"):
9358 instance.foo
9359 self.assertNotIn("bar", d)
9360 with self.assertRaisesRegex(AttributeError, "bar"):
9361 instance.bar
9362
9363 def test_dunder_dict_setdefault_with_nonexistent_attr_sets_none(self):
9364 class C:
9365 pass
9366
9367 instance = C()
9368 d = instance.__dict__
9369 self.assertIsNone(d.setdefault("foo"))
9370 self.assertIsNone(d["foo"])
9371 self.assertIsNone(instance.foo)
9372
9373 def test_dunder_dict_setdefault_with_nonexistent_attr_sets_default(self):
9374 class C:
9375 pass
9376
9377 instance = C()
9378 d = instance.__dict__
9379 value = "bar"
9380 self.assertIs(d.setdefault("foo", value), value)
9381 self.assertIs(d["foo"], value)
9382 self.assertIs(instance.foo, value)
9383
9384 def test_dunder_dict_setdefault_with_extant_attr_returns_value(self):
9385 class C:
9386 pass
9387
9388 instance = C()
9389 value = "bar"
9390 instance.foo = value
9391 d = instance.__dict__
9392 self.assertIs(d.setdefault("foo"), value)
9393 self.assertIs(d["foo"], value)
9394 self.assertIs(instance.foo, value)
9395
9396 def test_dunder_str_with_none_repr_raises_type_error(self):
9397 class C:
9398 __repr__ = None
9399
9400 c = C()
9401 with self.assertRaises(TypeError) as context:
9402 str(c)
9403 self.assertEqual(str(context.exception), "'NoneType' object is not callable")
9404
9405 def test_ge_returns_not_implemented(self):
9406 self.assertIs(object().__ge__(object()), NotImplemented)
9407
9408 def test_gt_returns_not_implemented(self):
9409 self.assertIs(object().__gt__(object()), NotImplemented)
9410
9411 def test_le_returns_not_implemented(self):
9412 self.assertIs(object().__le__(object()), NotImplemented)
9413
9414 def test_lt_returns_not_implemented(self):
9415 self.assertIs(object().__lt__(object()), NotImplemented)
9416
9417
9418class OctTests(unittest.TestCase):
9419 def test_returns_string(self):
9420 self.assertEqual(oct(0), "0o0")
9421 self.assertEqual(oct(-1), "-0o1")
9422 self.assertEqual(oct(1), "0o1")
9423 self.assertEqual(oct(54321), "0o152061")
9424 self.assertEqual(oct(34466324363639), "0o765432101234567")
9425
9426 def test_with_large_int_returns_string(self):
9427 # Test carry-over behavior at the border between digit 0 and 1:
9428 self.assertEqual(oct(1 << 60), "0o100000000000000000000")
9429 self.assertEqual(oct(1 << 61), "0o200000000000000000000")
9430 self.assertEqual(oct(1 << 62), "0o400000000000000000000")
9431 self.assertEqual(oct(1 << 63), "0o1000000000000000000000")
9432 self.assertEqual(oct(1 << 64), "0o2000000000000000000000")
9433 self.assertEqual(oct(1 << 65), "0o4000000000000000000000")
9434 # Test carry over behavior between later digits (there's 3 different
9435 # carry sizes, between 0-1, 1-2, 2-3).
9436 self.assertEqual(
9437 oct(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF),
9438 "0o77777777777777777777777777777777777777777777777777777777777777"
9439 "7777777777",
9440 )
9441 self.assertEqual(
9442 oct(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF),
9443 "0o17777777777777777777777777777777777777777777777777777777777777"
9444 "777777777777",
9445 )
9446 self.assertEqual(
9447 oct(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF),
9448 "0o37777777777777777777777777777777777777777777777777777777777777"
9449 "7777777777777",
9450 )
9451 # Some random numbers:
9452 self.assertEqual(
9453 oct(0xDEE182DE2EC55F61B22A509ED1DC3EB),
9454 "0o157341405570566125754154425120475507341753",
9455 )
9456 self.assertEqual(
9457 oct(-0x53ADC651E593B1323158BFA776E8173F60C76519277B2BD6),
9458 "-0o2472670624362623542310612613764735564027176603073121444736625726",
9459 )
9460
9461 def test_calls_dunder_index(self):
9462 class C:
9463 def __int__(self):
9464 return 42
9465
9466 def __index__(self):
9467 return -9
9468
9469 self.assertEqual(oct(C()), "-0o11")
9470
9471 def test_with_int_subclass(self):
9472 class C(int):
9473 pass
9474
9475 self.assertEqual(oct(C(51)), "0o63")
9476
9477 def test_with_non_int_raises_type_error(self):
9478 with self.assertRaises(TypeError) as context:
9479 oct("not an int")
9480 self.assertEqual(
9481 str(context.exception), "'str' object cannot be interpreted as an integer"
9482 )
9483
9484
9485class OpenTests(unittest.TestCase):
9486 def test_function_exists(self):
9487 import builtins
9488
9489 self.assertTrue(hasattr(builtins, "open"))
9490
9491
9492class PowTests(unittest.TestCase):
9493 def test_binary_first_arg_pow_returns_result(self):
9494 dunder_pow_args = None
9495
9496 class A:
9497 def __pow__(self, other, mod=None):
9498 nonlocal dunder_pow_args
9499 dunder_pow_args = (self, other, mod)
9500 return -123
9501
9502 a = A()
9503 self.assertEqual(pow(a, "str0"), -123)
9504 self.assertEqual(dunder_pow_args, (a, "str0", None))
9505
9506 def test_binary_second_arg_rpow_returns_result(self):
9507 dunder_pow_args = None
9508
9509 class A:
9510 def __rpow__(self, other, mod=None):
9511 nonlocal dunder_pow_args
9512 dunder_pow_args = (self, other, mod)
9513 return -123
9514
9515 a = A()
9516 self.assertEqual(pow("str0", a), -123)
9517 self.assertEqual(dunder_pow_args, (a, "str0", None))
9518
9519 def test_binary_unsupported_dunder_functions_raises_type_error(self):
9520 # TODO(T53066604): Check error message.
9521 with self.assertRaises(TypeError):
9522 pow("", "")
9523
9524 def test_ternary_first_arg_pow_returns_result(self):
9525 dunder_pow_args = None
9526
9527 class A:
9528 def __pow__(self, other, mod=None):
9529 nonlocal dunder_pow_args
9530 dunder_pow_args = (self, other, mod)
9531 return -123
9532
9533 a = A()
9534 self.assertEqual(pow(a, "str0", "str1"), -123)
9535 self.assertEqual(dunder_pow_args, (a, "str0", "str1"))
9536
9537 def test_ternary_first_arg_pow_from_descriptor_returns_result(self):
9538 class Desc:
9539 def __get__(self, obj, type):
9540 return lambda a, b, c=None: -5678
9541
9542 class A:
9543 __pow__ = Desc()
9544
9545 a = A()
9546 self.assertEqual(pow(a, "str0", "str1"), -5678)
9547
9548 def test_ternary_ignore_non_first_args_dunder_functions(self):
9549 class A:
9550 def __pow__(self, other, mod=None):
9551 raise UserWarning("unreachable")
9552
9553 def __rpow__(self, other):
9554 # __rpow__ doesn't accept the third arg.
9555 raise UserWarning("unreachable")
9556
9557 with self.assertRaises(TypeError) as context:
9558 pow("", A(), A())
9559 self.assertIn(
9560 "unsupported operand type(s) for pow(): 'str', 'A', 'A'",
9561 str(context.exception),
9562 )
9563
9564 def test_ternary_unsupported_dunder_functions_raises_type_error(self):
9565 class A:
9566 pass
9567
9568 class B:
9569 pass
9570
9571 class C:
9572 pass
9573
9574 with self.assertRaises(TypeError) as context:
9575 pow(A(), B(), C())
9576 self.assertIn(
9577 "unsupported operand type(s) for pow(): 'A', 'B', 'C'",
9578 str(context.exception),
9579 )
9580
9581
9582class PrintTests(unittest.TestCase):
9583 class MyStream:
9584 def __init__(self):
9585 self.buf = ""
9586
9587 def write(self, text):
9588 self.buf += text
9589 return len(text)
9590
9591 def flush(self):
9592 raise UserWarning("foo")
9593
9594 def test_print_writes_to_stream(self):
9595 stream = PrintTests.MyStream()
9596 print("hello", file=stream)
9597 self.assertEqual(stream.buf, "hello\n")
9598
9599 def test_print_returns_none(self):
9600 stream = PrintTests.MyStream()
9601 self.assertIs(print("hello", file=stream), None)
9602
9603 def test_print_writes_end(self):
9604 stream = PrintTests.MyStream()
9605 print("hi", end="ho", file=stream)
9606 self.assertEqual(stream.buf, "hiho")
9607
9608 def test_print_with_no_sep_defaults_to_space(self):
9609 stream = PrintTests.MyStream()
9610 print("hello", "world", file=stream)
9611 self.assertEqual(stream.buf, "hello world\n")
9612
9613 def test_print_writes_none(self):
9614 stream = PrintTests.MyStream()
9615 print(None, file=stream)
9616 self.assertEqual(stream.buf, "None\n")
9617
9618 def test_print_with_none_file_prints_to_sys_stdout(self):
9619 stream = PrintTests.MyStream()
9620 import sys
9621
9622 orig_stdout = sys.stdout
9623 sys.stdout = stream
9624 print("hello", file=None)
9625 self.assertEqual(stream.buf, "hello\n")
9626 sys.stdout = orig_stdout
9627
9628 def test_print_with_none_stdout_does_nothing(self):
9629 import sys
9630
9631 orig_stdout = sys.stdout
9632 sys.stdout = None
9633 print("hello", file=None)
9634 sys.stdout = orig_stdout
9635
9636 def test_print_with_deleted_stdout_raises_runtime_error(self):
9637 import sys
9638
9639 orig_stdout = sys.stdout
9640 del sys.stdout
9641 with self.assertRaises(RuntimeError):
9642 print("hello", file=None)
9643 sys.stdout = orig_stdout
9644
9645 def test_print_with_flush_calls_file_flush(self):
9646 stream = PrintTests.MyStream()
9647 with self.assertRaises(UserWarning):
9648 print("hello", file=stream, flush=True)
9649 self.assertEqual(stream.buf, "hello\n")
9650
9651 def test_print_calls_dunder_str(self):
9652 class C:
9653 def __str__(self):
9654 raise UserWarning("foo")
9655
9656 stream = PrintTests.MyStream()
9657 c = C()
9658 with self.assertRaises(UserWarning):
9659 print(c, file=stream)
9660
9661
9662class PropertyTests(unittest.TestCase):
9663 def test_dunder_abstractmethod_with_missing_attr_returns_false(self):
9664 def foo():
9665 pass
9666
9667 prop = property(foo)
9668 self.assertIs(prop.__isabstractmethod__, False)
9669
9670 def test_dunder_abstractmethod_with_false_attr_returns_false(self):
9671 def foo():
9672 pass
9673
9674 foo.__isabstractmethod__ = False
9675 with self.assertRaises(AttributeError):
9676 type(foo).__isabstractmethod__
9677 prop = property(foo)
9678 self.assertIs(prop.__isabstractmethod__, False)
9679
9680 def test_dunder_abstractmethod_with_abstract_getter_returns_true(self):
9681 def foo():
9682 pass
9683
9684 foo.__isabstractmethod__ = b"random non-empty value"
9685 with self.assertRaises(AttributeError):
9686 type(foo).__isabstractmethod__
9687 prop = property(foo)
9688 self.assertIs(prop.__isabstractmethod__, True)
9689
9690 def test_dunder_abstractmethod_with_abstract_setter_returns_true(self):
9691 def foo():
9692 pass
9693
9694 foo.__isabstractmethod__ = True
9695 with self.assertRaises(AttributeError):
9696 type(foo).__isabstractmethod__
9697 prop = property(fset=foo)
9698 self.assertIs(prop.__isabstractmethod__, True)
9699
9700 def test_dunder_abstractmethod_with_abstract_deleter_returns_true(self):
9701 def foo():
9702 pass
9703
9704 foo.__isabstractmethod__ = (42, "non-empty tuple")
9705 with self.assertRaises(AttributeError):
9706 type(foo).__isabstractmethod__
9707 prop = property(fdel=foo)
9708 self.assertIs(prop.__isabstractmethod__, True)
9709
9710 def test_dunder_abstractmethod_with_non_abstractmethod_raise_type_error(self):
9711 with self.assertRaises(TypeError):
9712 property.__dict__["__isabstractmethod__"].__get__(42)
9713
9714 def test_dunder_doc_returns_updated_value(self):
9715 p = property()
9716 self.assertIsNone(p.__doc__)
9717
9718 document_message = "this is for testing"
9719 p.__doc__ = document_message
9720 self.assertIs(p.__doc__, document_message)
9721
9722 def test_dunder_get_returns_value(self):
9723 class C:
9724 @property
9725 def bar(self):
9726 return 5
9727
9728 self.assertEqual(C().bar, 5)
9729
9730 def test_dunder_get_with_subclassed_property_returns_value(self):
9731 class foo(property):
9732 pass
9733
9734 class C:
9735 @foo
9736 def bar(self):
9737 return 5
9738
9739 self.assertEqual(C().bar, 5)
9740
9741 def test_dunder_get_called_with_non_property_raises_type_error(self):
9742 self.assertRaisesRegex(
9743 TypeError,
9744 "'__get__' .* 'property' object.* a 'float'",
9745 property.__get__,
9746 42.3,
9747 None,
9748 None,
9749 )
9750
9751 def test_dunder_new_called_with_non_type_object_raises_type_error(self):
9752 with self.assertRaises(TypeError) as context:
9753
9754 def bar():
9755 pass
9756
9757 property.__new__(42.3, bar)
9758 self.assertIn("not a type object", str(context.exception))
9759
9760 def test_dunder_new_called_with_non_subtype_raises_type_error(self):
9761 with self.assertRaises(TypeError) as context:
9762
9763 def bar():
9764 pass
9765
9766 property.__new__(float, bar)
9767 self.assertIn("not a subtype of property", str(context.exception))
9768
9769 def test_dunder_new_with_subclassed_property_returns_instance_of_superclass(self):
9770 class foo(property):
9771 pass
9772
9773 def bar():
9774 pass
9775
9776 self.assertIsInstance(property.__new__(foo, bar), foo)
9777
9778 def test_getter_and_setter_and_deleter_default_to_none(self):
9779 p = property()
9780 self.assertIsNone(p.fget)
9781 self.assertIsNone(p.fset)
9782 self.assertIsNone(p.fdel)
9783
9784 def test_fget_returns_getter(self):
9785 p = property(fget=len)
9786 self.assertIs(p.fget, len)
9787 with self.assertRaises(AttributeError):
9788 p.fget = len
9789
9790 def test_fset_returns_setter(self):
9791 p = property(fset=len)
9792 self.assertIs(p.fset, len)
9793 with self.assertRaises(AttributeError):
9794 p.fset = len
9795
9796 def test_fdel_returns_deleter(self):
9797 p = property(fdel=len)
9798 self.assertIs(p.fdel, len)
9799 with self.assertRaises(AttributeError):
9800 p.fdel = len
9801
9802
9803class RangeTests(unittest.TestCase):
9804 def test_dunder_bool_with_empty_range_returns_true(self):
9805 self.assertFalse(range(0).__bool__())
9806
9807 def test_dunder_bool_with_non_empty_range_returns_true(self):
9808 self.assertTrue(range(1).__bool__())
9809
9810 def test_dunder_contains_with_int_less_than_start_returns_false(self):
9811 self.assertFalse(range(1, 5).__contains__(0))
9812
9813 def test_dunder_contains_with_int_equals_start_returns_true(self):
9814 self.assertTrue(range(1, 5).__contains__(1))
9815
9816 def test_dunder_contains_with_int_in_range_returns_true(self):
9817 self.assertTrue(range(1, 5).__contains__(3))
9818
9819 def test_dunder_contains_with_int_equals_stop_returns_false(self):
9820 self.assertFalse(range(1, 5).__contains__(5))
9821
9822 def test_dunder_contains_with_int_in_stride_returns_true(self):
9823 self.assertTrue(range(1, 5, 2).__contains__(3))
9824
9825 def test_dunder_contains_with_int_not_in_stride_returns_false(self):
9826 self.assertFalse(range(1, 5, 2).__contains__(4))
9827
9828 def test_dunder_contains_with_negative_step_and_int_greater_than_start_returns_false( # noqa: B950
9829 self,
9830 ):
9831 self.assertFalse(range(5, 1, -1).__contains__(6))
9832
9833 def test_dunder_contains_with_negative_step_and_int_equals_start_returns_true(self):
9834 self.assertTrue(range(5, 1, -1).__contains__(5))
9835
9836 def test_dunder_contains_with_negative_step_and_int_less_than_start_returns_true( # noqa: B950
9837 self,
9838 ):
9839 self.assertTrue(range(5, 1, -1).__contains__(4))
9840
9841 def test_dunder_contains_with_negative_step_and_int_equals_stop_returns_false(self):
9842 self.assertFalse(range(5, 1, -1).__contains__(1))
9843
9844 def test_dunder_contains_with_negative_step_and_int_greater_than_stop_returns_true( # noqa: B950
9845 self,
9846 ):
9847 self.assertTrue(range(5, 1, -1).__contains__(2))
9848
9849 def test_dunder_contains_with_non_int_falls_back_to_iter_search(self):
9850 class C:
9851 __eq__ = Mock(name="__eq__", return_value=False)
9852
9853 range(1, 10, 3).__contains__(C())
9854 self.assertEqual(C.__eq__.call_count, 3)
9855
9856 def test_dunder_eq_with_non_range_self_raises_type_error(self):
9857 with self.assertRaises(TypeError):
9858 range.__eq__(1, 2)
9859
9860 def test_dunder_eq_with_non_range_other_returns_not_implemented(self):
9861 r = range(100)
9862 self.assertIs(r.__eq__(1), NotImplemented)
9863
9864 def test_dunder_eq_same_returns_true(self):
9865 r = range(10)
9866 self.assertTrue(r == r)
9867
9868 def test_dunder_eq_both_empty_returns_true(self):
9869 r1 = range(0)
9870 r2 = range(4, 3, 2)
9871 r3 = range(2, 5, -1)
9872 self.assertTrue(r1 == r2)
9873 self.assertTrue(r1 == r3)
9874 self.assertTrue(r2 == r3)
9875
9876 def test_dunder_eq_different_start_returns_false(self):
9877 r1 = range(1, 10, 3)
9878 r2 = range(2, 10, 3)
9879 self.assertFalse(r1 == r2)
9880
9881 def test_dunder_eq_different_stop_returns_true(self):
9882 r1 = range(0, 10, 3)
9883 r2 = range(0, 11, 3)
9884 self.assertTrue(r1 == r2)
9885
9886 def test_dunder_eq_different_step_length_one_returns_true(self):
9887 r1 = range(0, 4, 10)
9888 r2 = range(0, 4, 11)
9889 self.assertTrue(r1 == r2)
9890
9891 def test_dunder_eq_different_step_returns_false(self):
9892 r1 = range(0, 14, 10)
9893 r2 = range(0, 14, 11)
9894 self.assertFalse(r1 == r2)
9895
9896 def test_dunder_ge_with_non_range_self_raises_type_error(self):
9897 with self.assertRaises(TypeError):
9898 range.__ge__(1, 2)
9899
9900 def test_dunder_ge_returns_not_implemented(self):
9901 r = range(100)
9902 self.assertIs(r.__ge__(r), NotImplemented)
9903
9904 def test_dunder_getitem_with_non_range_raises_type_error(self):
9905 with self.assertRaises(TypeError):
9906 range.__getitem__(1, 2)
9907
9908 def test_dunder_getitem_with_int_subclass_does_not_call_dunder_index(self):
9909 class C(int):
9910 def __index__(self):
9911 raise ValueError("foo")
9912
9913 r = range(5)
9914 self.assertEqual(r[C(3)], 3)
9915
9916 def test_dunder_getitem_with_raising_descriptor_propagates_exception(self):
9917 class Desc:
9918 def __get__(self, obj, type):
9919 raise AttributeError("foo")
9920
9921 class C:
9922 __index__ = Desc()
9923
9924 r = range(5)
9925 with self.assertRaises(AttributeError) as context:
9926 r[C()]
9927 self.assertEqual(str(context.exception), "foo")
9928
9929 def test_dunder_getitem_with_string_raises_type_error(self):
9930 r = range(5)
9931 with self.assertRaises(TypeError) as context:
9932 r["3"]
9933 self.assertEqual(
9934 str(context.exception), "range indices must be integers or slices, not str"
9935 )
9936
9937 def test_dunder_getitem_with_dunder_index_calls_dunder_index(self):
9938 class C:
9939 def __index__(self):
9940 return 2
9941
9942 r = range(5)
9943 self.assertEqual(r[C()], 2)
9944
9945 def test_dunder_getitem_index_too_small_raises_index_error(self):
9946 r = range(5)
9947 with self.assertRaises(IndexError) as context:
9948 r[-6]
9949 self.assertEqual(str(context.exception), "range object index out of range")
9950
9951 def test_dunder_getitem_index_too_large_raises_index_error(self):
9952 r = range(5)
9953 with self.assertRaises(IndexError) as context:
9954 r[5]
9955 self.assertEqual(str(context.exception), "range object index out of range")
9956
9957 def test_dunder_getitem_negative_index_relative_to_end_value_error(self):
9958 r = range(5)
9959 self.assertEqual(r[-4], 1)
9960
9961 def test_dunder_getitem_with_valid_indices_returns_sublist(self):
9962 r = range(5)
9963 self.assertEqual(r[2:-1:1], range(2, 4))
9964
9965 def test_dunder_getitem_with_negative_start_returns_trailing(self):
9966 r = range(5)
9967 self.assertEqual(r[-2:], range(3, 5))
9968
9969 def test_dunder_getitem_with_positive_stop_returns_leading(self):
9970 r = range(5)
9971 self.assertEqual(r[:2], range(2))
9972
9973 def test_dunder_getitem_with_negative_stop_returns_all_but_trailing(self):
9974 r = range(5)
9975 self.assertEqual(r[:-2], range(3))
9976
9977 def test_dunder_getitem_with_positive_step_returns_forwards_list(self):
9978 r = range(5)
9979 self.assertEqual(r[::2], range(0, 5, 2))
9980
9981 def test_dunder_getitem_with_negative_step_returns_backwards_list(self):
9982 r = range(5)
9983 self.assertEqual(r[::-2], range(4, -1, -2))
9984
9985 def test_dunder_getitem_with_large_negative_start_returns_copy(self):
9986 r = range(5)
9987 copy = r[-10:]
9988 self.assertEqual(copy, r)
9989 self.assertIsNot(copy, r)
9990
9991 def test_dunder_getitem_with_large_positive_start_returns_empty(self):
9992 r = range(5)
9993 self.assertEqual(r[10:], range(0))
9994
9995 def test_dunder_getitem_with_large_negative_start_returns_empty(self):
9996 r = range(5)
9997 self.assertEqual(r[:-10], range(0))
9998
9999 def test_dunder_getitem_with_large_positive_start_returns_copy(self):
10000 r = range(5)
10001 copy = r[:10]
10002 self.assertEqual(copy, r)
10003 self.assertIsNot(copy, r)
10004
10005 def test_dunder_getitem_with_identity_slice_returns_copy(self):
10006 r = range(5)
10007 copy = r[::]
10008 self.assertEqual(copy, r)
10009 self.assertIsNot(copy, r)
10010
10011 def test_dunder_gt_with_non_range_self_raises_type_error(self):
10012 with self.assertRaises(TypeError):
10013 range.__gt__(1, 2)
10014
10015 def test_dunder_gt_returns_not_implemented(self):
10016 r = range(100)
10017 self.assertIs(r.__gt__(r), NotImplemented)
10018
10019 def test_dunder_iter_returns_range_iterator(self):
10020 it = iter(range(100))
10021 self.assertEqual(type(it).__name__, "range_iterator")
10022
10023 def test_dunder_iter_returns_longrange_iterator(self):
10024 it = iter(range(2 ** 63))
10025 self.assertEqual(type(it).__name__, "longrange_iterator")
10026
10027 def test_dunder_le_with_non_range_self_raises_type_error(self):
10028 with self.assertRaises(TypeError):
10029 range.__le__(1, 2)
10030
10031 def test_dunder_le_returns_not_implemented(self):
10032 r = range(100)
10033 self.assertIs(r.__le__(r), NotImplemented)
10034
10035 def test_dunder_lt_with_non_range_self_raises_type_error(self):
10036 with self.assertRaises(TypeError):
10037 range.__lt__(1, 2)
10038
10039 def test_dunder_lt_returns_not_implemented(self):
10040 r = range(100)
10041 self.assertIs(r.__lt__(r), NotImplemented)
10042
10043 def test_dunder_ne_with_non_range_self_raises_type_error(self):
10044 with self.assertRaises(TypeError):
10045 range.__ne__(1, 2)
10046
10047 def test_dunder_ne_with_non_range_other_returns_not_implemented(self):
10048 r = range(100)
10049 self.assertIs(r.__ne__(1), NotImplemented)
10050
10051 def test_dunder_ne_same_returns_false(self):
10052 r = range(10)
10053 self.assertFalse(r != r)
10054
10055 def test_dunder_ne_both_empty_returns_false(self):
10056 r1 = range(0)
10057 r2 = range(4, 3, 2)
10058 r3 = range(2, 5, -1)
10059 self.assertFalse(r1 != r2)
10060 self.assertFalse(r1 != r3)
10061 self.assertFalse(r2 != r3)
10062
10063 def test_dunder_ne_different_start_returns_true(self):
10064 r1 = range(1, 10, 3)
10065 r2 = range(2, 10, 3)
10066 self.assertTrue(r1 != r2)
10067
10068 def test_dunder_ne_different_stop_returns_false(self):
10069 r1 = range(0, 10, 3)
10070 r2 = range(0, 11, 3)
10071 self.assertFalse(r1 != r2)
10072
10073 def test_dunder_ne_different_step_length_one_returns_false(self):
10074 r1 = range(0, 4, 10)
10075 r2 = range(0, 4, 11)
10076 self.assertFalse(r1 != r2)
10077
10078 def test_dunder_ne_different_step_returns_true(self):
10079 r1 = range(0, 14, 10)
10080 r2 = range(0, 14, 11)
10081 self.assertTrue(r1 != r2)
10082
10083 def test_dunder_new_with_non_type_raises_type_error(self):
10084 with self.assertRaises(TypeError) as context:
10085 range.__new__(2, 1)
10086 self.assertEqual(
10087 str(context.exception), "range.__new__(X): X is not a type object (int)"
10088 )
10089
10090 def test_dunder_new_with_str_type_raises_type_error(self):
10091 with self.assertRaises(TypeError) as context:
10092 range.__new__(str, 5)
10093 self.assertEqual(
10094 str(context.exception), "range.__new__(str): str is not a subtype of range"
10095 )
10096
10097 def test_dunder_new_with_str_raises_type_error(self):
10098 with self.assertRaises(TypeError) as context:
10099 range("2")
10100 self.assertEqual(
10101 str(context.exception), "'str' object cannot be interpreted as an integer"
10102 )
10103
10104 def test_dunder_new_with_zero_step_raises_value_error(self):
10105 with self.assertRaises(ValueError) as context:
10106 range(1, 2, 0)
10107 self.assertEqual(str(context.exception), "range() arg 3 must not be zero")
10108
10109 def test_dunder_new_calls_dunder_index(self):
10110 class Foo:
10111 def __index__(self):
10112 return 10
10113
10114 obj = range(10)
10115 self.assertEqual(obj.start, 0)
10116 self.assertEqual(obj.stop, 10)
10117 self.assertEqual(obj.step, 1)
10118
10119 def test_dunder_new_stores_int_subclasses(self):
10120 class Foo(int):
10121 pass
10122
10123 class Bar:
10124 def __index__(self):
10125 return Foo(10)
10126
10127 warnings.filterwarnings(
10128 action="ignore",
10129 category=DeprecationWarning,
10130 message="__index__ returned non-int.*",
10131 module=__name__,
10132 )
10133 obj = range(Foo(2), Bar())
10134 self.assertEqual(type(obj.start), Foo)
10135 self.assertEqual(type(obj.stop), Foo)
10136 self.assertEqual(obj.start, 2)
10137 self.assertEqual(obj.stop, 10)
10138 self.assertEqual(obj.step, 1)
10139
10140 def test_dunder_new_with_one_arg_sets_stop(self):
10141 obj = range(10)
10142 self.assertEqual(obj.start, 0)
10143 self.assertEqual(obj.stop, 10)
10144 self.assertEqual(obj.step, 1)
10145
10146 def test_dunder_new_with_two_args_sets_start_and_stop(self):
10147 obj = range(10, 11)
10148 self.assertEqual(obj.start, 10)
10149 self.assertEqual(obj.stop, 11)
10150 self.assertEqual(obj.step, 1)
10151
10152 def test_dunder_new_with_three_args_sets_all(self):
10153 obj = range(10, 11, 12)
10154 self.assertEqual(obj.start, 10)
10155 self.assertEqual(obj.stop, 11)
10156 self.assertEqual(obj.step, 12)
10157
10158 def test_dunder_reduce_returns_tuple(self):
10159 r = range(10)
10160 self.assertTupleEqual(r.__reduce__(), (range, (0, 10, 1)))
10161 r = range(21, 10, 2)
10162 self.assertTupleEqual(r.__reduce__(), (range, (21, 10, 2)))
10163
10164 def test_dunder_repr_with_no_step_calls_repr(self):
10165 class Repr(int):
10166 def __repr__(self):
10167 return "repr"
10168
10169 def __str__(self):
10170 return "1"
10171
10172 r = range(Repr(2), Repr(4))
10173 self.assertEqual(repr(r), "range(repr, repr)")
10174
10175 def test_dunder_repr_with_step_calls_repr(self):
10176 class Repr(int):
10177 def __repr__(self):
10178 return "repr"
10179
10180 def __str__(self):
10181 return "1"
10182
10183 r = range(Repr(2), Repr(4), Repr(2))
10184 self.assertEqual(repr(r), "range(repr, repr, repr)")
10185
10186 def test_dunder_reversed_with_returns_reversed_iterator(self):
10187 rev_iter = range(1, 6, 2).__reversed__()
10188 self.assertEqual(rev_iter.__next__(), 5)
10189 self.assertEqual(rev_iter.__next__(), 3)
10190 self.assertEqual(rev_iter.__next__(), 1)
10191
10192 def test_start_is_readonly(self):
10193 with self.assertRaises(AttributeError):
10194 range(0, 1, 2).start = 2
10195
10196 def test_step_is_readonly(self):
10197 with self.assertRaises(AttributeError):
10198 range(0, 1, 2).step = 2
10199
10200 def test_stop_is_readonly(self):
10201 with self.assertRaises(AttributeError):
10202 range(0, 1, 2).stop = 2
10203
10204 def test_count_with_int_in_range_returns_one(self):
10205 self.assertEqual(range(3).count(1), 1)
10206
10207 def test_count_with_int_not_in_range_returns_zero(self):
10208 self.assertEqual(range(3).count(4), 0)
10209
10210 def test_count_with_overloaded_eq_returns_all_counts(self):
10211 class A:
10212 def __eq__(self, other):
10213 return other == 1 or other == 2
10214
10215 self.assertEqual(range(3).count(A()), 2)
10216
10217 def test_index_with_int_in_range_returns_index(self):
10218 self.assertEqual(range(3).index(1), 1)
10219
10220 def test_index_with_int_not_in_range_raises_value_error(self):
10221 with self.assertRaises(ValueError) as context:
10222 range(3).index(4)
10223 self.assertEqual(str(context.exception), "4 is not in range")
10224
10225 def test_index_with_overloaded_eq_returns_all_indexs(self):
10226 class A:
10227 def __eq__(self, other):
10228 return other == 1 or other == 2
10229
10230 self.assertEqual(range(3).index(A()), 1)
10231
10232 def test_hash_equals_equivalent_tuple_hashes(self):
10233 self.assertEqual(hash(range(0)), hash((0, None, None)))
10234 self.assertEqual(hash(range(1)), hash((1, 0, None)))
10235 self.assertEqual(hash(range(1, 4)), hash((3, 1, 1)))
10236 self.assertEqual(hash(range(0, 4, 2)), hash((2, 0, 2)))
10237
10238
10239class RangeIteratorTests(unittest.TestCase):
10240 def test_dunder_iter_returns_self(self):
10241 it = iter(range(100))
10242 self.assertEqual(iter(it), it)
10243
10244 def test_dunder_length_hint_returns_pending_length(self):
10245 len = 100
10246 it = iter(range(len))
10247 self.assertEqual(it.__length_hint__(), len)
10248 it.__next__()
10249 self.assertEqual(it.__length_hint__(), len - 1)
10250
10251 def test_dunder_next_returns_ints(self):
10252 it = iter(range(10, 5, -2))
10253 self.assertEqual(it.__next__(), 10)
10254 self.assertEqual(it.__next__(), 8)
10255 self.assertEqual(it.__next__(), 6)
10256 with self.assertRaises(StopIteration):
10257 it.__next__()
10258
10259
10260class ReversedTests(unittest.TestCase):
10261 def test_dunder_new_with_no_dunder_getitem_raises_type_error(self):
10262 class C:
10263 pass
10264
10265 with self.assertRaises(TypeError) as context:
10266 reversed(C())
10267 self.assertEqual(str(context.exception), "'C' object is not reversible")
10268
10269 def test_dunder_new_with_kwargs_raises_type_error(self):
10270 class C:
10271 pass
10272
10273 with self.assertRaises(TypeError) as context:
10274 reversed.__new__(reversed, [], foo=123)
10275 # TODO(emacs): Make error message for unexpected keyword arguments more
10276 # descriptive.
10277 self.assertIn("arguments", str(context.exception))
10278
10279 def test_reversed_iterates_backwards_over_iterable(self):
10280 it = reversed([1, 2, 3])
10281 self.assertEqual(it.__next__(), 3)
10282 self.assertEqual(it.__next__(), 2)
10283 self.assertEqual(it.__next__(), 1)
10284 with self.assertRaises(StopIteration):
10285 it.__next__()
10286
10287 def test_reversed_calls_dunder_reverse(self):
10288 class C:
10289 def __reversed__(self):
10290 return "foo"
10291
10292 self.assertEqual(reversed(C()), "foo")
10293
10294 def test_reversed_with_none_dunder_reverse_raises_type_error(self):
10295 class C:
10296 __reversed__ = None
10297
10298 with self.assertRaises(TypeError) as context:
10299 reversed(C())
10300 self.assertEqual(str(context.exception), "'C' object is not reversible")
10301
10302 def test_reversed_with_non_callable_dunder_reverse_raises_type_error(self):
10303 class C:
10304 __reversed__ = 1
10305
10306 with self.assertRaises(TypeError) as context:
10307 reversed(C())
10308 self.assertEqual(str(context.exception), "'int' object is not callable")
10309
10310 def test_reversed_length_hint(self):
10311 it = reversed([1, 2, 3])
10312 self.assertEqual(it.__length_hint__(), 3)
10313 it.__next__()
10314 self.assertEqual(it.__length_hint__(), 2)
10315 it.__next__()
10316 self.assertEqual(it.__length_hint__(), 1)
10317 it.__next__()
10318 self.assertEqual(it.__length_hint__(), 0)
10319
10320
10321class RoundTests(unittest.TestCase):
10322 def test_round_calls_dunder_round(self):
10323 class Roundable:
10324 def __init__(self, value):
10325 self.value = value
10326
10327 def __round__(self, ndigits="a default value"):
10328 return (self.value, ndigits)
10329
10330 self.assertEqual(round(Roundable(12), 34), (12, 34))
10331 self.assertEqual(round(Roundable(56)), (56, "a default value"))
10332
10333 def test_round_raises_type_error(self):
10334 class ClassWithoutDunderRound:
10335 pass
10336
10337 with self.assertRaises(TypeError):
10338 round(ClassWithoutDunderRound())
10339
10340
10341class SeqTests(unittest.TestCase):
10342 def test_sequence_is_iterable(self):
10343 class A:
10344 def __getitem__(self, index):
10345 return [1, 2, 3][index]
10346
10347 self.assertEqual([x for x in A()], [1, 2, 3])
10348
10349 def test_sequence_iter_is_itself(self):
10350 class A:
10351 def __getitem__(self, index):
10352 return [1, 2, 3][index]
10353
10354 a = iter(A())
10355 self.assertEqual(a, a.__iter__())
10356
10357 def test_non_iter_non_sequence_with_iter_raises_type_error(self):
10358 class NonIter:
10359 pass
10360
10361 with self.assertRaises(TypeError) as context:
10362 iter(NonIter())
10363
10364 self.assertEqual(str(context.exception), "'NonIter' object is not iterable")
10365
10366 def test_non_iter_non_sequence_with_for_raises_type_error(self):
10367 class NonIter:
10368 pass
10369
10370 with self.assertRaises(TypeError) as context:
10371 [x for x in NonIter()]
10372
10373 self.assertEqual(str(context.exception), "'NonIter' object is not iterable")
10374
10375 def test_sequence_with_error_raising_iter_descriptor_raises_type_error(self):
10376 dunder_get_called = False
10377
10378 class Desc:
10379 def __get__(self, obj, type):
10380 nonlocal dunder_get_called
10381 dunder_get_called = True
10382 raise UserWarning("Nope")
10383
10384 class C:
10385 __iter__ = Desc()
10386
10387 with self.assertRaises(TypeError) as context:
10388 [x for x in C()]
10389
10390 self.assertEqual(str(context.exception), "'C' object is not iterable")
10391 self.assertTrue(dunder_get_called)
10392
10393 def test_sequence_with_error_raising_getitem_descriptor_returns_iter(self):
10394 dunder_get_called = False
10395
10396 class Desc:
10397 def __get__(self, obj, type):
10398 nonlocal dunder_get_called
10399 dunder_get_called = True
10400 raise UserWarning("Nope")
10401
10402 class C:
10403 __getitem__ = Desc()
10404
10405 i = iter(C())
10406 self.assertTrue(hasattr(i, "__next__"))
10407 self.assertFalse(dunder_get_called)
10408
10409
10410class SetTests(unittest.TestCase):
10411 def test_deepcopy_with_set_returns_set(self):
10412 s = {1, 2, 3}
10413 self.assertEqual(s, copy.deepcopy(s))
10414
10415 def test_deepcopy_with_set_subclass_returns_subclass(self):
10416 class SubSet(set):
10417 pass
10418
10419 s = SubSet({1, 2, 3})
10420 self.assertEqual(s, copy.deepcopy(s))
10421
10422 def test_dunder_eq_with_non_set_self_raises_type_error(self):
10423 self.assertRaisesRegex(
10424 TypeError,
10425 "'__eq__' .* 'set' object.* a 'list'",
10426 set.__eq__,
10427 [],
10428 set(),
10429 )
10430
10431 def test_dunder_ge_with_non_set_self_raises_type_error(self):
10432 self.assertRaisesRegex(
10433 TypeError,
10434 "'__ge__' .* 'set' object.* a 'list'",
10435 set.__ge__,
10436 [],
10437 set(),
10438 )
10439
10440 def test_dunder_gt_with_non_set_self_raises_type_error(self):
10441 self.assertRaisesRegex(
10442 TypeError,
10443 "'__gt__' .* 'set' object.* a 'list'",
10444 set.__gt__,
10445 [],
10446 set(),
10447 )
10448
10449 def test_dunder_init_with_non_set_self_raises_type_error(self):
10450 self.assertRaisesRegex(
10451 TypeError,
10452 "'__init__' .* 'set' object.* a 'list'",
10453 set.__init__,
10454 [],
10455 )
10456
10457 def test_dunder_le_with_non_set_self_raises_type_error(self):
10458 self.assertRaisesRegex(
10459 TypeError,
10460 "'__le__' .* 'set' object.* a 'list'",
10461 set.__le__,
10462 [],
10463 set(),
10464 )
10465
10466 def test_dunder_lt_with_non_set_self_raises_type_error(self):
10467 self.assertRaisesRegex(
10468 TypeError,
10469 "'__lt__' .* 'set' object.* a 'list'",
10470 set.__lt__,
10471 [],
10472 set(),
10473 )
10474
10475 def test_dunder_ne_with_non_set_self_raises_type_error(self):
10476 self.assertRaisesRegex(
10477 TypeError,
10478 "'__ne__' .* 'set' object.* a 'list'",
10479 set.__ne__,
10480 [],
10481 set(),
10482 )
10483
10484 def test_dunder_reduce_with_set_returns_tuple(self):
10485 s = set({1, 2, 3})
10486 result = s.__reduce__()
10487 cls, value, state = result
10488 self.assertEqual(type(result), tuple)
10489 self.assertIsInstance(cls, type)
10490 self.assertEqual(cls, set)
10491 self.assertEqual(type(value), tuple)
10492 self.assertEqual(len(value), 1)
10493 self.assertEqual(value[0], [1, 2, 3])
10494 self.assertEqual(state, None)
10495
10496 def test_dunder_reduce_with_set_subclass_returns_tuple(self):
10497 class SubSet(set):
10498 pass
10499
10500 s = SubSet({1, 2, 3})
10501 s.test_value = "test_value"
10502 result = s.__reduce__()
10503 cls, value, state = result
10504 self.assertEqual(type(result), tuple)
10505 self.assertIsInstance(cls, type)
10506 self.assertEqual(cls, SubSet)
10507 self.assertEqual(type(value), tuple)
10508 self.assertEqual(len(value), 1)
10509 self.assertEqual(type(value[0]), list)
10510 self.assertEqual(value[0], [1, 2, 3])
10511 self.assertEqual(len(state), 1)
10512 self.assertEqual(state["test_value"], "test_value")
10513
10514 def test_set_add_then_remove_adds_then_add_adds_elements(self):
10515 s = set()
10516 for x in range(100):
10517 s.add(x)
10518 for x in range(100):
10519 s.remove(x)
10520 for x in range(100):
10521 s.add(x)
10522 self.assertEqual(s, set(range(100)))
10523
10524 def test_copy_with_non_set_self_raises_type_error(self):
10525 self.assertRaisesRegex(
10526 TypeError,
10527 "'copy' .* 'set' object.* a 'frozenset'",
10528 set.copy,
10529 frozenset(),
10530 )
10531
10532 def test_set_difference_update_with_non_iterable_raises_type_error(self):
10533 a = {1, 2, 3}
10534 with self.assertRaises(TypeError):
10535 a.difference_update(1)
10536
10537 def test_set_difference_update_no_match(self):
10538 a = {1, 2, 3}
10539 b = {4, 5, 6}
10540 a.difference_update(b)
10541 self.assertEqual(len(a), 3)
10542 self.assertIn(1, a)
10543 self.assertIn(2, a)
10544 self.assertIn(3, a)
10545
10546 def test_set_difference_update_removes_elements(self):
10547 a = {1, 2, 3}
10548 b = {2, 3}
10549 a.difference_update(b)
10550 self.assertEqual(len(a), 1)
10551 self.assertIn(1, a)
10552
10553 def test_set_difference_update_with_iterable_removes_elements(self):
10554 a = {1, 2, 3}
10555 b = [2]
10556 a.difference_update(b)
10557 self.assertEqual(len(a), 2)
10558 self.assertIn(1, a)
10559 self.assertIn(3, a)
10560
10561 def test_set_difference_update_with_multiple_args_removes_elements(self):
10562 a = {1, 2, 3}
10563 b = [2]
10564 c = {1, 3}
10565 a.difference_update(b, c)
10566 self.assertEqual(len(a), 0)
10567
10568 def test_dunder_and_with_non_set_raises_type_error(self):
10569 with self.assertRaises(TypeError):
10570 set.__and__(frozenset(), set())
10571
10572 def test_dunder_ixor_with_non_set_self_raises_type_error(self):
10573 with self.assertRaisesRegex(
10574 TypeError,
10575 "'__ixor__' .* 'set' object.* a 'frozenset'",
10576 ):
10577 set.__ixor__(frozenset(), set())
10578
10579 def test_dunder_ixor_with_non_anyset_other_returns_not_implemented(self):
10580 result = set.__ixor__(set(), ())
10581 self.assertIs(result, NotImplemented)
10582
10583 def test_dunder_ixor_does_inplace_symmetric_difference_update(self):
10584 left = {1, 2, 3}
10585 right = {3, 4, 5}
10586 result = set.__ixor__(left, right)
10587 self.assertIs(result, left)
10588 self.assertSetEqual(left, {1, 2, 4, 5})
10589 self.assertSetEqual(right, {3, 4, 5})
10590
10591 def test_dunder_ixor_with_frozenset_does_inplace_symmetric_difference_update(self):
10592 left = {1, 2, 3}
10593 right = frozenset({3, 4, 5})
10594 result = set.__ixor__(left, right)
10595 self.assertIs(result, left)
10596 self.assertSetEqual(left, {1, 2, 4, 5})
10597 self.assertEqual(right, {3, 4, 5})
10598
10599 def test_set_subclass_difference_removes_elements(self):
10600 class SubSet(set):
10601 pass
10602
10603 a = SubSet([1, 2, 3])
10604 b = {2, 3}
10605 a.difference_update(b)
10606 self.assertEqual(len(a), 1)
10607 self.assertIn(1, a)
10608
10609 def test_set_subclass_difference_update_with_custom_discard(self):
10610 class SubSet(set):
10611 def discard(self, item):
10612 pass
10613
10614 a = SubSet([1, 2, 3])
10615 b = {2, 3}
10616 a.difference_update(b)
10617 self.assertEqual(len(a), 1)
10618 self.assertIn(1, a)
10619
10620 def test_set_subclass_difference_ignores_subclass_difference_update(self):
10621 class SubSet(set):
10622 def difference_update(self, *others):
10623 pass
10624
10625 a = SubSet([1, 2, 3])
10626 b = {2, 3}
10627 set.difference_update(a, b)
10628 self.assertEqual(len(a), 1)
10629 self.assertIn(1, a)
10630
10631 def test_set_clear_with_non_set_raises_type_error(self):
10632 with self.assertRaises(TypeError):
10633 set.clear(1)
10634
10635 def test_set_clear_removes_elements(self):
10636 a = {1, 2, 3}
10637 a.clear()
10638 self.assertEqual(len(a), 0)
10639
10640 def test_set_subclass_clear_removes_elements(self):
10641 class SubSet(set):
10642 pass
10643
10644 a = SubSet([1, 2, 3])
10645 a.clear()
10646 self.assertEqual(len(a), 0)
10647
10648 def test_dunder_or_with_non_set_raises_type_error(self):
10649 self.assertRaisesRegex(
10650 TypeError,
10651 "'__or__' .* 'set' object.* a 'frozenset'",
10652 set.__or__,
10653 frozenset(),
10654 set(),
10655 )
10656
10657 def test_dunder_xor_with_non_set_raises_type_error(self):
10658 self.assertRaisesRegex(
10659 TypeError,
10660 "'__xor__' .* 'set' object.* a 'frozenset'",
10661 set.__xor__,
10662 frozenset(),
10663 set(),
10664 )
10665
10666 def test_dunder_xor_with_non_anyset_other_returns_notimplemented(self):
10667 result = set.__xor__(set(), ())
10668 self.assertIs(result, NotImplemented)
10669
10670 def test_dunder_xor_removes_common_elements(self):
10671 left = {1, 2, 3}
10672 right = {3, 4, 5}
10673 result = set.__xor__(left, right)
10674 self.assertIs(type(result), set)
10675 self.assertSetEqual(result, {1, 2, 4, 5})
10676
10677 def test_dunder_xor_with_frozenset_removes_common_elements(self):
10678 left = {1, 2, 3}
10679 right = frozenset({3, 4, 5})
10680 result = set.__xor__(left, right)
10681 self.assertIs(type(result), set)
10682 self.assertSetEqual(result, {1, 2, 4, 5})
10683
10684 def test_dunder_rxor_with_non_set_raises_type_error(self):
10685 with self.assertRaisesRegex(
10686 TypeError,
10687 "'__rxor__' .* 'set' object.* a 'frozenset'",
10688 ):
10689 set.__rxor__(frozenset(), set())
10690
10691 def test_dunder_rxor_with_non_anyset_other_returns_notimplemented(self):
10692 result = set.__rxor__(set(), ())
10693 self.assertIs(result, NotImplemented)
10694
10695 def test_dunder_rxor_removes_common_elements(self):
10696 left = {1, 2, 3}
10697 right = {3, 4, 5}
10698 result = set.__rxor__(left, right)
10699 self.assertSetEqual(result, {1, 2, 4, 5})
10700
10701 def test_dunder_rxor_with_frozenset_removes_common_elements(self):
10702 left = {1, 2, 3}
10703 right = frozenset({3, 4, 5})
10704 result = set.__rxor__(left, right)
10705 self.assertSetEqual(result, {1, 2, 4, 5})
10706
10707 def test_difference_no_others_copies_self(self):
10708 a_set = {1, 2, 3}
10709 self.assertIsNot(set.difference(a_set), a_set)
10710
10711 def test_difference_same_sets_returns_empty_set(self):
10712 a_set = {1, 2, 3}
10713 self.assertFalse(set.difference(a_set, a_set))
10714
10715 def test_difference_two_sets_returns_difference(self):
10716 set1 = {1, 2, 3, 4, 5, 6, 7}
10717 set2 = {1, 3, 5, 7}
10718 self.assertEqual(set.difference(set1, set2), {2, 4, 6})
10719
10720 def test_difference_many_sets_returns_difference(self):
10721 a_set = {1, 10, 100, 1000}
10722 self.assertEqual(set.difference(a_set, {10}, {100}, {1000}), {1})
10723
10724 def test_discard_with_non_set_raises_type_error(self):
10725 with self.assertRaises(TypeError):
10726 set.discard(None, 1)
10727
10728 def test_discard_with_non_member_returns_none(self):
10729 self.assertIs(set.discard(set(), 1), None)
10730
10731 def test_discard_with_member_removes_element(self):
10732 s = {1, 2, 3}
10733 self.assertIn(1, s)
10734 self.assertIs(set.discard(s, 1), None)
10735 self.assertNotIn(1, s)
10736
10737 def test_mix_bool_and_int(self):
10738 s = set()
10739 s.add(1)
10740 self.assertIn(1, s)
10741 self.assertNotIn(0, s)
10742 self.assertIn(True, s)
10743 self.assertNotIn(False, s)
10744 self.assertEqual(len(s), 1)
10745 s.add(True)
10746 self.assertEqual(len(s), 1)
10747
10748 s = set()
10749 s.add(False)
10750 self.assertIn(0, s)
10751 self.assertEqual(len(s), 1)
10752 s.add(0)
10753 self.assertEqual(len(s), 1)
10754
10755 def test_repr_returns_str(self):
10756 self.assertEqual(set.__repr__(set()), "set()")
10757 self.assertEqual(set.__repr__({1}), "{1}")
10758 result = set.__repr__({1, "foo"})
10759 self.assertTrue(result == "{1, 'foo'}" or result == "{'foo', 1}")
10760
10761 class M(type):
10762 def __repr__(cls):
10763 return "<M instance>"
10764
10765 class C(metaclass=M):
10766 def __repr__(self):
10767 return "<C instance>"
10768
10769 self.assertEqual(set.__repr__({C}), "{<M instance>}")
10770 self.assertEqual(set.__repr__({C()}), "{<C instance>}")
10771
10772 def test_repr_with_subclass_returns_str(self):
10773 class C(set):
10774 pass
10775
10776 self.assertEqual(set.__repr__(C()), "C()")
10777
10778 def test_remove_with_non_set_raises_type_error(self):
10779 with self.assertRaises(TypeError):
10780 set.remove(None, 1)
10781
10782 def test_remove_with_non_member_raises_key_error(self):
10783 with self.assertRaises(KeyError):
10784 set.remove(set(), 1)
10785
10786 def test_remove_with_member_removes_element(self):
10787 s = {1, 2, 3}
10788 self.assertIn(1, s)
10789 set.remove(s, 1)
10790 self.assertNotIn(1, s)
10791
10792 def test_inplace_with_non_set_raises_type_error(self):
10793 a = frozenset()
10794 self.assertRaises(TypeError, set.__ior__, a, set())
10795
10796 def test_inplace_with_non_set_as_other_returns_unimplemented(self):
10797 a = set()
10798 result = set.__ior__(a, 1)
10799 self.assertEqual(len(a), 0)
10800 self.assertIs(result, NotImplemented)
10801
10802 def test_inplace_or_modifies_self(self):
10803 a = set()
10804 b = {"foo"}
10805 result = set.__ior__(a, b)
10806 self.assertIs(result, a)
10807 self.assertEqual(len(a), 1)
10808 self.assertIn("foo", a)
10809
10810 def test_intersection_update_with_non_set_self_raises_type_error(self):
10811 self.assertRaisesRegex(
10812 TypeError,
10813 "'intersection_update' .* 'set' object.* a 'frozenset'",
10814 set.intersection_update,
10815 frozenset(),
10816 set(),
10817 )
10818
10819 def test_intersection_update_with_non_iterable_other_raises_type_error(self):
10820 with self.assertRaises(TypeError) as context:
10821 set.intersection_update(set(), 5)
10822 self.assertEqual(str(context.exception), "'int' object is not iterable")
10823
10824 def test_intersection_update_updates_self_to_be_intersection(self):
10825 a = {1, 2, 3}
10826 a.intersection_update((2, 3, 4))
10827 self.assertEqual(a, {2, 3})
10828
10829 def test_intersection_update_updates_self_to_be_intersection_with_multiple(self):
10830 a = {1, 2, 3}
10831 a.intersection_update((2, 3, 4), (3, 4, 5))
10832 self.assertEqual(a, {3})
10833
10834 def test_intersection_update_with_empty_lhs_and_no_rhs_stays_empty(self):
10835 a = set()
10836 a.intersection_update()
10837 self.assertEqual(a, set())
10838
10839 def test_intersection_update_with_empty_lhs_and_empty_rhs(self):
10840 a = set()
10841 a.intersection_update(())
10842 self.assertEqual(a, set())
10843
10844 def test_intersection_update_with_non_empty_lhs_and_empty_rhs(self):
10845 a = {1, 2, 3}
10846 a.intersection_update(())
10847 self.assertEqual(a, set())
10848
10849 def test_intersection_update_with_empty_lhs_and_non_empty_rhs(self):
10850 a = set()
10851 a.intersection_update({1, 2, 3})
10852 self.assertEqual(a, set())
10853
10854 def test_sub_returns_difference(self):
10855 self.assertEqual(set.__sub__({1, 2}, set()), {1, 2})
10856 self.assertEqual(set.__sub__({1, 2}, {1}), {2})
10857 self.assertEqual(set.__sub__({1, 2}, {1, 2}), set())
10858
10859 def test_sub_with_frozenset_returns_difference(self):
10860 self.assertEqual(set.__sub__({1, 2}, frozenset({1})), {2})
10861
10862 def test_sub_with_non_set_raises_type_error(self):
10863 with self.assertRaises(TypeError):
10864 set.__sub__("not a set", set())
10865 with self.assertRaises(TypeError):
10866 set.__sub__("not a set", "also not a set")
10867 with self.assertRaises(TypeError):
10868 set.__sub__(frozenset(), set())
10869
10870 def test_sub_with_non_set_other_returns_not_implemented(self):
10871 self.assertEqual(set.__sub__(set(), "not a set"), NotImplemented)
10872
10873 def test_isub_returns_difference(self):
10874 x1 = {1, 2}
10875 y1 = set()
10876 self.assertIs(set.__isub__(x1, y1), x1)
10877 self.assertEqual(x1, {1, 2})
10878
10879 x2 = {1, 2}
10880 y2 = {1}
10881 self.assertIs(set.__isub__(x2, y2), x2)
10882 self.assertEqual(x2, {2})
10883
10884 x3 = {1, 2}
10885 y3 = {1, 2}
10886 self.assertIs(set.__isub__(x3, y3), x3)
10887 self.assertEqual(x3, set())
10888
10889 def test_isub_with_frozenset_returns_difference(self):
10890 x2 = {1, 2}
10891 y2 = frozenset({1})
10892 self.assertIs(set.__isub__(x2, y2), x2)
10893 self.assertEqual(x2, {2})
10894
10895 def test_isub_operator_returns_difference(self):
10896 x1 = {1, 2}
10897 y1 = set()
10898 x1 -= y1
10899 self.assertEqual(x1, {1, 2})
10900
10901 x2 = {1, 2}
10902 y2 = {1}
10903 x2 -= y2
10904 self.assertEqual(x2, {2})
10905
10906 x3 = {1, 2}
10907 y3 = {1, 2}
10908 x3 -= y3
10909 self.assertEqual(x3, set())
10910
10911 def test_isub_with_non_set_raises_type_error(self):
10912 with self.assertRaises(TypeError):
10913 set.__isub__("not a set", set())
10914 with self.assertRaises(TypeError):
10915 set.__isub__("not a set", "also not a set")
10916 with self.assertRaises(TypeError):
10917 set.__isub__(frozenset(), set())
10918
10919 def test_isub_with_non_set_other_returns_not_implemented(self):
10920 self.assertEqual(set.__isub__(set(), "not a set"), NotImplemented)
10921
10922 def test_symmetric_difference_with_non_set_raises_type_error(self):
10923 self.assertRaisesRegex(
10924 TypeError,
10925 "'symmetric_difference' .* 'set' object.* a 'frozenset'",
10926 set.symmetric_difference,
10927 frozenset(),
10928 set(),
10929 )
10930
10931 def test_symmetric_difference_with_non_anyset_other_returns_notimplemented(self):
10932 result = set.symmetric_difference(set(), ())
10933 self.assertIs(type(result), set)
10934 self.assertSetEqual(result, set())
10935
10936 def test_symmetric_difference_removes_common_elements(self):
10937 left = {1, 2, 3}
10938 right = {3, 4, 5}
10939 result = set.symmetric_difference(left, right)
10940 self.assertIs(type(result), set)
10941 self.assertSetEqual(result, {1, 2, 4, 5})
10942
10943 def test_symmetric_difference_with_iterable_removes_common_elements(self):
10944 left = {1, 2, 3}
10945 right = (3, 4, 5)
10946 result = set.symmetric_difference(left, right)
10947 self.assertIs(type(result), set)
10948 self.assertSetEqual(result, {1, 2, 4, 5})
10949
10950 def test_symmetric_difference_update_with_non_set_self_raises_type_error(self):
10951 with self.assertRaisesRegex(
10952 TypeError,
10953 "'symmetric_difference_update' .* 'set' object.* a 'int'",
10954 ):
10955 set.symmetric_difference_update(1, set())
10956
10957 def test_symmetric_difference_update_with_non_iterable_other_raises_type_error(
10958 self,
10959 ):
10960 with self.assertRaisesRegex(TypeError, "object is not iterable"):
10961 set.symmetric_difference_update(set(), 1)
10962
10963 def test_symmetric_difference_update_with_identity_equal_params_clears_self(self):
10964 a = {1, 2, 3}
10965 self.assertSetEqual(a, {1, 2, 3})
10966 set.symmetric_difference_update(a, a)
10967 self.assertSetEqual(a, set())
10968
10969 def test_symmetric_difference_update_removes_self_items_found_in_other(self):
10970 left = {1, 2, 3}
10971 right = {3}
10972 set.symmetric_difference_update(left, right)
10973 self.assertSetEqual(left, {1, 2})
10974 self.assertSetEqual(right, {3})
10975
10976 def test_symmetric_difference_update_adds_items_found_in_other(self):
10977 left = {1, 2}
10978 right = {3, 4, 5}
10979 set.symmetric_difference_update(left, right)
10980 self.assertSetEqual(left, {1, 2, 3, 4, 5})
10981 self.assertSetEqual(right, {3, 4, 5})
10982
10983 def test_symmetric_difference_update_with_raising_iterable_does_not_remove(self):
10984 class C:
10985 def __init__(self):
10986 self.value = 0
10987
10988 def __iter__(self):
10989 return self
10990
10991 def __next__(self):
10992 if self.value > 3:
10993 raise UserWarning("foo")
10994 self.value += 1
10995 return self.value
10996
10997 left = {1, 2, 3}
10998 right = C()
10999 with self.assertRaisesRegex(UserWarning, "foo"):
11000 set.symmetric_difference_update(left, right)
11001 self.assertEqual(left, {1, 2, 3})
11002
11003 def test_set_ignores_subclass_isub_update(self):
11004 class SubSet(set):
11005 def __isub__(self, other):
11006 pass
11007
11008 a = SubSet([1, 2, 3])
11009 b = {2, 3}
11010 self.assertIs(set.__isub__(a, b), a)
11011 self.assertEqual(a, {1})
11012
11013 def test_union_with_non_set_as_self_raises_type_error(self):
11014 with self.assertRaises(TypeError):
11015 set.union(frozenset(), set())
11016
11017 def test_union_with_set_returns_union(self):
11018 set1 = {1, 2}
11019 set2 = {2, 3}
11020 set3 = {4, 5}
11021 self.assertEqual(set.union(set1, set2, set3), {1, 2, 3, 4, 5})
11022
11023 def test_union_with_self_returns_copy(self):
11024 a_set = {1, 2, 3}
11025 self.assertIsNot(set.union(a_set), a_set)
11026 self.assertIsNot(set.union(a_set, a_set), a_set)
11027
11028 def test_union_with_iterable_contains_iterable_items(self):
11029 a_set = {1, 2}
11030 a_dict = {2: True, 3: True}
11031 self.assertEqual(set.union(a_set, a_dict), {1, 2, 3})
11032
11033 def test_union_with_custom_iterable(self):
11034 class C:
11035 def __init__(self, start, end):
11036 self.pos = start
11037 self.end = end
11038
11039 def __iter__(self):
11040 return self
11041
11042 def __next__(self):
11043 if self.pos == self.end:
11044 raise StopIteration
11045 result = self.pos
11046 self.pos += 1
11047 return result
11048
11049 self.assertEqual(set.union(set(), C(1, 3), C(6, 9)), {1, 2, 6, 7, 8})
11050
11051 def test_issuperset_with_non_set_raises_type_error(self):
11052 with self.assertRaises(TypeError):
11053 set.issuperset(None, set())
11054
11055 def test_issuperset_with_frozenset_raises_type_error(self):
11056 with self.assertRaises(TypeError):
11057 set.issuperset(frozenset(), set())
11058
11059 def test_issuperset_with_empty_sets_returns_true(self):
11060 self.assertTrue(set.issuperset(set(), frozenset()))
11061 self.assertTrue(set.issuperset(set(), set()))
11062
11063 def test_issuperset_with_anyset_subset_returns_true(self):
11064 self.assertTrue({1}.issuperset(set()))
11065 self.assertTrue({1}.issuperset(frozenset()))
11066
11067 self.assertTrue({1}.issuperset({1}))
11068 self.assertTrue({1}.issuperset(frozenset({1})))
11069
11070 self.assertTrue({1, 2}.issuperset({1}))
11071 self.assertTrue({1, 2}.issuperset(frozenset({1})))
11072
11073 self.assertTrue({1, 2}.issuperset({1, 2}))
11074 self.assertTrue({1, 2}.issuperset(frozenset({1, 2})))
11075
11076 self.assertTrue({1, 2, 3}.issuperset({1, 2}))
11077 self.assertTrue({1, 2, 3}.issuperset(frozenset({1, 2})))
11078
11079 def test_issuperset_with_iterable_subset_returns_true(self):
11080 self.assertTrue({1}.issuperset([]))
11081 self.assertTrue({1}.issuperset(range(1, 1)))
11082
11083 self.assertTrue({1}.issuperset([1]))
11084 self.assertTrue({1}.issuperset(range(1, 2)))
11085
11086 self.assertTrue({1, 2}.issuperset([1]))
11087 self.assertTrue({1, 2}.issuperset(range(1, 2)))
11088
11089 self.assertTrue({1, 2}.issuperset([1, 2]))
11090 self.assertTrue({1, 2}.issuperset(range(1, 3)))
11091
11092 self.assertTrue({1, 2, 3}.issuperset([1, 2]))
11093 self.assertTrue({1, 2, 3}.issuperset(range(1, 3)))
11094
11095 def test_issuperset_with_superset_returns_false(self):
11096 self.assertFalse(set().issuperset({1}))
11097 self.assertFalse(set().issuperset(frozenset({1})))
11098 self.assertFalse(set().issuperset([1]))
11099 self.assertFalse(set().issuperset(range(1, 2)))
11100
11101 self.assertFalse({1}.issuperset({1, 2}))
11102 self.assertFalse({1}.issuperset(frozenset({1, 2})))
11103 self.assertFalse({1}.issuperset([1, 2]))
11104 self.assertFalse({1}.issuperset(range(1, 3)))
11105
11106 self.assertFalse({1, 2}.issuperset({1, 2, 3}))
11107 self.assertFalse({1, 2}.issuperset(frozenset({1, 2, 3})))
11108 self.assertFalse({1, 2}.issuperset([1, 2, 3]))
11109 self.assertFalse({1, 2}.issuperset(range(1, 4)))
11110
11111 def test_update_with_non_set_self_raises_type_error(self):
11112 self.assertRaisesRegex(
11113 TypeError,
11114 "'update' .* 'set' object.* a 'frozenset'",
11115 set.update,
11116 frozenset(),
11117 )
11118
11119
11120class SimpleNamespaceTests(unittest.TestCase):
11121 def test_dunder_eq_returns_false(self):
11122 sn0 = SimpleNamespace(foo=42, bar="baz")
11123 self.assertIs(SimpleNamespace.__eq__(sn0, SimpleNamespace()), False)
11124 self.assertIs(SimpleNamespace.__eq__(SimpleNamespace(), sn0), False)
11125 sn1 = SimpleNamespace(foo=42)
11126 self.assertIs(SimpleNamespace.__eq__(sn0, sn1), False)
11127 self.assertIs(SimpleNamespace.__eq__(sn1, sn0), False)
11128 sn2 = SimpleNamespace(foo=42, bar="baz", bam=None)
11129 self.assertIs(SimpleNamespace.__eq__(sn0, sn2), False)
11130 self.assertIs(SimpleNamespace.__eq__(sn2, sn0), False)
11131
11132 def test_dunder_eq_returns_true(self):
11133 self.assertIs(
11134 SimpleNamespace.__eq__(SimpleNamespace(), SimpleNamespace()), True
11135 )
11136 sn0 = SimpleNamespace(foo=42, bar="baz")
11137 sn1 = SimpleNamespace(bar="baz", foo=42)
11138 self.assertIs(SimpleNamespace.__eq__(sn0, sn1), True)
11139 self.assertIs(SimpleNamespace.__eq__(sn1, sn0), True)
11140
11141 def test_dunder_eq_returns_notimplemented(self):
11142 self.assertIs(SimpleNamespace.__eq__(SimpleNamespace(), {}), NotImplemented)
11143
11144 def test_dunder_init_returns_simple_namespace(self):
11145
11146 s = SimpleNamespace(foo=42, bar="baz")
11147 self.assertEqual(s.foo, 42)
11148 self.assertEqual(s.bar, "baz")
11149
11150 def test_dunder_ne_returns_false(self):
11151 self.assertIs(
11152 SimpleNamespace.__ne__(SimpleNamespace(), SimpleNamespace()), False
11153 )
11154 sn0 = SimpleNamespace(foo=42, bar="baz")
11155 sn1 = SimpleNamespace(bar="baz", foo=42)
11156 self.assertIs(SimpleNamespace.__ne__(sn0, sn1), False)
11157 self.assertIs(SimpleNamespace.__ne__(sn1, sn0), False)
11158
11159 def test_dunder_ne_returns_true(self):
11160 sn0 = SimpleNamespace(foo=42, bar="baz")
11161 self.assertIs(SimpleNamespace.__ne__(sn0, SimpleNamespace()), True)
11162 self.assertIs(SimpleNamespace.__ne__(SimpleNamespace(), sn0), True)
11163 sn1 = SimpleNamespace(foo=42)
11164 self.assertIs(SimpleNamespace.__ne__(sn0, sn1), True)
11165 self.assertIs(SimpleNamespace.__ne__(sn1, sn0), True)
11166 sn2 = SimpleNamespace(foo=42, bar="baz", bam=None)
11167 self.assertIs(SimpleNamespace.__ne__(sn0, sn2), True)
11168 self.assertIs(SimpleNamespace.__ne__(sn2, sn0), True)
11169
11170 def test_dunder_ne_returns_notimplemented(self):
11171 self.assertIs(SimpleNamespace.__ne__(SimpleNamespace(), {}), NotImplemented)
11172
11173 def test_dunder_repr_returns_str(self):
11174 s = SimpleNamespace(foo=42, bar="baz")
11175 self.assertEqual(SimpleNamespace.__repr__(s), "namespace(bar='baz', foo=42)")
11176
11177 def test_dunder_repr_sorts_elements_and_returns_str(self):
11178 s = SimpleNamespace(x=1, y=2, w=3)
11179 self.assertEqual(list(s.__dict__.items()), [("x", 1), ("y", 2), ("w", 3)])
11180 self.assertEqual(SimpleNamespace.__repr__(s), "namespace(w=3, x=1, y=2)")
11181 s = SimpleNamespace(w=3, y=2, x=1)
11182 self.assertEqual(list(s.__dict__.items()), [("w", 3), ("y", 2), ("x", 1)])
11183 self.assertEqual(SimpleNamespace.__repr__(s), "namespace(w=3, x=1, y=2)")
11184
11185 def test_dunder_repr_recursive_returns_str(self):
11186 ns0 = SimpleNamespace()
11187 ns0.n = ns0
11188 self.assertEqual(SimpleNamespace.__repr__(ns0), "namespace(n=namespace(...))")
11189
11190 ns1 = SimpleNamespace()
11191 ns2 = SimpleNamespace()
11192 ns1.foo = ns2
11193 ns2.bar = ns1
11194 self.assertEqual(
11195 SimpleNamespace.__repr__(ns1),
11196 "namespace(foo=namespace(bar=namespace(...)))",
11197 )
11198 self.assertEqual(
11199 SimpleNamespace.__repr__(ns2),
11200 "namespace(bar=namespace(foo=namespace(...)))",
11201 )
11202
11203 def test_simple_namespace_is_non_heaptype(self):
11204 self.assertFalse(SimpleNamespace.__flags__ & Py_TPFLAGS_HEAPTYPE)
11205
11206
11207class SliceTest(unittest.TestCase):
11208 def test_dunder_repr_with_nones_returns_str(self):
11209 s = slice(None)
11210 self.assertEqual(repr(s), "slice(None, None, None)")
11211
11212 def test_dunder_repr_with_stop_returns_str(self):
11213 s = slice(5)
11214 self.assertEqual(repr(s), "slice(None, 5, None)")
11215
11216 def test_dunder_repr_with_values_returns_str(self):
11217 s = slice(1, 5, 2)
11218 self.assertEqual(repr(s), "slice(1, 5, 2)")
11219
11220 def test_dunder_repr_calls_dunder_repr(self):
11221 class C:
11222 def __repr__(self):
11223 return "repr"
11224
11225 def __str__(self):
11226 return "str"
11227
11228 c = C()
11229 s = slice(c, c, c)
11230 self.assertEqual(repr(s), "slice(repr, repr, repr)")
11231
11232 def test_indices_with_non_slice_self_raises_type_error(self):
11233 self.assertRaisesRegex(
11234 TypeError,
11235 "'indices' .* 'slice' object.* a 'list'",
11236 slice.indices,
11237 [],
11238 1,
11239 )
11240
11241
11242class StaticMethodTests(unittest.TestCase):
11243 def test_dunder_abstractmethod_with_missing_attr_returns_false(self):
11244 def foo():
11245 pass
11246
11247 method = staticmethod(foo)
11248 self.assertIs(method.__isabstractmethod__, False)
11249
11250 def test_dunder_abstractmethod_with_false_attr_returns_false(self):
11251 def foo():
11252 pass
11253
11254 foo.__isabstractmethod__ = False
11255 with self.assertRaises(AttributeError):
11256 type(foo).__isabstractmethod__
11257 method = staticmethod(foo)
11258 self.assertIs(method.__isabstractmethod__, False)
11259
11260 def test_dunder_abstractmethod_with_abstract_returns_true(self):
11261 def foo():
11262 pass
11263
11264 foo.__isabstractmethod__ = 10 # non-zero is True
11265 with self.assertRaises(AttributeError):
11266 type(foo).__isabstractmethod__
11267 method = staticmethod(foo)
11268 self.assertIs(method.__isabstractmethod__, True)
11269
11270 def test_dunder_abstractmethod_with_non_staticmethod_raises_type_error(self):
11271 with self.assertRaises(TypeError):
11272 staticmethod.__dict__["__isabstractmethod__"].__get__(42)
11273
11274 def test_dunder_func_returns_function(self):
11275 def foo():
11276 pass
11277
11278 method = staticmethod(foo)
11279 self.assertIs(method.__func__, foo)
11280
11281 def test_dunder_func_assign_raises_attribute_error(self):
11282 def foo():
11283 pass
11284
11285 def bar():
11286 pass
11287
11288 method = staticmethod(foo)
11289 with self.assertRaises(AttributeError):
11290 method.__func__ = bar
11291
11292 def test_has_dunder_call(self):
11293 class C:
11294 @staticmethod
11295 def bar(self):
11296 pass
11297
11298 C.bar.__getattribute__("__call__")
11299
11300 def test_dunder_get_returns_value(self):
11301 class C:
11302 @staticmethod
11303 def bar(self):
11304 return 5
11305
11306 self.assertEqual(C.bar(C()), 5)
11307
11308 def test_dunder_get_with_subclassed_staticmethod_returns_value(self):
11309 class foo(staticmethod):
11310 pass
11311
11312 class C:
11313 @foo
11314 def bar(self):
11315 return 5
11316
11317 self.assertEqual(C.bar(C()), 5)
11318
11319 def test_dunder_get_called_with_non_staticmethod_raises_type_error(self):
11320 self.assertRaisesRegex(
11321 TypeError,
11322 "'__get__' .* 'staticmethod' object.* a 'float'",
11323 staticmethod.__get__,
11324 42.3,
11325 None,
11326 None,
11327 )
11328
11329 def test_dunder_new_called_with_non_type_object_raises_type_error(self):
11330 with self.assertRaises(TypeError) as context:
11331
11332 def bar():
11333 pass
11334
11335 staticmethod.__new__(42.3, bar)
11336 self.assertIn("not a type object", str(context.exception))
11337
11338 def test_dunder_new_called_with_non_subtype_raises_type_error(self):
11339 with self.assertRaises(TypeError) as context:
11340
11341 def bar():
11342 pass
11343
11344 staticmethod.__new__(float, bar)
11345 self.assertIn("not a subtype of staticmethod", str(context.exception))
11346
11347 def test_dunder_new_with_subclassed_staticmethod_returns_instance_of_superclass(
11348 self,
11349 ):
11350 class foo(staticmethod):
11351 pass
11352
11353 def bar():
11354 pass
11355
11356 self.assertIsInstance(staticmethod.__new__(foo, bar), foo)
11357
11358
11359class SumTests(unittest.TestCase):
11360 def test_str_as_start_raises_type_error(self):
11361 with self.assertRaises(TypeError) as context:
11362 sum([], "")
11363 self.assertEqual(
11364 str(context.exception), "sum() can't sum strings [use ''.join(seq) instead]"
11365 )
11366
11367 def test_bytes_as_start_raises_type_error(self):
11368 with self.assertRaises(TypeError) as context:
11369 sum([], b"")
11370 self.assertEqual(
11371 str(context.exception), "sum() can't sum bytes [use b''.join(seq) instead]"
11372 )
11373
11374 def test_bytearray_as_start_raises_type_error(self):
11375 with self.assertRaises(TypeError) as context:
11376 sum([], bytearray())
11377 self.assertEqual(
11378 str(context.exception),
11379 "sum() can't sum bytearray [use b''.join(seq) instead]",
11380 )
11381
11382 def test_non_iterable_raises_type_error(self):
11383 with self.assertRaises(TypeError):
11384 sum(None)
11385 # TODO(T43043290): Check for the exception message.
11386
11387 def test_int_list_without_start_returns_sum(self):
11388 result = sum([1, 2, 3])
11389 self.assertEqual(result, 6)
11390
11391 def test_int_list_with_start_returns_sum(self):
11392 result = sum([1, 2, 3], -6)
11393 self.assertEqual(result, 0)
11394
11395
11396class SuperTests(unittest.TestCase):
11397 def test_dunder_thisclass_returns_this_class(self):
11398 class C:
11399 def get_super(self):
11400 return super()
11401
11402 class D(C):
11403 pass
11404
11405 self.assertIs(D().get_super().__thisclass__, C)
11406
11407 def test_dunder_self_returns_self(self):
11408 class C:
11409 def get_super(self):
11410 return super()
11411
11412 class D(C):
11413 pass
11414
11415 i = D()
11416 self.assertIs(i.get_super().__self__, i)
11417
11418 def test_dunder_self_class_returns_self_class(self):
11419 class C:
11420 def get_super(self):
11421 return super()
11422
11423 class D(C):
11424 pass
11425
11426 self.assertIs(D().get_super().__self_class__, D)
11427
11428 def test_dunder_init_resolves_cell_vars(self):
11429 class C:
11430 def foo(self, a1):
11431 def compute():
11432 # This turns self, a1 into freevars in `compute` and
11433 # cellvars in `foo`. I am also using a1 here to have
11434 # `self` move at the end of the freevar/cellvar list to
11435 # make the test more interesting.
11436 self.dummy = a1
11437
11438 compute()
11439 s = super()
11440 return s
11441
11442 self.assertIn("self", C.foo.__code__.co_cellvars)
11443
11444 instance = C()
11445 s = instance.foo(None)
11446 self.assertEqual(s.__self__, instance)
11447 self.assertEqual(s.__self_class__, C)
11448 self.assertEqual(s.__thisclass__, C)
11449
11450
11451class SyntaxErrorTests(unittest.TestCase):
11452 def test_dunder_init_with_no_args_sets_msg_to_none(self):
11453 obj = SyntaxError()
11454 self.assertIsNone(obj.msg)
11455
11456 def test_dunder_init_with_arg_sets_msg_to_first_arg(self):
11457 obj = SyntaxError("hello")
11458 self.assertEqual(obj.msg, "hello")
11459
11460 def test_dunder_init_with_tuple_of_wrong_length_raises_index_error(self):
11461 with self.assertRaises(IndexError) as context:
11462 SyntaxError("hello", ())
11463 self.assertEqual(str(context.exception), "tuple index out of range")
11464
11465 def test_dunder_init_sets_attributes(self):
11466 obj = SyntaxError("msg", ("filename", "lineno", "offset", "text"))
11467 self.assertEqual(obj.msg, "msg")
11468 self.assertEqual(obj.filename, "filename")
11469 self.assertEqual(obj.lineno, "lineno")
11470 self.assertEqual(obj.offset, "offset")
11471 self.assertEqual(obj.text, "text")
11472
11473 def test_dunder_str_with_no_filename_and_no_lineno_returns_msg(self):
11474 obj = SyntaxError("hello")
11475 self.assertEqual(obj.__str__(), "hello")
11476
11477 def test_dunder_str_calls_dunder_str_on_message(self):
11478 class C:
11479 def __str__(self):
11480 return "foo"
11481
11482 obj = SyntaxError(C())
11483 result = obj.__str__()
11484 self.assertEqual(result, "foo")
11485
11486 def test_dunder_str_with_no_message_returns_none_string(self):
11487 obj = SyntaxError()
11488 result = obj.__str__()
11489 self.assertEqual(result, "None")
11490
11491 def test_dunder_str_with_filename_and_lineno(self):
11492 obj = SyntaxError("msg", ("filename", 5, "offset", "text"))
11493 result = obj.__str__()
11494 self.assertEqual(result, "msg (filename, line 5)")
11495
11496 def test_dunder_str_with_non_str_filename_and_lineno(self):
11497 obj = SyntaxError("msg", (10, 5, "offset", "text"))
11498 result = obj.__str__()
11499 self.assertEqual(result, "msg (line 5)")
11500
11501 def test_dunder_str_with_non_int_lineno_and_filename(self):
11502 obj = SyntaxError("msg", ("filename", "lineno", "offset", "text"))
11503 result = obj.__str__()
11504 self.assertEqual(result, "msg (filename)")
11505
11506 def test_dunder_str_with_str_filename_and_int_lineno(self):
11507 obj = SyntaxError("msg", ("path/to/foo.py", 5, "offset", "text"))
11508 result = obj.__str__()
11509 self.assertEqual(result, "msg (foo.py, line 5)")
11510
11511 def test_dunder_str_with_str_filename_and_non_int_lineno(self):
11512 obj = SyntaxError("msg", ("path/to/foo.py", "lineno", "offset", "test"))
11513 result = obj.__str__()
11514 self.assertEqual(result, "msg (foo.py)")
11515
11516
11517class TupleTests(unittest.TestCase):
11518 def test_dunder_repr_with_single_element(self):
11519 self.assertEqual(repr((1,)), "(1,)")
11520 self.assertEqual(repr(([1],)), "([1],)")
11521
11522 def test_dunder_repr_with_single_element_recursive(self):
11523 x = []
11524 y = (x,)
11525 x.append(y)
11526 self.assertEqual(repr(y), "([(...)],)")
11527
11528 def test_dunder_repr_with_multi_element(self):
11529 self.assertEqual(repr((1, [])), "(1, [])")
11530
11531 def test_dunder_repr_with_multi_element_recursive(self):
11532 x = []
11533 y = (x, [], 1)
11534 x.append(y)
11535 self.assertEqual(repr(y), "([(...)], [], 1)")
11536
11537 def test_dunder_eq_with_non_tuple_self_raises_type_error(self):
11538 self.assertRaisesRegex(
11539 TypeError,
11540 "'__eq__' .* 'tuple' object.* a 'NoneType'",
11541 tuple.__eq__,
11542 None,
11543 (),
11544 )
11545
11546 def test_dunder_eq_with_non_tuple_other_return_not_implemented(self):
11547 self.assertIs(tuple.__eq__((), None), NotImplemented)
11548
11549 def test_dunder_eq_with_equal_tuples_returns_true(self):
11550 lhs = (1, 2, 3, 4)
11551 rhs = (1, 2, 3, 4)
11552 self.assertTrue(tuple.__eq__(lhs, rhs))
11553
11554 def test_dunder_eq_with_longer_rhs_returns_false(self):
11555 lhs = (1, 2, 3, 4)
11556 rhs = (1, 2, 3, 4, 5)
11557 self.assertFalse(tuple.__eq__(lhs, rhs))
11558
11559 def test_dunder_eq_with_shorter_rhs_returns_false(self):
11560 lhs = (1, 2, 3, 4)
11561 rhs = (1, 2, 3)
11562 self.assertFalse(tuple.__eq__(lhs, rhs))
11563
11564 def test_dunder_eq_with_smaller_element_returns_false(self):
11565 lhs = (1, 2, 3)
11566 rhs = (1, 2, 2, 4)
11567 self.assertFalse(tuple.__eq__(lhs, rhs))
11568
11569 def test_dunder_eq_with_larger_element_returns_false(self):
11570 lhs = (1, 2, 3, 4)
11571 rhs = (1, 4)
11572 self.assertFalse(tuple.__eq__(lhs, rhs))
11573
11574 def test_dunder_ge_with_non_tuple_self_raises_type_error(self):
11575 self.assertRaisesRegex(
11576 TypeError,
11577 "'__ge__' .* 'tuple' object.* a 'NoneType'",
11578 tuple.__ge__,
11579 None,
11580 (),
11581 )
11582
11583 def test_dunder_ge_with_non_tuple_other_return_not_implemented(self):
11584 self.assertIs(tuple.__ge__((), None), NotImplemented)
11585
11586 def test_dunder_ge_with_equal_tuples_returns_true(self):
11587 lhs = (1, 2, 3, 4)
11588 rhs = (1, 2, 3, 4)
11589 self.assertTrue(tuple.__ge__(lhs, rhs))
11590
11591 def test_dunder_ge_with_longer_rhs_returns_false(self):
11592 lhs = (1, 2, 3, 4)
11593 rhs = (1, 2, 3, 4, 5)
11594 self.assertFalse(tuple.__ge__(lhs, rhs))
11595
11596 def test_dunder_ge_with_shorter_rhs_returns_true(self):
11597 lhs = (1, 2, 3, 4)
11598 rhs = (1, 2, 3)
11599 self.assertTrue(tuple.__ge__(lhs, rhs))
11600
11601 def test_dunder_ge_with_smaller_element_returns_true(self):
11602 lhs = (1, 2, 3)
11603 rhs = (1, 2, 2, 4)
11604 self.assertTrue(tuple.__ge__(lhs, rhs))
11605
11606 def test_dunder_ge_with_larger_element_returns_false(self):
11607 lhs = (1, 2, 3, 4)
11608 rhs = (1, 4)
11609 self.assertFalse(tuple.__ge__(lhs, rhs))
11610
11611 def test_dunder_getitem_with_non_tuple_self_raises_type_error(self):
11612 self.assertRaisesRegex(
11613 TypeError,
11614 "'__getitem__' .* 'tuple' object.* a 'NoneType'",
11615 tuple.__getitem__,
11616 None,
11617 1,
11618 )
11619
11620 def test_dunder_getitem_with_int_subclass_does_not_call_dunder_index(self):
11621 class C(int):
11622 def __index__(self):
11623 raise ValueError("foo")
11624
11625 t = (1, 2, 3)
11626 self.assertEqual(tuple.__getitem__(t, C(0)), 1)
11627
11628 def test_dunder_getitem_with_raising_descriptor_propagates_exception(self):
11629 class Desc:
11630 def __get__(self, obj, type):
11631 raise AttributeError("foo")
11632
11633 class C:
11634 __index__ = Desc()
11635
11636 t = (1, 2, 3)
11637 with self.assertRaises(AttributeError) as context:
11638 tuple.__getitem__(t, C())
11639 self.assertEqual(str(context.exception), "foo")
11640
11641 def test_dunder_getitem_with_non_int_raises_type_error(self):
11642 t = (1, 2, 3)
11643 with self.assertRaises(TypeError) as context:
11644 tuple.__getitem__(t, "3")
11645 self.assertEqual(
11646 str(context.exception), "tuple indices must be integers or slices, not str"
11647 )
11648
11649 def test_dunder_getitem_with_tuple_subclass_returns_value(self):
11650 class Foo(tuple):
11651 pass
11652
11653 t = Foo((0, 1))
11654 self.assertEqual(tuple.__getitem__(t, 0), 0)
11655
11656 def test_dunder_getitem_slice_with_tuple_subclass_returns_tuple(self):
11657 class Foo(tuple):
11658 pass
11659
11660 t = Foo((0, 1))
11661 self.assertEqual(tuple.__getitem__(t, slice(2)), (0, 1))
11662
11663 def test_dunder_getitem_with_dunder_index_calls_dunder_index(self):
11664 class C:
11665 def __index__(self):
11666 return 2
11667
11668 t = (1, 2, 3)
11669 self.assertEqual(tuple.__getitem__(t, C()), 3)
11670
11671 def test_dunder_getitem_index_too_small_raises_index_error(self):
11672 t = ()
11673 with self.assertRaises(IndexError) as context:
11674 tuple.__getitem__(t, -1)
11675 self.assertEqual(str(context.exception), "tuple index out of range")
11676
11677 def test_dunder_getitem_index_too_large_raises_index_error(self):
11678 t = (1, 2, 3)
11679 with self.assertRaises(IndexError) as context:
11680 tuple.__getitem__(t, 3)
11681 self.assertEqual(str(context.exception), "tuple index out of range")
11682
11683 def test_dunder_getitem_negative_index_relative_to_end_value_error(self):
11684 t = (1, 2, 3)
11685 self.assertEqual(tuple.__getitem__(t, -3), 1)
11686
11687 def test_dunder_getitem_with_valid_indices_returns_subtuple(self):
11688 t = (1, 2, 3, 4, 5)
11689 self.assertEqual(tuple.__getitem__(t, slice(2, -1)), (3, 4))
11690
11691 def test_dunder_getitem_with_negative_start_returns_trailing(self):
11692 t = (1, 2, 3)
11693 self.assertEqual(tuple.__getitem__(t, slice(-2, 5)), (2, 3))
11694
11695 def test_dunder_getitem_with_positive_stop_returns_leading(self):
11696 t = (1, 2, 3)
11697 self.assertEqual(tuple.__getitem__(t, slice(2)), (1, 2))
11698
11699 def test_dunder_getitem_with_negative_stop_returns_all_but_trailing(self):
11700 t = (1, 2, 3)
11701 self.assertEqual(tuple.__getitem__(t, slice(-2)), (1,))
11702
11703 def test_dunder_getitem_with_positive_step_returns_forwards_list(self):
11704 t = (1, 2, 3)
11705 self.assertEqual(tuple.__getitem__(t, slice(0, 10, 2)), (1, 3))
11706
11707 def test_dunder_getitem_with_negative_step_returns_backwards_list(self):
11708 t = (1, 2, 3)
11709 self.assertEqual(tuple.__getitem__(t, slice(2, -10, -2)), (3, 1))
11710
11711 def test_dunder_getitem_with_large_negative_start_returns_copy(self):
11712 t = (1, 2, 3)
11713 self.assertIs(tuple.__getitem__(t, slice(-10, 10)), t)
11714
11715 def test_dunder_getitem_with_large_positive_start_returns_empty(self):
11716 t = (1, 2, 3)
11717 self.assertEqual(tuple.__getitem__(t, slice(10, 10)), ())
11718
11719 def test_dunder_getitem_with_large_negative_stop_returns_empty(self):
11720 t = (1, 2, 3)
11721 self.assertEqual(tuple.__getitem__(t, slice(-10)), ())
11722
11723 def test_dunder_getitem_with_large_positive_stop_returns_same_object(self):
11724 t = (1, 2, 3)
11725 self.assertIs(tuple.__getitem__(t, slice(10)), t)
11726
11727 def test_dunder_getitem_with_extended_empty_slice_neg_step_returns_empty(self):
11728 t = (1, 2, 3)
11729 self.assertEqual(tuple.__getitem__(t, slice(1, 2, -1)), ())
11730
11731 def test_dunder_getitem_with_extended_empty_slice_pos_step_returns_empty(self):
11732 t = (1, 2, 3)
11733 self.assertEqual(tuple.__getitem__(t, slice(2, 1, 2)), ())
11734
11735 def test_dunder_gt_with_non_tuple_self_raises_type_error(self):
11736 self.assertRaisesRegex(
11737 TypeError,
11738 "'__gt__' .* 'tuple' object.* a 'NoneType'",
11739 tuple.__gt__,
11740 None,
11741 (),
11742 )
11743
11744 def test_dunder_gt_with_non_tuple_other_return_not_implemented(self):
11745 self.assertIs(tuple.__gt__((), None), NotImplemented)
11746
11747 def test_dunder_gt_with_equal_tuples_returns_false(self):
11748 lhs = (1, 2, 3, 4)
11749 rhs = (1, 2, 3, 4)
11750 self.assertFalse(tuple.__gt__(lhs, rhs))
11751
11752 def test_dunder_gt_with_longer_rhs_returns_false(self):
11753 lhs = (1, 2, 3, 4)
11754 rhs = (1, 2, 3, 4, 5)
11755 self.assertFalse(tuple.__gt__(lhs, rhs))
11756
11757 def test_dunder_gt_with_shorter_rhs_returns_true(self):
11758 lhs = (1, 2, 3, 4)
11759 rhs = (1, 2, 3)
11760 self.assertTrue(tuple.__gt__(lhs, rhs))
11761
11762 def test_dunder_gt_with_smaller_element_returns_true(self):
11763 lhs = (1, 2, 3)
11764 rhs = (1, 2, 2, 4)
11765 self.assertTrue(tuple.__gt__(lhs, rhs))
11766
11767 def test_dunder_gt_with_larger_element_returns_false(self):
11768 lhs = (1, 2, 3, 4)
11769 rhs = (1, 4)
11770 self.assertFalse(tuple.__gt__(lhs, rhs))
11771
11772 def test_dunder_le_with_non_tuple_self_raises_type_error(self):
11773 self.assertRaisesRegex(
11774 TypeError,
11775 "'__le__' .* 'tuple' object.* a 'NoneType'",
11776 tuple.__le__,
11777 None,
11778 (),
11779 )
11780
11781 def test_dunder_le_with_non_tuple_other_return_not_implemented(self):
11782 self.assertIs(tuple.__le__((), None), NotImplemented)
11783
11784 def test_dunder_le_with_equal_tuples_returns_true(self):
11785 lhs = (1, 2, 3, 4)
11786 rhs = (1, 2, 3, 4)
11787 self.assertTrue(tuple.__le__(lhs, rhs))
11788
11789 def test_dunder_le_with_longer_rhs_returns_true(self):
11790 lhs = (1, 2, 3, 4)
11791 rhs = (1, 2, 3, 4, 5)
11792 self.assertTrue(tuple.__le__(lhs, rhs))
11793
11794 def test_dunder_le_with_shorter_rhs_returns_false(self):
11795 lhs = (1, 2, 3, 4)
11796 rhs = (1, 2, 3)
11797 self.assertFalse(tuple.__le__(lhs, rhs))
11798
11799 def test_dunder_le_with_smaller_element_returns_false(self):
11800 lhs = (1, 2, 3)
11801 rhs = (1, 2, 2, 4)
11802 self.assertFalse(tuple.__le__(lhs, rhs))
11803
11804 def test_dunder_le_with_larger_element_returns_true(self):
11805 lhs = (1, 2, 3, 4)
11806 rhs = (1, 4)
11807 self.assertTrue(tuple.__le__(lhs, rhs))
11808
11809 def test_dunder_lt_with_non_tuple_self_raises_type_error(self):
11810 self.assertRaisesRegex(
11811 TypeError,
11812 "'__lt__' .* 'tuple' object.* a 'NoneType'",
11813 tuple.__lt__,
11814 None,
11815 (),
11816 )
11817
11818 def test_dunder_lt_with_non_tuple_other_returns_not_implemented(self):
11819 self.assertIs(tuple.__lt__((), None), NotImplemented)
11820
11821 def test_dunder_lt_with_equal_tuples_returns_false(self):
11822 lhs = (1, 2, 3, 4)
11823 rhs = (1, 2, 3, 4)
11824 self.assertFalse(tuple.__lt__(lhs, rhs))
11825
11826 def test_dunder_lt_with_longer_rhs_returns_true(self):
11827 lhs = (1, 2, 3, 4)
11828 rhs = (1, 2, 3, 4, 5)
11829 self.assertTrue(tuple.__lt__(lhs, rhs))
11830
11831 def test_dunder_lt_with_shorter_rhs_returns_false(self):
11832 lhs = (1, 2, 3, 4)
11833 rhs = (1, 2, 3)
11834 self.assertFalse(tuple.__lt__(lhs, rhs))
11835
11836 def test_dunder_lt_with_smaller_element_returns_false(self):
11837 lhs = (1, 2, 3)
11838 rhs = (1, 2, 2, 4)
11839 self.assertFalse(tuple.__lt__(lhs, rhs))
11840
11841 def test_dunder_lt_with_larger_element_returns_true(self):
11842 lhs = (1, 2, 3, 4)
11843 rhs = (1, 4)
11844 self.assertTrue(tuple.__lt__(lhs, rhs))
11845
11846 def test_dunder_ne_with_non_tuple_self_raises_type_error(self):
11847 self.assertRaisesRegex(
11848 TypeError,
11849 "'__ne__' .* 'tuple' object.* a 'NoneType'",
11850 tuple.__ne__,
11851 None,
11852 (),
11853 )
11854
11855 def test_dunder_ne_with_non_tuple_other_returns_not_implemented(self):
11856 self.assertIs(tuple.__lt__((), None), NotImplemented)
11857
11858 def test_dunder_ne_with_equal_tuples_returns_false(self):
11859 lhs = (1, 2, 3, 4)
11860 rhs = (1, 2, 3, 4)
11861 self.assertFalse(tuple.__ne__(lhs, rhs))
11862
11863 def test_dunder_ne_with_different_element_returns_true(self):
11864 lhs = (1, 2, 3, 4)
11865 rhs = (1, 2, 3, 5)
11866 self.assertTrue(tuple.__ne__(lhs, rhs))
11867
11868 def test_dunder_ne_with_longer_rhs_returns_true(self):
11869 lhs = (1, 2, 3, 4)
11870 rhs = (1, 2, 3, 4, 5)
11871 self.assertTrue(tuple.__ne__(lhs, rhs))
11872
11873 def test_dunder_ne_with_shorter_rhs_returns_true(self):
11874 lhs = (1, 2, 3, 4)
11875 rhs = (1, 2, 3)
11876 self.assertTrue(tuple.__ne__(lhs, rhs))
11877
11878 def test_dunder_ne_with_smaller_element_returns_true(self):
11879 lhs = (1, 2, 3)
11880 rhs = (1, 2, 2, 4)
11881 self.assertTrue(tuple.__ne__(lhs, rhs))
11882
11883 def test_dunder_ne_with_larger_element_returns_true(self):
11884 lhs = (1, 2, 3, 4)
11885 rhs = (1, 4)
11886 self.assertTrue(tuple.__ne__(lhs, rhs))
11887
11888 def test_dunder_new_with_no_iterable_arg_returns_empty_tuple(self):
11889 result = tuple.__new__(tuple)
11890 self.assertIs(result, ())
11891
11892 def test_dunder_new_with_tuple_returns_same_object(self):
11893 src = (1, 2, 3)
11894 result = tuple.__new__(tuple, src)
11895 self.assertIs(result, src)
11896
11897 def test_dunder_new_with_list_returns_tuple(self):
11898 self.assertEqual(tuple([1, 2, 3]), (1, 2, 3))
11899
11900 def test_dunder_new_with_tuple_subclass_and_tuple_returns_new_object(self):
11901 class C(tuple):
11902 pass
11903
11904 src = (1, 2, 3)
11905 result = tuple.__new__(C, src)
11906 self.assertTrue(result is not src)
11907
11908 def test_dunder_new_with_iterable_returns_tuple_with_elements(self):
11909 result = tuple.__new__(tuple, [1, 2, 3])
11910 self.assertEqual(result, (1, 2, 3))
11911
11912 def test_dunder_new_with_tuple_subclass_calls_dunder_iter(self):
11913 class C(tuple):
11914 def __iter__(self):
11915 raise UserWarning("foo")
11916
11917 c = C()
11918 self.assertRaises(UserWarning, tuple, c)
11919
11920 def test_dunder_new_with_list_subclass_calls_dunder_iter(self):
11921 class C(list):
11922 def __iter__(self):
11923 raise UserWarning("foo")
11924
11925 c = C()
11926 self.assertRaises(UserWarning, tuple, c)
11927
11928 def test_dunder_new_with_raising_dunder_iter_descriptor_raises_type_error(self):
11929 class Desc:
11930 def __get__(self, obj, type):
11931 raise UserWarning("foo")
11932
11933 class C:
11934 __iter__ = Desc()
11935
11936 with self.assertRaises(TypeError) as context:
11937 tuple(C())
11938 self.assertEqual(str(context.exception), "'C' object is not iterable")
11939
11940 def test_dunder_new_with_raising_dunder_next_descriptor_propagates_exception(self):
11941 class Desc:
11942 def __get__(self, obj, type):
11943 raise UserWarning("foo")
11944
11945 class C:
11946 def __iter__(self):
11947 return self
11948
11949 __next__ = Desc()
11950
11951 with self.assertRaises(UserWarning):
11952 tuple(C())
11953
11954 def test_dunder_rmul_with_one_element(self):
11955 left = (1,)
11956 result = tuple.__rmul__(left, 4)
11957 self.assertTupleEqual(result, (1, 1, 1, 1))
11958
11959 def test_dunder_rmul_with_length_greater_than_one_and_times_is_one(self):
11960 left = (1, 2, 3)
11961 result = tuple.__rmul__(left, 1)
11962 self.assertIs(result, left)
11963
11964 def test_dunder_rmul_with_length_greater_than_one_and_times_greater_than_one(self):
11965 left = (1, 2, 3)
11966 result = tuple.__rmul__(left, 2)
11967 self.assertTupleEqual(result, (1, 2, 3, 1, 2, 3))
11968
11969 def test_dunder_rmul_with_empty_tuple(self):
11970 left = ()
11971 result = tuple.__rmul__(left, 5)
11972 self.assertIs(result, left)
11973
11974 def test_dunder_rmul_with_negative_times(self):
11975 left = (1, 2, 3)
11976 result = tuple.__rmul__(left, -2)
11977 self.assertIs(result, ())
11978
11979 def test_dunder_rmul_with_tuple_subclass_returns_tuple(self):
11980 class C(tuple):
11981 pass
11982
11983 instance = C((1, 2, 3))
11984 result = tuple.__rmul__(instance, 2)
11985 self.assertEqual(result.__class__, tuple)
11986 self.assertTupleEqual(result, (1, 2, 3, 1, 2, 3))
11987
11988 def test_index_with_non_tuple_self_raises_type_error(self):
11989 with self.assertRaises(TypeError):
11990 tuple.index(object(), object())
11991
11992 def test_index_with_no_start_starts_at_zero(self):
11993 result = (1, 2, 3, 1, 2, 3).index(1)
11994 self.assertEqual(result, 0)
11995
11996 def test_index_with_negative_start_starts_from_end(self):
11997 result = (1, 2, 3, 1, 2, 3).index(3, -1)
11998 self.assertEqual(result, 5)
11999
12000 def test_index_with_negative_start_greater_than_length_starts_from_zero(self):
12001 result = (1, 2, 3, 1, 2, 3).index(3, -10)
12002 self.assertEqual(result, 2)
12003
12004 def test_index_with_no_stop_ends_at_length(self):
12005 result = (1, 2, 3, 4).index(4)
12006 self.assertEqual(result, 3)
12007
12008 def test_index_starts_at_given_start(self):
12009 result = (1, 2, 3, 1, 2, 3).index(1, 2)
12010 self.assertEqual(result, 3)
12011
12012 def test_index_with_negative_one_stops_before_end(self):
12013 with self.assertRaisesRegex(ValueError, "not in tuple"):
12014 (1, 2, 3, 4).index(4, 0, -1)
12015
12016 def test_index_with_negative_stop_stops_at_end(self):
12017 result = (1, 2, 3, 4).index(3, 0, -1)
12018 self.assertEqual(result, 2)
12019
12020 def test_index_with_negative_stop_greater_than_length_stops_at_zero(self):
12021 with self.assertRaisesRegex(ValueError, "not in tuple"):
12022 (1, 2, 3).index(3, 0, -10)
12023
12024 def test_index_stops_at_given_stop(self):
12025 with self.assertRaisesRegex(ValueError, "not in tuple"):
12026 (1, 2, 3, 4).index(4, 0, 3)
12027
12028 def test_index_compares_identity(self):
12029 class C:
12030 __eq__ = Mock(name="__eq__", return_value=False)
12031
12032 instance = C()
12033 result = (instance,).index(instance)
12034 self.assertEqual(result, 0)
12035 instance.__eq__.assert_not_called()
12036
12037 def test_index_calls_dunder_index_on_start(self):
12038 class C:
12039 __index__ = Mock(name="__index__", return_value=0)
12040
12041 result = (1, 2, 3).index(2, C())
12042 self.assertEqual(result, 1)
12043 C.__index__.assert_called_once()
12044
12045 def test_index_calls_dunder_index_on_stop(self):
12046 class C:
12047 __index__ = Mock(name="__index__", return_value=5)
12048
12049 result = (1, 2, 3).index(2, 0, C())
12050 self.assertEqual(result, 1)
12051 C.__index__.assert_called_once()
12052
12053 def test_index_calls_dunder_eq(self):
12054 class C:
12055 __eq__ = Mock(name="__eq__", return_value=False)
12056
12057 instance = C()
12058 result = (instance, 4).index(4)
12059 self.assertEqual(result, 1)
12060 instance.__eq__.assert_called_once()
12061
12062 def test_count_with_non_tuple_raises_type_error(self):
12063 with self.assertRaises(TypeError):
12064 tuple.count("foo", 3)
12065
12066 def test_count_with_empty_returns_zero(self):
12067 result = ().count(3)
12068 self.assertEqual(result, 0)
12069
12070 def test_count_with_no_matches_returns_zero(self):
12071 result = (2, 4, 6, 8).count(3)
12072 self.assertEqual(result, 0)
12073
12074 def test_count_with_mixed_elements(self):
12075 t = (2, [1], 6, 8)
12076 self.assertEqual(t.count(3), 0)
12077 self.assertEqual(t.count(2), 1)
12078
12079 def test_count_with_identical_elements(self):
12080 N = 5
12081 t = (2,) * N
12082 self.assertEqual(t.count(3), 0)
12083 self.assertEqual(t.count(2), N)
12084
12085 def test_count_with_equivalent_objects(self):
12086 o = object()
12087 self.assertEqual(().count(o), 0)
12088 self.assertEqual((o,).count(o), 1)
12089 self.assertEqual((o, o).count(o), 2)
12090
12091 def test_count_with_incomparable_elements_raises(self):
12092 class MyException(Exception):
12093 pass
12094
12095 class NoCompare:
12096 def __eq__(self, other):
12097 raise MyException("oops")
12098
12099 # Create an object that doesn't support __eq__
12100 # The exception should pass through the count
12101 bad = NoCompare()
12102
12103 with self.assertRaises(MyException):
12104 (1, 2, bad, 3).count(3)
12105
12106 with self.assertRaises(MyException):
12107 (1, 2, 3, 4).count(bad)
12108
12109 self.assertEqual((bad,).count(bad), 1)
12110
12111 def test_count_with_nan(self):
12112 nan = float("nan")
12113 self.assertEqual(().count(nan), 0)
12114 self.assertEqual((nan,).count(nan), 1)
12115
12116 def test_count_does_not_call_dunder_iter(self):
12117 class NoIterTuple(tuple):
12118 def __iter__(self):
12119 raise NotImplementedError("no iter")
12120
12121 t = NoIterTuple((1, 2, 3, 4, 3, 2, 1))
12122 self.assertEqual(t.count(3), 2)
12123
12124 def pickle_with_tuple_returns_bytes(self, protocol):
12125 t = (11, 22, 33)
12126 # @lint-ignore PYTHONPICKLEISBAD
12127 pickled = pickle.dumps(t, protocol)
12128 self.assertIs(type(pickled), bytes)
12129 # @lint-ignore PYTHONPICKLEISBAD
12130 unpickled = pickle.loads(pickled)
12131 self.assertEqual(t, unpickled)
12132 # Type must precisely be a tuple
12133 self.assertIs(type(unpickled), tuple)
12134
12135 def test_pickle_with_tuple_and_default_protocol_returns_bytes(self):
12136 self.pickle_with_tuple_returns_bytes(None)
12137
12138 def test_pickle_with_tuple_and_protocol_0_returns_bytes(self):
12139 self.pickle_with_tuple_returns_bytes(0)
12140
12141 def test_pickle_with_tuple_and_protocol_1_returns_bytes(self):
12142 self.pickle_with_tuple_returns_bytes(1)
12143
12144 def test_pickle_with_tuple_and_protocol_2_returns_bytes(self):
12145 self.pickle_with_tuple_returns_bytes(2)
12146
12147 def test_pickle_with_tuple_and_protocol_3_returns_bytes(self):
12148 self.pickle_with_tuple_returns_bytes(3)
12149
12150 # TODO(T85833587): Test needs _object_reduce_getstate implemented
12151 @cpython_only
12152 def test_tuple_subclass_pickles(self):
12153 t = TupleSubclass((11, 22, 33))
12154 # @lint-ignore PYTHONPICKLEISBAD
12155 pickled = pickle.dumps(t)
12156 self.assertIs(type(pickled), bytes)
12157 # @lint-ignore PYTHONPICKLEISBAD
12158 unpickled = pickle.loads(pickled)
12159 self.assertEqual(t, unpickled)
12160 # Type must precisely be a T
12161 self.assertIs(type(unpickled), TupleSubclass)
12162
12163 def pickle_with_tuple_iterator_returns_bytes(self, protocol):
12164 t = (11, 22, 33)
12165 it = iter(t)
12166 # @lint-ignore PYTHONPICKLEISBAD
12167 pickled = pickle.dumps(it, protocol)
12168 self.assertIs(type(pickled), bytes)
12169 # @lint-ignore PYTHONPICKLEISBAD
12170 unpickled_iterator = pickle.loads(pickled)
12171 self.assertIs(type(unpickled_iterator), type(it))
12172 items = tuple(unpickled_iterator)
12173 self.assertEqual(t, items)
12174
12175 def test_pickle_with_tuple_iterator_protocol_default_returns_bytes(self):
12176 self.pickle_with_tuple_iterator_returns_bytes(None)
12177
12178 def test_pickle_with_tuple_iterator_protocol_0_returns_bytes(self):
12179 self.pickle_with_tuple_iterator_returns_bytes(0)
12180
12181 def test_pickle_with_tuple_iterator_protocol_1_returns_bytes(self):
12182 self.pickle_with_tuple_iterator_returns_bytes(1)
12183
12184 def test_pickle_with_tuple_iterator_protocol_2_returns_bytes(self):
12185 self.pickle_with_tuple_iterator_returns_bytes(2)
12186
12187 def test_pickle_with_tuple_iterator_protocol_3_returns_bytes(self):
12188 self.pickle_with_tuple_iterator_returns_bytes(3)
12189
12190 def test_tupliter_reduce_with_iter_builtin_missing_raises_attribute_error(self):
12191 class remove_builtins_iter:
12192 def __enter__(self):
12193 self._saveiter = __builtins__.iter
12194 del __builtins__.iter
12195
12196 def __exit__(self, type, value, traceback):
12197 __builtins__.iter = self._saveiter
12198
12199 t = TupleSubclass((11, 22, 33))
12200 it = iter(t)
12201 with remove_builtins_iter():
12202 with self.assertRaises(AttributeError):
12203 it.__reduce__()
12204
12205 def pickle_tuple_iterator_with_subclass_iter_returns_bytes(self, protocol):
12206 t = TupleSubclass((11, 22, 33))
12207 it = iter(t)
12208 # @lint-ignore PYTHONPICKLEISBAD
12209 pickled = pickle.dumps(it, protocol)
12210 self.assertIs(type(pickled), bytes)
12211 # @lint-ignore PYTHONPICKLEISBAD
12212 unpickled_iterator = pickle.loads(pickled)
12213 self.assertIs(type(unpickled_iterator), type(it))
12214 items = tuple(unpickled_iterator)
12215 self.assertEqual(tuple(it), items)
12216 self.assertEqual(t, items)
12217
12218 def test_pickle_with_tuple_iterator_subclass_and_default_protocol_returns_bytes(
12219 self,
12220 ):
12221 self.pickle_tuple_iterator_with_subclass_iter_returns_bytes(None)
12222
12223 def test_pickle_with_tuple_iterator_subclass_and_protocol_0_returns_bytes(self):
12224 self.pickle_tuple_iterator_with_subclass_iter_returns_bytes(0)
12225
12226 def test_pickle_with_tuple_iterator_subclass_and_protocol_1_returns_bytes(self):
12227 self.pickle_tuple_iterator_with_subclass_iter_returns_bytes(1)
12228
12229 def test_pickle_with_tuple_iterator_subclass_and_protocol_2_returns_bytes(self):
12230 self.pickle_tuple_iterator_with_subclass_iter_returns_bytes(2)
12231
12232 def test_pickle_with_tuple_iterator_subclass_and_protocol_3_returns_bytes(self):
12233 self.pickle_tuple_iterator_with_subclass_iter_returns_bytes(3)
12234
12235 def pickle_with_reversedtuple_returns_bytes(self, protocol):
12236 t = (11, 22, 33)
12237 it = reversed(t)
12238 # @lint-ignore PYTHONPICKLEISBAD
12239 pickled = pickle.dumps(it, protocol)
12240 self.assertIs(type(pickled), bytes)
12241 # @lint-ignore PYTHONPICKLEISBAD
12242 unpickled_iterator = pickle.loads(pickled)
12243 items = tuple(unpickled_iterator)
12244 self.assertEqual(tuple(it), items)
12245
12246 def test_pickle_with_reversedtuple_and_default_protocol_returns_bytes(self):
12247 self.pickle_with_reversedtuple_returns_bytes(None)
12248
12249 def test_pickle_with_reversedtuple_and_protocol_0_returns_bytes(self):
12250 self.pickle_with_reversedtuple_returns_bytes(0)
12251
12252 def test_pickle_with_reversedtuple_and_protocol_1_returns_bytes(self):
12253 self.pickle_with_reversedtuple_returns_bytes(1)
12254
12255 def test_pickle_with_reversedtuple_and_protocol_2_returns_bytes(self):
12256 self.pickle_with_reversedtuple_returns_bytes(2)
12257
12258 def test_pickle_with_reversedtuple_and_protocol_3_returns_bytes(self):
12259 self.pickle_with_reversedtuple_returns_bytes(3)
12260
12261 def pickle_with_used_tuple_iterator_returns_bytes(self, protocol):
12262 t = (11, 22, 33)
12263 it = iter(t)
12264 self.assertEqual(it.__next__(), 11)
12265 # @lint-ignore PYTHONPICKLEISBAD
12266 pickled = pickle.dumps(it, protocol)
12267 self.assertIs(type(pickled), bytes)
12268 # @lint-ignore PYTHONPICKLEISBAD
12269 unpickled_iterator = pickle.loads(pickled)
12270 self.assertIs(type(unpickled_iterator), type(it))
12271 items = tuple(unpickled_iterator)
12272 self.assertEqual(t[1:], items)
12273
12274 def test_pickle_with_used_tuple_iterator_and_default_protocol_returns_bytes(self):
12275 self.pickle_with_used_tuple_iterator_returns_bytes(None)
12276
12277 def test_pickle_with_used_tuple_iterator_and_protocol_0_returns_bytes(self):
12278 self.pickle_with_used_tuple_iterator_returns_bytes(0)
12279
12280 def test_pickle_with_used_tuple_iterator_and_protocol_1_returns_bytes(self):
12281 self.pickle_with_used_tuple_iterator_returns_bytes(1)
12282
12283 def test_pickle_with_used_tuple_iterator_and_protocol_2_returns_bytes(self):
12284 self.pickle_with_used_tuple_iterator_returns_bytes(2)
12285
12286 def test_pickle_with_used_tuple_iterator_and_protocol_3_returns_bytes(self):
12287 self.pickle_with_used_tuple_iterator_returns_bytes(3)
12288
12289 def pickle_with_used_tuplesubclass_iter_returns_bytes(self, protocol):
12290 t = TupleSubclass((11, 22, 33))
12291 it = iter(t)
12292 self.assertEqual(it.__next__(), 11)
12293 # @lint-ignore PYTHONPICKLEISBAD
12294 pickled = pickle.dumps(it, protocol)
12295 self.assertIs(type(pickled), bytes)
12296 # @lint-ignore PYTHONPICKLEISBAD
12297 unpickled_iterator = pickle.loads(pickled)
12298 self.assertIs(type(unpickled_iterator), type(it))
12299 items = tuple(unpickled_iterator)
12300 self.assertEqual(t[1:], items)
12301
12302 def test_pickle_with_used_tuplesubclass_iter_and_default_protocol_returns_bytes(
12303 self,
12304 ):
12305 self.pickle_with_used_tuplesubclass_iter_returns_bytes(None)
12306
12307 def test_pickle_with_used_tuplesubclass_iter_and_protocol_0_returns_bytes(
12308 self,
12309 ):
12310 self.pickle_with_used_tuplesubclass_iter_returns_bytes(0)
12311
12312 def test_pickle_with_used_tuplesubclass_iter_and_protocol_1_returns_bytes(
12313 self,
12314 ):
12315 self.pickle_with_used_tuplesubclass_iter_returns_bytes(1)
12316
12317 def test_pickle_with_used_tuplesubclass_iter_and_protocol_2_returns_bytes(
12318 self,
12319 ):
12320 self.pickle_with_used_tuplesubclass_iter_returns_bytes(2)
12321
12322 def test_pickle_with_used_tuplesubclass_iter_and_protocol_3_returns_bytes(
12323 self,
12324 ):
12325 self.pickle_with_used_tuplesubclass_iter_returns_bytes(3)
12326
12327 def test_tuple_iterator_setstate_with_noninteger_raises_type_error(self):
12328 t = (11, 22, 33)
12329 it = iter(t)
12330 with self.assertRaises(TypeError):
12331 it.__setstate__("hello")
12332
12333 def test_getnewargs_with_ground_tuple_returns_tuple_of_self(self):
12334 t = (11, 22, 33)
12335 result = t.__getnewargs__()
12336 self.assertEqual(result, (t,))
12337 self.assertIs(result[0], t)
12338
12339 def test_getnewargs_with_tuple_subclass_without_iter_returns_tuple(self):
12340 class T(tuple):
12341 def __iter__(self):
12342 raise NotImplementedError("bad")
12343
12344 t = T((11, 22, 33))
12345 result = t.__getnewargs__()
12346 self.assertEqual(result, (t,))
12347 self.assertIsNot(result[0], t)
12348 self.assertIs(type(result[0]), tuple)
12349
12350 def test_tuple_iterator_setstate_with_int_returns_none(self):
12351 t = (11, 22, 33)
12352 it = iter(t)
12353 self.assertIsNone(it.__setstate__(0))
12354
12355 def test_tuple_iterator_setstate_with_int_in_range_returns_none(self):
12356 t = (11, 22, 33)
12357 it = iter(t)
12358 self.assertIsNone(it.__setstate__(0))
12359 self.assertEqual(it.__reduce__()[2], 0)
12360 self.assertIsNone(it.__setstate__(1))
12361 self.assertEqual(it.__reduce__()[2], 1)
12362 self.assertIsNone(it.__setstate__(2))
12363 self.assertEqual(it.__reduce__()[2], 2)
12364 self.assertIsNone(it.__setstate__(3))
12365 self.assertEqual(it.__reduce__()[2], 3)
12366
12367 def test_tuple_iterator_setstate_with_negative_int_returns_none(self):
12368 t = (11, 22, 33)
12369 it = iter(t)
12370 self.assertIsNone(it.__setstate__(-1))
12371 self.assertEqual(it.__reduce__()[2], 0)
12372
12373 def test_tuple_iterator_setstate_with_int_greater_than_size_returns_none(self):
12374 t = (11, 22, 33)
12375 it = iter(t)
12376 self.assertIsNone(it.__setstate__(4))
12377 self.assertEqual(it.__reduce__()[2], 3)
12378
12379 def test_tuple_iterator_setstate_with_largest_native_int_returns_none(self):
12380 t = (11, 22, 33)
12381 it = iter(t)
12382 self.assertIsNone(it.__setstate__(sys.maxsize))
12383 self.assertEqual(it.__reduce__()[2], 3)
12384
12385 def test_tuple_iterator_setstate_with_most_negative_native_int_returns_none(self):
12386 t = (11, 22, 33)
12387 it = iter(t)
12388 verynegative = (-sys.maxsize) - 1
12389 self.assertIsNone(it.__setstate__(verynegative))
12390 self.assertEqual(it.__reduce__()[2], 0)
12391
12392 def test_tuple_iterator_setstate_with_large_int_raises_overflow_error(self):
12393 t = (11, 22, 33)
12394 it = iter(t)
12395 large = 2 ** 1000
12396 with self.assertRaises(OverflowError):
12397 it.__setstate__(large)
12398
12399 def test_tuple_iterator_setstate_with_negative_large_int_raises_overflow_error(
12400 self,
12401 ):
12402 t = (11, 22, 33)
12403 it = iter(t)
12404 negative_large = -(2 ** 1000)
12405 with self.assertRaises(OverflowError):
12406 it.__setstate__(negative_large)
12407
12408 def test_tuple_iterator_setstate_with_noninteger_raises_type_error(self):
12409 t = (11, 22, 33)
12410 it = iter(t)
12411 with self.assertRaises(TypeError):
12412 it.__setstate__("hello")
12413
12414 def test_tuple_iterator_setstate_with_integer_convertable_raises_type_error(self):
12415 t = (11, 22, 33)
12416 it = iter(t)
12417 with self.assertRaises(TypeError):
12418 it.__setstate__(1.0)
12419
12420 def test_tuple_iterator_setstate_with_int_subclass_returns_none(self):
12421 class T(int):
12422 pass
12423
12424 t = (11, 22, 33)
12425 it = iter(t)
12426 n = T(1)
12427 self.assertIsNone(it.__setstate__(n))
12428 self.assertEqual(it.__reduce__()[2], n)
12429 self.assertIs(type(it.__reduce__()[2]), int)
12430
12431 def test_tuple_iterator_reduce_with_ground_tuple_returns_tuple(self):
12432 t = (11, 22, 33)
12433 it = iter(t)
12434 reduction = it.__reduce__()
12435 self.assertEqual(reduction, (iter, (t,), 0))
12436 self.assertIs(reduction[0], iter)
12437 self.assertIs(type(reduction[1]), tuple)
12438 self.assertIs(type(reduction[1][0]), tuple)
12439 self.assertIs(type(reduction[2]), int)
12440
12441 def test_tuple_iterator_reduce_with_empty_tuple_returns_tuple(self):
12442 t = ()
12443 it = iter(t)
12444 reduction = it.__reduce__()
12445 self.assertEqual(reduction, (iter, (t,), 0))
12446 self.assertIs(reduction[0], iter)
12447 self.assertIs(type(reduction[1]), tuple)
12448 self.assertIs(type(reduction[1][0]), tuple)
12449
12450 def test_tuple_iterator_reduce_with_tuple_subclass_returns_tuple(self):
12451 class T(tuple):
12452 pass
12453
12454 ground = (11, 22, 33)
12455 t = T(ground)
12456 it = iter(t)
12457 reduction = it.__reduce__()
12458 self.assertEqual(reduction, (iter, (t,), 0))
12459 self.assertIs(reduction[0], iter)
12460 self.assertIs(type(reduction[1]), tuple)
12461 self.assertIs(type(reduction[2]), int)
12462
12463 def test_tuple_iterator_reduce_with_empty_tuple_subclass_returns_tuple(self):
12464 class T(tuple):
12465 pass
12466
12467 ground = (11, 22, 33)
12468 t = T(ground)
12469 it = iter(t)
12470 reduction = it.__reduce__()
12471 self.assertEqual(reduction, (iter, (t,), 0))
12472 self.assertIs(reduction[0], iter)
12473 self.assertIs(type(reduction[1]), tuple)
12474
12475
12476class VarsTests(unittest.TestCase):
12477 def test_no_arg_delegates_to_locals(self):
12478 def foo():
12479 a = 4
12480 a = a # noqa: F841
12481 b = 5
12482 b = b # noqa: F841
12483 return vars()
12484
12485 result = foo()
12486 self.assertIsInstance(result, dict)
12487 self.assertEqual(len(result), 2)
12488 self.assertEqual(result["a"], 4)
12489 self.assertEqual(result["b"], 5)
12490
12491 def test_arg_with_no_dunder_dict_raises_type_error(self):
12492 with self.assertRaises(TypeError) as context:
12493 vars(None)
12494 self.assertEqual(
12495 str(context.exception), "vars() argument must have __dict__ attribute"
12496 )
12497
12498 def test_arg_with_dunder_dict_raising_attribute_error_raises_type_error(self):
12499 class Desc:
12500 def __get__(self, obj, type):
12501 raise AttributeError("called descriptor")
12502
12503 class C:
12504 __dict__ = Desc()
12505
12506 c = C()
12507 with self.assertRaises(TypeError) as context:
12508 vars(c)
12509 self.assertEqual(
12510 str(context.exception), "vars() argument must have __dict__ attribute"
12511 )
12512
12513 def test_arg_with_dunder_dict_propagates_exception(self):
12514 class Desc:
12515 def __get__(self, obj, type):
12516 raise UserWarning("called descriptor")
12517
12518 class C:
12519 __dict__ = Desc()
12520
12521 c = C()
12522 with self.assertRaises(UserWarning):
12523 vars(c)
12524
12525 def test_arg_with_dunder_dict_returns_dunder_dict(self):
12526 class C:
12527 __dict__ = 4
12528
12529 c = C()
12530 self.assertEqual(vars(c), 4)
12531
12532
12533@pyro_only
12534class UnderNumberCheckTests(unittest.TestCase):
12535 def test_number_check_with_builtin_number_returns_true(self):
12536 self.assertTrue(_number_check(2))
12537 self.assertTrue(_number_check(False))
12538 self.assertTrue(_number_check(5.0))
12539
12540 def test_number_check_without_class_method_returns_false(self):
12541 class Foo:
12542 pass
12543
12544 foo = Foo()
12545 foo.__float__ = lambda: 1.0
12546 foo.__int__ = lambda: 2
12547 self.assertFalse(_number_check(foo))
12548
12549 def test_number_check_with_dunder_index_descriptor_does_not_call(self):
12550 class Raise:
12551 def __get__(self, obj, type):
12552 raise AttributeError("bad")
12553
12554 class FloatLike:
12555 __float__ = Raise()
12556
12557 class IntLike:
12558 __int__ = Raise()
12559
12560 self.assertTrue(_number_check(FloatLike()))
12561 self.assertTrue(_number_check(IntLike()))
12562
12563
12564@unittest.skipIf(
12565 sys.version_info < (3, 10) and sys.implementation.name != "skybison",
12566 "Union requrires CPython 3.10",
12567)
12568class UnionTests(unittest.TestCase):
12569 def test_or_type_operator(self):
12570 self.assertEqual(int | str, typing.Union[int, str])
12571 self.assertNotEqual(int | list, typing.Union[int, str])
12572 self.assertEqual(str | int, typing.Union[int, str])
12573 self.assertEqual(int | None, typing.Union[int, None])
12574 self.assertEqual(None | int, typing.Union[int, None])
12575 self.assertEqual(int | str | list, typing.Union[int, str, list])
12576 self.assertEqual(int | (str | list), typing.Union[int, str, list])
12577 self.assertEqual(str | (int | list), typing.Union[int, str, list])
12578 self.assertEqual(
12579 typing.List | typing.Tuple, typing.Union[typing.List, typing.Tuple]
12580 )
12581 self.assertEqual(
12582 typing.List[int] | typing.Tuple[int],
12583 typing.Union[typing.List[int], typing.Tuple[int]],
12584 )
12585 self.assertEqual(typing.List[int] | None, typing.Union[typing.List[int], None])
12586 self.assertEqual(None | typing.List[int], typing.Union[None, typing.List[int]])
12587 self.assertEqual(
12588 str | float | int | complex | int, (int | str) | (float | complex)
12589 )
12590 self.assertEqual(
12591 typing.Union[str, int, typing.List[int]], str | int | typing.List[int]
12592 )
12593 self.assertEqual(
12594 typing.Union[str, int, float, complex], (int | str) | (float | complex)
12595 )
12596 self.assertEqual(int | int, int)
12597 self.assertEqual(
12598 BaseException | bool | bytes | complex | float | int | list | map | set,
12599 typing.Union[
12600 BaseException,
12601 bool,
12602 bytes,
12603 complex,
12604 float,
12605 int,
12606 list,
12607 map,
12608 set,
12609 ],
12610 )
12611 with self.assertRaises(TypeError):
12612 int | 3
12613 with self.assertRaises(TypeError):
12614 3 | int
12615 with self.assertRaises(TypeError):
12616 Example() | int
12617 with self.assertRaises(TypeError):
12618 (int | str) < typing.Union[str, int]
12619 with self.assertRaises(TypeError):
12620 (int | str) < (int | bool)
12621 with self.assertRaises(TypeError):
12622 (int | str) <= (int | str)
12623
12624 def test_or_type_operator_with_Alias(self):
12625 self.assertEqual(list | str, typing.Union[list, str])
12626 self.assertEqual(typing.List | str, typing.Union[typing.List, str])
12627
12628 def test_or_type_operator_with_IO(self):
12629 self.assertEqual(typing.IO | str, typing.Union[typing.IO, str])
12630
12631 def test_or_type_operator_with_NamedTuple(self):
12632 NT = namedtuple("A", ["B", "C", "D"])
12633 self.assertEqual(NT | str, typing.Union[NT, str])
12634
12635 def test_or_type_operator_with_NewType(self):
12636 UserId = typing.NewType("UserId", int)
12637 self.assertEqual(UserId | str, typing.Union[UserId, str])
12638
12639 def test_or_type_operator_with_SpecialForm(self):
12640 self.assertEqual(typing.Any | str, typing.Union[typing.Any, str])
12641 self.assertEqual(typing.NoReturn | str, typing.Union[typing.NoReturn, str])
12642 self.assertEqual(
12643 typing.Optional[int] | str, typing.Union[typing.Optional[int], str]
12644 )
12645 self.assertEqual(typing.Optional[int] | str, typing.Union[int, str, None])
12646 self.assertEqual(typing.Union[int, bool] | str, typing.Union[int, bool, str])
12647 self.assertNotEqual(str | int, typing.Tuple[str, int])
12648
12649 def test_or_type_operator_with_TypeVar(self):
12650 TV = typing.TypeVar("T")
12651 self.assertEqual(TV | str, typing.Union[TV, str])
12652 self.assertEqual(str | TV, typing.Union[str, TV])
12653
12654 def test_or_type_repr(self):
12655 self.assertEqual(repr(int | None), "int | None")
12656
12657 def test_isinstance_with_or_union(self):
12658 self.assertTrue(isinstance(Super(), Super | int))
12659 self.assertFalse(isinstance(None, str | int))
12660 self.assertTrue(isinstance(3, str | int))
12661 self.assertTrue(isinstance("", str | int))
12662 self.assertTrue(isinstance(None, int | None))
12663 self.assertFalse(isinstance(3.14, int | str))
12664
12665 def test_isinstance_raises_type_error(self):
12666 with self.assertRaises(TypeError):
12667 isinstance(2, list[int])
12668 with self.assertRaises(TypeError):
12669 isinstance(2, list[int] | int)
12670 with self.assertRaises(TypeError):
12671 isinstance(2, int | str | list[int] | float)
12672
12673 def test_subclass_with_union(self):
12674 self.assertTrue(issubclass(int, int | float | int))
12675 self.assertTrue(issubclass(str, str | Child | str))
12676 self.assertFalse(issubclass(dict, float | str))
12677 self.assertFalse(issubclass(object, float | str))
12678 with self.assertRaises(TypeError):
12679 issubclass(2, Child | Super)
12680 with self.assertRaises(TypeError):
12681 issubclass(int, list[int] | Child)
12682
12683
12684class ZipTests(unittest.TestCase):
12685 def test_no_iterables_returns_stopped_iterator(self):
12686 self.assertTupleEqual(tuple(zip()), ())
12687
12688 def test_one_iterable_returns_1_tuples(self):
12689 self.assertTupleEqual(tuple(zip(range(3))), ((0,), (1,), (2,)))
12690
12691 def test_two_iterables_returns_2_tuples(self):
12692 self.assertTupleEqual(
12693 tuple(zip(range(0, 6, 2), range(1, 6, 2))), ((0, 1), (2, 3), (4, 5))
12694 )
12695
12696 def test_two_iterables_returns_shortest(self):
12697 self.assertTupleEqual(tuple(zip(range(10), range(3))), ((0, 0), (1, 1), (2, 2)))
12698 self.assertTupleEqual(tuple(zip(range(3), range(10))), ((0, 0), (1, 1), (2, 2)))
12699
12700 def test_three_iterables_returns_3_tuples(self):
12701 self.assertTupleEqual(
12702 tuple(zip(range(0, 10, 3), range(1, 10, 3), range(2, 10, 3))),
12703 ((0, 1, 2), (3, 4, 5), (6, 7, 8)),
12704 )
12705
12706 def test_three_iterables_returns_shortest(self):
12707 self.assertTupleEqual(
12708 tuple(zip(range(3), range(10), range(4))), ((0, 0, 0), (1, 1, 1), (2, 2, 2))
12709 )
12710 self.assertTupleEqual(
12711 tuple(zip(range(3), range(4), range(10))), ((0, 0, 0), (1, 1, 1), (2, 2, 2))
12712 )
12713 self.assertTupleEqual(
12714 tuple(zip(range(10), range(3), range(4))), ((0, 0, 0), (1, 1, 1), (2, 2, 2))
12715 )
12716 self.assertTupleEqual(
12717 tuple(zip(range(10), range(4), range(3))), ((0, 0, 0), (1, 1, 1), (2, 2, 2))
12718 )
12719 self.assertTupleEqual(
12720 tuple(zip(range(4), range(3), range(10))), ((0, 0, 0), (1, 1, 1), (2, 2, 2))
12721 )
12722 self.assertTupleEqual(
12723 tuple(zip(range(4), range(10), range(3))), ((0, 0, 0), (1, 1, 1), (2, 2, 2))
12724 )
12725
12726
12727@pyro_only
12728class TestUnimplemented(unittest.TestCase):
12729 def test_unimplemented_raises_with_env_variable(self):
12730 @contextlib.contextmanager
12731 def temporary_env(name, value):
12732 previous_value = os.getenv(name)
12733 os.putenv(name, value)
12734 try:
12735 yield
12736 finally:
12737 if previous_value is None:
12738 os.unsetenv(name)
12739 else:
12740 os.putenv(name, previous_value)
12741
12742 with temporary_env("PYRO_RAISE_ON_UNIMPLEMENTED", "1"):
12743 with self.assertRaises(NotImplementedError):
12744 ImportError().__reduce__()
12745
12746 def test_unimplemented_raises_with_system_variable(self):
12747 class temporary_sysvar:
12748 def __init__(self, name, value):
12749 self._name = name
12750 self._value = value
12751 self._empty = object()
12752
12753 def __enter__(self):
12754 self._previous_value = getattr(sys, self._name, self._empty)
12755 setattr(sys, self._name, self._value)
12756
12757 def __exit__(self, exctype, excinst, exctb):
12758 if self._previous_value is self._empty:
12759 delattr(sys, self._name)
12760 else:
12761 setattr(sys, self._name, self._previous_value)
12762
12763 with temporary_sysvar("PYRO_RAISE_ON_UNIMPLEMENTED", True):
12764 with self.assertRaises(NotImplementedError):
12765 ImportError().__reduce__()
12766
12767
12768class FrameTests(unittest.TestCase):
12769 def test_clear_clears_locals(self):
12770 def inner():
12771 try:
12772 raise Exception("test")
12773 except Exception as e:
12774 return e.__traceback__.tb_frame
12775
12776 frame = inner()
12777 self.assertIsNot(frame, None)
12778 self.assertIsNot(frame.f_locals, None)
12779 # Ensure that frame.clear() exists.
12780 # TODO(T86451971): Properly test behavior once we implement it. For now, we just test that
12781 # clear() doesn't raise.
12782 frame.clear()
12783
12784
12785if __name__ == "__main__":
12786 unittest.main()