Lines Matching refs:self
42 def cancel(self):
43 if self.done():
45 self.__cancelled = True
48 def cancelled(self):
49 return self.__cancelled
51 def done(self):
52 return (self.__cancelled
53 or self.__result is not None
54 or self.__exception is not None)
56 def result(self):
57 self.assertFalse(self.cancelled())
58 if self.__exception is not None:
59 raise self.__exception
60 return self.__result
62 def exception(self):
63 self.assertFalse(self.cancelled())
64 return self.__exception
66 def set_result(self, result):
67 self.assertFalse(self.done())
68 self.assertIsNotNone(result)
69 self.__result = result
71 def set_exception(self, exception):
72 self.assertFalse(self.done())
73 self.assertIsNotNone(exception)
74 self.__exception = exception
76 def __iter__(self):
77 if not self.done():
78 self._asyncio_future_blocking = True
79 yield self
80 self.assertTrue(self.done())
81 return self.result()
86 def setUp(self):
88 self.loop = self.new_test_loop()
89 self.addCleanup(self.loop.close)
91 def test_wrap_future(self):
94 self.assertIs(g, f)
96 def test_ensure_future(self):
99 self.assertIs(g, f)
104 def _new_future(self, *args, **kwargs):
105 return self.cls(*args, **kwargs)
107 def setUp(self):
109 self.loop = self.new_test_loop()
110 self.addCleanup(self.loop.close)
112 def test_generic_alias(self):
113 future = self.cls[str]
114 self.assertEqual(future.__args__, (str,))
115 self.assertIsInstance(future, GenericAlias)
117 def test_isfuture(self):
121 def __init__(self):
122 self._asyncio_future_blocking = False
124 self.assertFalse(asyncio.isfuture(MyFuture))
125 self.assertTrue(asyncio.isfuture(MyFuture()))
126 self.assertFalse(asyncio.isfuture(1))
129 self.assertFalse(asyncio.isfuture(mock.Mock()))
131 f = self._new_future(loop=self.loop)
132 self.assertTrue(asyncio.isfuture(f))
133 self.assertFalse(asyncio.isfuture(type(f)))
136 self.assertTrue(asyncio.isfuture(mock.Mock(type(f))))
140 def test_initial_state(self):
141 f = self._new_future(loop=self.loop)
142 self.assertFalse(f.cancelled())
143 self.assertFalse(f.done())
145 self.assertTrue(f.cancelled())
147 def test_constructor_without_loop(self):
148 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
149 self._new_future()
151 def test_constructor_use_running_loop(self):
153 return self._new_future()
154 f = self.loop.run_until_complete(test())
155 self.assertIs(f._loop, self.loop)
156 self.assertIs(f.get_loop(), self.loop)
158 def test_constructor_use_global_loop(self):
160 asyncio.set_event_loop(self.loop)
161 self.addCleanup(asyncio.set_event_loop, None)
162 f = self._new_future()
163 self.assertIs(f._loop, self.loop)
164 self.assertIs(f.get_loop(), self.loop)
166 def test_constructor_positional(self):
168 self.assertRaises(TypeError, self._new_future, 42)
170 def test_uninitialized(self):
174 fut = self.cls.__new__(self.cls, loop=self.loop)
175 self.assertRaises(asyncio.InvalidStateError, fut.result)
177 fut = self.cls.__new__(self.cls, loop=self.loop)
178 self.assertRaises(asyncio.InvalidStateError, fut.exception)
180 fut = self.cls.__new__(self.cls, loop=self.loop)
181 with self.assertRaises((RuntimeError, AttributeError)):
184 fut = self.cls.__new__(self.cls, loop=self.loop)
185 with self.assertRaises((RuntimeError, AttributeError)):
188 fut = self.cls.__new__(self.cls, loop=self.loop)
189 with self.assertRaises((RuntimeError, AttributeError)):
192 fut = self.cls.__new__(self.cls, loop=self.loop)
193 with self.assertRaises((RuntimeError, AttributeError)):
196 fut = self.cls.__new__(self.cls, loop=self.loop)
197 with self.assertRaises((RuntimeError, AttributeError)):
200 fut = self.cls.__new__(self.cls, loop=self.loop)
206 fut = self.cls.__new__(self.cls, loop=self.loop)
212 fut = self.cls.__new__(self.cls, loop=self.loop)
218 fut = self.cls.__new__(self.cls, loop=self.loop)
219 self.assertFalse(fut.cancelled())
220 self.assertFalse(fut.done())
222 def test_future_cancel_message_getter(self):
223 f = self._new_future(loop=self.loop)
224 self.assertTrue(hasattr(f, '_cancel_message'))
225 self.assertEqual(f._cancel_message, None)
228 with self.assertRaises(asyncio.CancelledError):
229 self.loop.run_until_complete(f)
230 self.assertEqual(f._cancel_message, 'my message')
232 def test_future_cancel_message_setter(self):
233 f = self._new_future(loop=self.loop)
236 self.assertEqual(f._cancel_message, 'my new message')
239 with self.assertRaises(asyncio.CancelledError):
240 self.loop.run_until_complete(f)
241 self.assertEqual(f._cancel_message, 'my new message')
243 def test_cancel(self):
244 f = self._new_future(loop=self.loop)
245 self.assertTrue(f.cancel())
246 self.assertTrue(f.cancelled())
247 self.assertTrue(f.done())
248 self.assertRaises(asyncio.CancelledError, f.result)
249 self.assertRaises(asyncio.CancelledError, f.exception)
250 self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
251 self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
252 self.assertFalse(f.cancel())
254 def test_result(self):
255 f = self._new_future(loop=self.loop)
256 self.assertRaises(asyncio.InvalidStateError, f.result)
259 self.assertFalse(f.cancelled())
260 self.assertTrue(f.done())
261 self.assertEqual(f.result(), 42)
262 self.assertEqual(f.exception(), None)
263 self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
264 self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
265 self.assertFalse(f.cancel())
267 def test_exception(self):
269 f = self._new_future(loop=self.loop)
270 self.assertRaises(asyncio.InvalidStateError, f.exception)
273 self.assertRaisesRegex(TypeError, "StopIteration .* cannot be raised",
277 self.assertFalse(f.cancelled())
278 self.assertTrue(f.done())
279 self.assertRaises(RuntimeError, f.result)
280 self.assertEqual(f.exception(), exc)
281 self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
282 self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
283 self.assertFalse(f.cancel())
285 def test_exception_class(self):
286 f = self._new_future(loop=self.loop)
288 self.assertIsInstance(f.exception(), RuntimeError)
290 def test_yield_from_twice(self):
291 f = self._new_future(loop=self.loop)
301 self.assertEqual(next(g), 'A') # yield 'A'.
302 self.assertEqual(next(g), f) # First yield from f.
304 self.assertEqual(next(g), ('B', 42)) # yield 'B', x.
306 self.assertEqual(next(g), ('C', 42)) # yield 'C', y.
308 def test_future_repr(self):
309 self.loop.set_debug(True)
310 f_pending_debug = self._new_future(loop=self.loop)
312 self.assertEqual(
314 f'<{self.cls.__name__} pending created at {frame[0]}:{frame[1]}>')
317 self.loop.set_debug(False)
318 f_pending = self._new_future(loop=self.loop)
319 self.assertEqual(repr(f_pending), f'<{self.cls.__name__} pending>')
322 f_cancelled = self._new_future(loop=self.loop)
324 self.assertEqual(repr(f_cancelled), f'<{self.cls.__name__} cancelled>')
326 f_result = self._new_future(loop=self.loop)
328 self.assertEqual(
329 repr(f_result), f'<{self.cls.__name__} finished result=4>')
330 self.assertEqual(f_result.result(), 4)
333 f_exception = self._new_future(loop=self.loop)
335 self.assertEqual(
337 f'<{self.cls.__name__} finished exception=RuntimeError()>')
338 self.assertIs(f_exception.exception(), exc)
345 f_one_callbacks = self._new_future(loop=self.loop)
348 self.assertRegex(
350 r'<' + self.cls.__name__ + r' pending cb=\[%s\]>' % fake_repr)
352 self.assertEqual(repr(f_one_callbacks),
353 f'<{self.cls.__name__} cancelled>')
355 f_two_callbacks = self._new_future(loop=self.loop)
360 self.assertRegex(repr(f_two_callbacks),
361 r'<' + self.cls.__name__ + r' pending cb=\[%s, %s\]>'
364 f_many_callbacks = self._new_future(loop=self.loop)
370 self.assertRegex(
372 r'<' + self.cls.__name__ + r' pending cb=\[%s\]>' % cb_regex)
374 self.assertEqual(repr(f_many_callbacks),
375 f'<{self.cls.__name__} cancelled>')
377 def test_copy_state(self):
380 f = self._new_future(loop=self.loop)
383 newf = self._new_future(loop=self.loop)
385 self.assertTrue(newf.done())
386 self.assertEqual(newf.result(), 10)
388 f_exception = self._new_future(loop=self.loop)
391 newf_exception = self._new_future(loop=self.loop)
393 self.assertTrue(newf_exception.done())
394 self.assertRaises(RuntimeError, newf_exception.result)
396 f_cancelled = self._new_future(loop=self.loop)
399 newf_cancelled = self._new_future(loop=self.loop)
401 self.assertTrue(newf_cancelled.cancelled())
403 def test_iter(self):
404 fut = self._new_future(loop=self.loop)
412 with self.assertRaisesRegex(RuntimeError, "await wasn't used"):
416 def test_log_traceback(self):
417 fut = self._new_future(loop=self.loop)
418 with self.assertRaisesRegex(ValueError, 'can only be set to False'):
422 def test_tb_logger_abandoned(self, m_log):
423 fut = self._new_future(loop=self.loop)
425 self.assertFalse(m_log.error.called)
428 def test_tb_logger_not_called_after_cancel(self, m_log):
429 fut = self._new_future(loop=self.loop)
433 self.assertFalse(m_log.error.called)
436 def test_tb_logger_result_unretrieved(self, m_log):
437 fut = self._new_future(loop=self.loop)
440 self.assertFalse(m_log.error.called)
443 def test_tb_logger_result_retrieved(self, m_log):
444 fut = self._new_future(loop=self.loop)
448 self.assertFalse(m_log.error.called)
451 def test_tb_logger_exception_unretrieved(self, m_log):
452 fut = self._new_future(loop=self.loop)
455 test_utils.run_briefly(self.loop)
457 self.assertTrue(m_log.error.called)
460 def test_tb_logger_exception_retrieved(self, m_log):
461 fut = self._new_future(loop=self.loop)
465 self.assertFalse(m_log.error.called)
468 def test_tb_logger_exception_result_retrieved(self, m_log):
469 fut = self._new_future(loop=self.loop)
471 self.assertRaises(RuntimeError, fut.result)
473 self.assertFalse(m_log.error.called)
475 def test_wrap_future(self):
481 f2 = asyncio.wrap_future(f1, loop=self.loop)
482 res, ident = self.loop.run_until_complete(f2)
483 self.assertTrue(asyncio.isfuture(f2))
484 self.assertEqual(res, 'oi')
485 self.assertNotEqual(ident, threading.get_ident())
488 def test_wrap_future_future(self):
489 f1 = self._new_future(loop=self.loop)
491 self.assertIs(f1, f2)
493 def test_wrap_future_without_loop(self):
498 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
502 def test_wrap_future_use_running_loop(self):
509 f2 = self.loop.run_until_complete(test())
510 self.assertIs(self.loop, f2._loop)
513 def test_wrap_future_use_global_loop(self):
515 asyncio.set_event_loop(self.loop)
516 self.addCleanup(asyncio.set_event_loop, None)
522 self.assertIs(self.loop, f2._loop)
525 def test_wrap_future_cancel(self):
527 f2 = asyncio.wrap_future(f1, loop=self.loop)
529 test_utils.run_briefly(self.loop)
530 self.assertTrue(f1.cancelled())
531 self.assertTrue(f2.cancelled())
533 def test_wrap_future_cancel2(self):
535 f2 = asyncio.wrap_future(f1, loop=self.loop)
538 test_utils.run_briefly(self.loop)
539 self.assertFalse(f1.cancelled())
540 self.assertEqual(f1.result(), 42)
541 self.assertTrue(f2.cancelled())
543 def test_future_source_traceback(self):
544 self.loop.set_debug(True)
546 future = self._new_future(loop=self.loop)
548 self.assertIsInstance(future._source_traceback, list)
549 self.assertEqual(future._source_traceback[-2][:3],
555 def check_future_exception_never_retrieved(self, debug, m_log):
556 self.loop.set_debug(debug)
565 future = self._new_future(loop=self.loop)
568 test_utils.run_briefly(self.loop)
571 regex = f'^{self.cls.__name__} exception was never retrieved\n'
576 self.assertRegex(message, re.compile(regex, re.DOTALL))
578 def test_future_exception_never_retrieved(self):
579 self.check_future_exception_never_retrieved(False)
581 def test_future_exception_never_retrieved_debug(self):
582 self.check_future_exception_never_retrieved(True)
584 def test_set_result_unless_cancelled(self):
585 fut = self._new_future(loop=self.loop)
588 self.assertTrue(fut.cancelled())
590 def test_future_stop_iteration_args(self):
591 fut = self._new_future(loop=self.loop)
600 self.fail('StopIteration was expected')
601 self.assertEqual(result, (1, 2))
603 def test_future_iter_throw(self):
604 fut = self._new_future(loop=self.loop)
606 self.assertRaises(TypeError, fi.throw,
608 self.assertRaises(TypeError, fi.throw,
611 self.assertRaises(ValueError, fi.throw, ValueError, None, None)
612 self.assertRaises(TypeError, fi.throw, list)
614 def test_future_del_collect(self):
616 def __del__(self):
620 fut = self._new_future(loop=self.loop)
632 def test_future_del_segfault(self):
633 fut = self._new_future(loop=self.loop)
634 with self.assertRaises(AttributeError):
636 with self.assertRaises(AttributeError):
658 def setUp(self):
660 self.loop = self.new_test_loop()
662 def run_briefly(self):
663 test_utils.run_briefly(self.loop)
665 def _make_callback(self, bag, thing):
671 def _new_future(self):
674 def test_callbacks_remove_first_callback(self):
676 f = self._new_future()
678 cb1 = self._make_callback(bag, 42)
679 cb2 = self._make_callback(bag, 17)
680 cb3 = self._make_callback(bag, 100)
689 self.assertEqual(bag, [])
692 self.run_briefly()
694 self.assertEqual(bag, [17, 100])
695 self.assertEqual(f.result(), 'foo')
697 def test_callbacks_remove_first_and_second_callback(self):
699 f = self._new_future()
701 cb1 = self._make_callback(bag, 42)
702 cb2 = self._make_callback(bag, 17)
703 cb3 = self._make_callback(bag, 100)
713 self.assertEqual(bag, [])
716 self.run_briefly()
718 self.assertEqual(bag, [100])
719 self.assertEqual(f.result(), 'foo')
721 def test_callbacks_remove_third_callback(self):
723 f = self._new_future()
725 cb1 = self._make_callback(bag, 42)
726 cb2 = self._make_callback(bag, 17)
727 cb3 = self._make_callback(bag, 100)
736 self.assertEqual(bag, [])
739 self.run_briefly()
741 self.assertEqual(bag, [42, 17])
742 self.assertEqual(f.result(), 'foo')
744 def test_callbacks_invoked_on_set_result(self):
746 f = self._new_future()
747 f.add_done_callback(self._make_callback(bag, 42))
748 f.add_done_callback(self._make_callback(bag, 17))
750 self.assertEqual(bag, [])
753 self.run_briefly()
755 self.assertEqual(bag, [42, 17])
756 self.assertEqual(f.result(), 'foo')
758 def test_callbacks_invoked_on_set_exception(self):
760 f = self._new_future()
761 f.add_done_callback(self._make_callback(bag, 100))
763 self.assertEqual(bag, [])
767 self.run_briefly()
769 self.assertEqual(bag, [100])
770 self.assertEqual(f.exception(), exc)
772 def test_remove_done_callback(self):
774 f = self._new_future()
775 cb1 = self._make_callback(bag, 1)
776 cb2 = self._make_callback(bag, 2)
777 cb3 = self._make_callback(bag, 3)
784 self.assertEqual(f.remove_done_callback(cb2), 1)
787 self.assertEqual(f.remove_done_callback(cb3), 0)
795 self.assertEqual(f.remove_done_callback(cb1), 6)
797 self.assertEqual(bag, [])
800 self.run_briefly()
802 self.assertEqual(bag, [2])
803 self.assertEqual(f.result(), 'foo')
805 def test_remove_done_callbacks_list_mutation(self):
808 fut = self._new_future()
815 def __eq__(self, other):
821 def test_remove_done_callbacks_list_clear(self):
824 fut = self._new_future()
831 def __eq__(self, other):
836 def test_schedule_callbacks_list_mutation_1(self):
842 fut = self._new_future()
847 test_utils.run_briefly(self.loop)
849 def test_schedule_callbacks_list_mutation_2(self):
852 fut = self._new_future()
862 def __eq__(self, other):
877 def _new_future(self):
878 return futures._CFuture(loop=self.loop)
886 def _new_future(self):
889 return CSubFuture(loop=self.loop)
895 def _new_future(self):
896 return futures._PyFuture(loop=self.loop)
901 def _get_future_cls(self):
904 def setUp(self):
906 self.loop = self.new_test_loop()
907 self.addCleanup(self.loop.close)
909 def test_inherit_without_calling_super_init(self):
911 cls = self._get_future_cls()
914 def __init__(self, *args, **kwargs):
918 fut = MyFut(loop=self.loop)
919 with self.assertRaisesRegex(
928 def _get_future_cls(self):
936 def _get_future_cls(self):