Lines Matching refs:self
18 def test_enter(self):
20 def __exit__(self, *args):
24 self.assertIs(manager.__enter__(), manager)
26 def test_exit_is_abstract(self):
30 with self.assertRaises(TypeError):
33 def test_structural_subclassing(self):
35 def __enter__(self):
36 return self
37 def __exit__(self, exc_type, exc_value, traceback):
40 self.assertTrue(issubclass(ManagerFromScratch, AbstractContextManager))
43 def __exit__(self, *args):
46 self.assertTrue(issubclass(DefaultEnter, AbstractContextManager))
51 self.assertFalse(issubclass(NoEnter, AbstractContextManager))
56 self.assertFalse(issubclass(NoExit, AbstractContextManager))
61 def test_contextmanager_plain(self):
69 self.assertEqual(state, [1])
70 self.assertEqual(x, 42)
72 self.assertEqual(state, [1, 42, 999])
74 def test_contextmanager_finally(self):
83 with self.assertRaises(ZeroDivisionError):
85 self.assertEqual(state, [1])
86 self.assertEqual(x, 42)
89 self.assertEqual(state, [1, 42, 999])
91 def test_contextmanager_traceback(self):
102 self.assertEqual(len(frames), 1)
103 self.assertEqual(frames[0].name, 'test_contextmanager_traceback')
104 self.assertEqual(frames[0].line, '1/0')
116 self.assertEqual(len(frames), 1)
117 self.assertEqual(frames[0].name, 'test_contextmanager_traceback')
118 self.assertEqual(frames[0].line, 'raise RuntimeErrorSubclass(42)')
127 with self.subTest(type=type(stop_exc)):
132 self.assertIs(e, stop_exc)
135 self.fail(f'{stop_exc} was suppressed')
137 self.assertEqual(len(frames), 1)
138 self.assertEqual(frames[0].name, 'test_contextmanager_traceback')
139 self.assertEqual(frames[0].line, 'raise stop_exc')
141 def test_contextmanager_no_reraise(self):
148 self.assertFalse(ctx.__exit__(TypeError, TypeError("foo"), None))
150 def test_contextmanager_trap_yield_after_throw(self):
159 self.assertRaises(
163 def test_contextmanager_except(self):
172 self.assertEqual(state, [1, 42, 999])
174 self.assertEqual(state, [1])
175 self.assertEqual(x, 42)
178 self.assertEqual(state, [1, 42, 999])
180 def test_contextmanager_except_stopiter(self):
189 with self.subTest(type=type(stop_exc)):
194 self.assertIs(ex, stop_exc)
196 self.fail(f'{stop_exc} was suppressed')
198 def test_contextmanager_except_pep479(self):
215 self.assertIs(ex, stop_exc)
217 self.fail('StopIteration was suppressed')
219 def test_contextmanager_do_not_unchain_non_stopiteration_exceptions(self):
230 self.assertIs(type(ex), RuntimeError)
231 self.assertEqual(ex.args[0], 'issue29692:Chained')
232 self.assertIsInstance(ex.__cause__, ZeroDivisionError)
238 self.assertIs(type(ex), StopIteration)
239 self.assertEqual(ex.args[0], 'issue29692:Unchained')
240 self.assertIsNone(ex.__cause__)
242 def _create_contextmanager_attribs(self):
255 def test_contextmanager_attribs(self):
256 baz = self._create_contextmanager_attribs()
257 self.assertEqual(baz.__name__,'baz')
258 self.assertEqual(baz.foo, 'bar')
261 def test_contextmanager_doc_attrib(self):
262 baz = self._create_contextmanager_attribs()
263 self.assertEqual(baz.__doc__, "Whee!")
266 def test_instance_docstring_given_cm_docstring(self):
267 baz = self._create_contextmanager_attribs()(None)
268 self.assertEqual(baz.__doc__, "Whee!")
270 def test_keywords(self):
273 def woohoo(self, func, args, kwds):
274 yield (self, func, args, kwds)
275 with woohoo(self=11, func=22, args=33, kwds=44) as target:
276 self.assertEqual(target, (11, 22, 33, 44))
278 def test_nokeepref(self):
288 self.assertIsNone(a())
289 self.assertIsNone(b())
295 def test_param_errors(self):
300 with self.assertRaises(TypeError):
302 with self.assertRaises(TypeError):
304 with self.assertRaises(TypeError):
307 def test_recursive(self):
316 self.assertEqual(depth, before)
324 self.assertEqual(depth, 0)
330 def test_instance_docs(self):
334 self.assertEqual(obj.__doc__, cm_docstring)
336 def test_closing(self):
339 def close(self):
342 self.assertEqual(state, [])
344 self.assertEqual(x, y)
345 self.assertEqual(state, [1])
347 def test_closing_error(self):
350 def close(self):
353 self.assertEqual(state, [])
354 with self.assertRaises(ZeroDivisionError):
356 self.assertEqual(x, y)
358 self.assertEqual(state, [1])
362 def test_nullcontext(self):
367 self.assertIs(c_in, c)
372 def testWithOpen(self):
377 self.assertFalse(f.closed)
379 self.assertTrue(f.closed)
381 with self.assertRaises(ZeroDivisionError):
383 self.assertFalse(f.closed)
384 self.assertEqual(f.read(), "Booh\n")
386 self.assertTrue(f.closed)
392 def boilerPlate(self, lock, locked):
393 self.assertFalse(locked())
395 self.assertTrue(locked())
396 self.assertFalse(locked())
397 with self.assertRaises(ZeroDivisionError):
399 self.assertTrue(locked())
401 self.assertFalse(locked())
403 def testWithLock(self):
405 self.boilerPlate(lock, lock.locked)
407 def testWithRLock(self):
409 self.boilerPlate(lock, lock._is_owned)
411 def testWithCondition(self):
415 self.boilerPlate(lock, locked)
417 def testWithSemaphore(self):
425 self.boilerPlate(lock, locked)
427 def testWithBoundedSemaphore(self):
435 self.boilerPlate(lock, locked)
444 def __enter__(self):
445 self.started = True
446 return self
448 def __exit__(self, *exc):
449 self.exc = exc
450 return self.catch
456 def test_instance_docs(self):
460 self.assertEqual(obj.__doc__, cm_docstring)
462 def test_contextdecorator(self):
465 self.assertIs(result, context)
466 self.assertTrue(context.started)
468 self.assertEqual(context.exc, (None, None, None))
471 def test_contextdecorator_with_exception(self):
474 with self.assertRaisesRegex(NameError, 'foo'):
477 self.assertIsNotNone(context.exc)
478 self.assertIs(context.exc[0], NameError)
484 self.assertIsNotNone(context.exc)
485 self.assertIs(context.exc[0], NameError)
488 def test_decorator(self):
493 self.assertIsNone(context.exc)
494 self.assertTrue(context.started)
496 self.assertEqual(context.exc, (None, None, None))
499 def test_decorator_with_exception(self):
504 self.assertIsNone(context.exc)
505 self.assertTrue(context.started)
508 with self.assertRaisesRegex(NameError, 'foo'):
510 self.assertIsNotNone(context.exc)
511 self.assertIs(context.exc[0], NameError)
514 def test_decorating_method(self):
520 def method(self, a, b, c=None):
521 self.a = a
522 self.b = b
523 self.c = c
528 self.assertEqual(test.a, 1)
529 self.assertEqual(test.b, 2)
530 self.assertEqual(test.c, None)
534 self.assertEqual(test.a, 'a')
535 self.assertEqual(test.b, 'b')
536 self.assertEqual(test.c, 'c')
540 self.assertEqual(test.a, 1)
541 self.assertEqual(test.b, 2)
544 def test_typo_enter(self):
546 def __unter__(self):
548 def __exit__(self, *exc):
551 with self.assertRaisesRegex(TypeError, 'the context manager'):
556 def test_typo_exit(self):
558 def __enter__(self):
560 def __uxit__(self, *exc):
563 with self.assertRaisesRegex(TypeError, 'the context manager.*__exit__'):
568 def test_contextdecorator_as_mixin(self):
573 def __enter__(self):
574 self.started = True
575 return self
577 def __exit__(self, *exc):
578 self.exc = exc
586 self.assertIsNone(context.exc)
587 self.assertTrue(context.started)
589 self.assertEqual(context.exc, (None, None, None))
592 def test_contextmanager_as_decorator(self):
602 self.assertEqual(state, [1])
605 self.assertEqual(state, [1, 'something', 999])
610 self.assertEqual(state, [1, 'something else', 999])
617 def test_instance_docs(self):
619 cm_docstring = self.exit_stack.__doc__
620 obj = self.exit_stack()
621 self.assertEqual(obj.__doc__, cm_docstring)
623 def test_no_resources(self):
624 with self.exit_stack():
627 def test_callback(self):
635 ((1,2), dict(self=3, callback=4)),
641 with self.exit_stack() as stack:
651 self.assertIs(f, _exit)
653 self.assertIs(wrapper[1].__wrapped__, _exit)
654 self.assertNotEqual(wrapper[1].__name__, _exit.__name__)
655 self.assertIsNone(wrapper[1].__doc__, _exit.__doc__)
656 self.assertEqual(result, expected)
659 with self.exit_stack() as stack:
660 with self.assertRaises(TypeError):
662 with self.assertRaises(TypeError):
663 self.exit_stack.callback(arg=2)
664 with self.assertRaises(TypeError):
666 self.assertEqual(result, [])
668 def test_push(self):
671 self.assertIs(exc_type, exc_raised)
675 self.assertIsNone(exc_type)
676 self.assertIsNone(exc)
677 self.assertIsNone(exc_tb)
679 def __init__(self, check_exc):
680 self.check_exc = check_exc
681 def __enter__(self):
682 self.fail("Should not be called!")
683 def __exit__(self, *exc_details):
684 self.check_exc(*exc_details)
685 with self.exit_stack() as stack:
687 self.assertIs(stack._exit_callbacks[-1][1], _expect_ok)
690 self.assertIs(stack._exit_callbacks[-1][1].__self__, cm)
692 self.assertIs(stack._exit_callbacks[-1][1], _suppress_exc)
695 self.assertIs(stack._exit_callbacks[-1][1].__self__, cm)
697 self.assertIs(stack._exit_callbacks[-1][1], _expect_exc)
699 self.assertIs(stack._exit_callbacks[-1][1], _expect_exc)
702 def test_enter_context(self):
704 def __enter__(self):
706 def __exit__(self, *exc_details):
711 with self.exit_stack() as stack:
715 self.assertIsNotNone(_exit)
717 self.assertIs(stack._exit_callbacks[-1][1].__self__, cm)
719 self.assertEqual(result, [1, 2, 3, 4])
721 def test_enter_context_errors(self):
725 def __exit__(self, *exc_info):
728 def __enter__(self):
731 with self.exit_stack() as stack:
732 with self.assertRaisesRegex(TypeError, 'the context manager'):
734 with self.assertRaisesRegex(TypeError, 'the context manager'):
736 with self.assertRaisesRegex(TypeError, 'the context manager'):
738 self.assertFalse(stack._exit_callbacks)
740 def test_close(self):
742 with self.exit_stack() as stack:
746 self.assertIsNotNone(_exit)
749 self.assertEqual(result, [1, 2])
751 def test_pop_all(self):
753 with self.exit_stack() as stack:
757 self.assertIsNotNone(_exit)
762 self.assertEqual(result, [1, 2, 3])
764 def test_exit_raise(self):
765 with self.assertRaises(ZeroDivisionError):
766 with self.exit_stack() as stack:
770 def test_exit_suppress(self):
771 with self.exit_stack() as stack:
775 def test_exit_exception_traceback(self):
785 with self.exit_stack() as stack:
791 self.assertIsInstance(exc, ValueError)
794 [('test_exit_exception_traceback', 'with self.exit_stack() as stack:')] + \
795 self.callback_error_internal_frames + \
799 self.assertEqual(
802 self.assertIsInstance(exc.__context__, ZeroDivisionError)
804 self.assertEqual([(f.name, f.line) for f in zde_frames],
807 def test_exit_exception_chaining_reference(self):
811 def __init__(self, exc):
812 self.exc = exc
813 def __enter__(self):
814 return self
815 def __exit__(self, *exc_details):
816 raise self.exc
819 def __init__(self, outer, inner):
820 self.outer = outer
821 self.inner = inner
822 def __enter__(self):
823 return self
824 def __exit__(self, *exc_details):
826 raise self.inner
828 raise self.outer
831 def __enter__(self):
832 return self
833 def __exit__(self, *exc_details):
834 type(self).saved_details = exc_details
844 self.assertIsInstance(exc.__context__, KeyError)
845 self.assertIsInstance(exc.__context__.__context__, AttributeError)
847 self.assertIsNone(exc.__context__.__context__.__context__)
849 self.fail("Expected IndexError, but no exception was raised")
852 self.assertIsInstance(inner_exc, ValueError)
853 self.assertIsInstance(inner_exc.__context__, ZeroDivisionError)
855 def test_exit_exception_chaining(self):
867 with self.exit_stack() as stack:
875 self.assertIsInstance(exc.__context__, KeyError)
876 self.assertIsInstance(exc.__context__.__context__, AttributeError)
878 self.assertIsNone(exc.__context__.__context__.__context__)
880 self.fail("Expected IndexError, but no exception was raised")
883 self.assertIsInstance(inner_exc, ValueError)
884 self.assertIsInstance(inner_exc.__context__, ZeroDivisionError)
886 def test_exit_exception_explicit_none_context(self):
906 with self.exit_stack() as stack:
911 with self.subTest():
916 self.assertIsNone(exc.__context__)
918 self.fail("Expected IndexError, but no exception was raised")
920 def test_exit_exception_non_suppressing(self):
929 with self.exit_stack() as stack:
933 self.assertIsInstance(exc, IndexError)
935 self.fail("Expected IndexError, but no exception was raised")
938 with self.exit_stack() as stack:
943 self.assertIsInstance(exc, KeyError)
945 self.fail("Expected KeyError, but no exception was raised")
947 def test_exit_exception_with_correct_context(self):
963 # infinite self-referential loop
965 with self.exit_stack() as stack:
971 self.assertIs(exc, exc4)
972 self.assertIs(exc.__context__, exc3)
973 self.assertIs(exc.__context__.__context__, exc2)
974 self.assertIs(exc.__context__.__context__.__context__, exc1)
975 self.assertIsNone(
978 def test_exit_exception_with_existing_context(self):
992 with self.exit_stack() as stack:
997 self.assertIs(exc, exc5)
998 self.assertIs(exc.__context__, exc4)
999 self.assertIs(exc.__context__.__context__, exc3)
1000 self.assertIs(exc.__context__.__context__.__context__, exc2)
1001 self.assertIs(
1003 self.assertIsNone(
1006 def test_body_exception_suppress(self):
1010 with self.exit_stack() as stack:
1014 self.fail("Expected no exception, got IndexError")
1016 def test_exit_exception_chaining_suppress(self):
1017 with self.exit_stack() as stack:
1022 def test_excessive_nesting(self):
1024 with self.exit_stack() as stack:
1028 def test_instance_bypass(self):
1033 stack = self.exit_stack()
1034 with self.assertRaisesRegex(TypeError, 'the context manager'):
1037 self.assertIs(stack._exit_callbacks[-1][1], cm)
1039 def test_dont_reraise_RuntimeError(self):
1060 with self.assertRaises(UniqueException) as err_ctx:
1061 with self.exit_stack() as es_ctx:
1067 self.assertIsInstance(exc, UniqueException)
1068 self.assertIsInstance(exc.__context__, UniqueRuntimeError)
1069 self.assertIsNone(exc.__context__.__context__)
1070 self.assertIsNone(exc.__context__.__cause__)
1071 self.assertIs(exc.__cause__, exc.__context__)
1088 def test_instance_docs(self):
1090 cm_docstring = self.redirect_stream.__doc__
1091 obj = self.redirect_stream(None)
1092 self.assertEqual(obj.__doc__, cm_docstring)
1094 def test_no_redirect_in_init(self):
1095 orig_stdout = getattr(sys, self.orig_stream)
1096 self.redirect_stream(None)
1097 self.assertIs(getattr(sys, self.orig_stream), orig_stdout)
1099 def test_redirect_to_string_io(self):
1102 orig_stdout = getattr(sys, self.orig_stream)
1103 with self.redirect_stream(f):
1104 print(msg, file=getattr(sys, self.orig_stream))
1105 self.assertIs(getattr(sys, self.orig_stream), orig_stdout)
1107 self.assertEqual(s, msg)
1109 def test_enter_result_is_target(self):
1111 with self.redirect_stream(f) as enter_result:
1112 self.assertIs(enter_result, f)
1114 def test_cm_is_reusable(self):
1116 write_to_f = self.redirect_stream(f)
1117 orig_stdout = getattr(sys, self.orig_stream)
1119 print("Hello", end=" ", file=getattr(sys, self.orig_stream))
1121 print("World!", file=getattr(sys, self.orig_stream))
1122 self.assertIs(getattr(sys, self.orig_stream), orig_stdout)
1124 self.assertEqual(s, "Hello World!\n")
1126 def test_cm_is_reentrant(self):
1128 write_to_f = self.redirect_stream(f)
1129 orig_stdout = getattr(sys, self.orig_stream)
1131 print("Hello", end=" ", file=getattr(sys, self.orig_stream))
1133 print("World!", file=getattr(sys, self.orig_stream))
1134 self.assertIs(getattr(sys, self.orig_stream), orig_stdout)
1136 self.assertEqual(s, "Hello World!\n")
1154 def test_instance_docs(self):
1158 self.assertEqual(obj.__doc__, cm_docstring)
1160 def test_no_result_from_enter(self):
1162 self.assertIsNone(enter_result)
1164 def test_no_exception(self):
1166 self.assertEqual(pow(2, 5), 32)
1168 def test_exact_exception(self):
1172 def test_exception_hierarchy(self):
1176 def test_other_exception(self):
1177 with self.assertRaises(ZeroDivisionError):
1181 def test_no_args(self):
1182 with self.assertRaises(ZeroDivisionError):
1186 def test_multiple_exception_args(self):
1192 def test_cm_is_reentrant(self):
1203 self.assertTrue(outer_continued)
1207 def make_relative_path(self, *parts):
1213 def test_simple(self):
1215 target = self.make_relative_path('data')
1216 self.assertNotEqual(old_cwd, target)
1219 self.assertEqual(os.getcwd(), target)
1220 self.assertEqual(os.getcwd(), old_cwd)
1222 def test_reentrant(self):
1224 target1 = self.make_relative_path('data')
1225 target2 = self.make_relative_path('ziptestdata')
1226 self.assertNotIn(old_cwd, (target1, target2))
1230 self.assertEqual(os.getcwd(), target1)
1232 self.assertEqual(os.getcwd(), target2)
1234 self.assertEqual(os.getcwd(), target1)
1235 self.assertEqual(os.getcwd(), target2)
1236 self.assertEqual(os.getcwd(), target1)
1237 self.assertEqual(os.getcwd(), old_cwd)
1239 def test_exception(self):
1241 target = self.make_relative_path('data')
1242 self.assertNotEqual(old_cwd, target)
1246 self.assertEqual(os.getcwd(), target)
1249 self.assertEqual(str(re), "boom")
1250 self.assertEqual(os.getcwd(), old_cwd)