Lines Matching refs:self
66 def __repr__(self):
69 def __call__(self, *args):
74 def send(self, v):
77 def throw(self, *exc):
80 def close(self):
83 def __await__(self):
84 return self
92 def new_task(self, loop, coro, name='TestTask', context=None):
93 return self.__class__.Task(coro, loop=loop, name=name, context=context)
95 def new_future(self, loop):
96 return self.__class__.Future(loop=loop)
98 def setUp(self):
100 self.loop = self.new_test_loop()
101 self.loop.set_task_factory(self.new_task)
102 self.loop.create_future = lambda: self.new_future(self.loop)
104 def test_generic_alias(self):
105 task = self.__class__.Task[str]
106 self.assertEqual(task.__args__, (str,))
107 self.assertIsInstance(task, GenericAlias)
109 def test_task_cancel_message_getter(self):
112 t = self.new_task(self.loop, coro())
113 self.assertTrue(hasattr(t, '_cancel_message'))
114 self.assertEqual(t._cancel_message, None)
117 self.assertEqual(t._cancel_message, 'my message')
119 with self.assertRaises(asyncio.CancelledError) as cm:
120 self.loop.run_until_complete(t)
122 self.assertEqual('my message', cm.exception.args[0])
124 def test_task_cancel_message_setter(self):
127 t = self.new_task(self.loop, coro())
130 self.assertEqual(t._cancel_message, 'my new message')
132 with self.assertRaises(asyncio.CancelledError) as cm:
133 self.loop.run_until_complete(t)
135 self.assertEqual('my new message', cm.exception.args[0])
137 def test_task_del_collect(self):
139 def __del__(self):
145 self.loop.run_until_complete(
147 self.new_task(self.loop, run()) for _ in range(100)
150 def test_other_loop_future(self):
152 fut = self.new_future(other_loop)
158 with self.assertRaisesRegex(RuntimeError,
160 self.loop.run_until_complete(run(fut))
164 def test_task_awaits_on_itself(self):
169 task = asyncio.ensure_future(test(), loop=self.loop)
171 with self.assertRaisesRegex(RuntimeError,
173 self.loop.run_until_complete(task)
175 def test_task_class(self):
178 t = self.new_task(self.loop, notmuch())
179 self.loop.run_until_complete(t)
180 self.assertTrue(t.done())
181 self.assertEqual(t.result(), 'ok')
182 self.assertIs(t._loop, self.loop)
183 self.assertIs(t.get_loop(), self.loop)
186 self.set_event_loop(loop)
187 t = self.new_task(loop, notmuch())
188 self.assertIs(t._loop, loop)
192 def test_ensure_future_coroutine(self):
195 t = asyncio.ensure_future(notmuch(), loop=self.loop)
196 self.assertIs(t._loop, self.loop)
197 self.loop.run_until_complete(t)
198 self.assertTrue(t.done())
199 self.assertEqual(t.result(), 'ok')
202 self.addCleanup(a.close)
203 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
208 t = self.loop.run_until_complete(test())
209 self.assertIs(t._loop, self.loop)
210 self.loop.run_until_complete(t)
211 self.assertTrue(t.done())
212 self.assertEqual(t.result(), 'ok')
215 asyncio.set_event_loop(self.loop)
216 self.addCleanup(asyncio.set_event_loop, None)
218 self.assertIs(t._loop, self.loop)
219 self.loop.run_until_complete(t)
220 self.assertTrue(t.done())
221 self.assertEqual(t.result(), 'ok')
223 def test_ensure_future_future(self):
224 f_orig = self.new_future(self.loop)
228 self.loop.run_until_complete(f)
229 self.assertTrue(f.done())
230 self.assertEqual(f.result(), 'ko')
231 self.assertIs(f, f_orig)
234 self.set_event_loop(loop)
236 with self.assertRaises(ValueError):
241 f = asyncio.ensure_future(f_orig, loop=self.loop)
242 self.assertIs(f, f_orig)
244 def test_ensure_future_task(self):
247 t_orig = self.new_task(self.loop, notmuch())
249 self.loop.run_until_complete(t)
250 self.assertTrue(t.done())
251 self.assertEqual(t.result(), 'ok')
252 self.assertIs(t, t_orig)
255 self.set_event_loop(loop)
257 with self.assertRaises(ValueError):
262 t = asyncio.ensure_future(t_orig, loop=self.loop)
263 self.assertIs(t, t_orig)
265 def test_ensure_future_awaitable(self):
267 def __init__(self, coro):
268 self.coro = coro
269 def __await__(self):
270 return self.coro.__await__()
276 self.set_event_loop(loop)
279 self.assertEqual(fut.result(), 'ok')
281 def test_ensure_future_neither(self):
282 with self.assertRaises(TypeError):
285 def test_ensure_future_error_msg(self):
287 f = self.new_future(self.loop)
288 with self.assertRaisesRegex(ValueError, 'The future belongs to a '
294 def test_get_stack(self):
304 self.assertEqual(f[0].f_code.co_name, 'foo')
313 self.assertRegex(tb, r'foo\(\) running')
317 T = asyncio.ensure_future(foo(), loop=self.loop)
320 self.loop.run_until_complete(runner())
322 def test_task_repr(self):
323 self.loop.set_debug(False)
329 self.assertEqual(notmuch.__name__, 'notmuch')
330 self.assertRegex(notmuch.__qualname__,
332 self.assertEqual(notmuch.__module__, __name__)
340 self.assertEqual(gen.__name__, 'notmuch')
341 self.assertEqual(gen.__qualname__, coro_qualname)
344 t = self.new_task(self.loop, gen)
349 self.assertEqual(repr(t),
354 self.assertEqual(repr(t),
358 self.assertRaises(asyncio.CancelledError,
359 self.loop.run_until_complete, t)
362 self.assertEqual(repr(t),
366 t = self.new_task(self.loop, notmuch())
367 self.loop.run_until_complete(t)
370 self.assertEqual(repr(t),
373 def test_task_repr_autogenerated(self):
377 t1 = self.new_task(self.loop, notmuch(), None)
378 t2 = self.new_task(self.loop, notmuch(), None)
379 self.assertNotEqual(repr(t1), repr(t2))
382 self.assertIsNotNone(match1)
384 self.assertIsNotNone(match2)
387 self.assertLess(int(match1.group(1)), int(match2.group(1)))
388 self.loop.run_until_complete(t1)
389 self.loop.run_until_complete(t2)
391 def test_task_repr_name_not_str(self):
395 t = self.new_task(self.loop, notmuch())
397 self.assertEqual(t.get_name(), '{6}')
398 self.loop.run_until_complete(t)
400 def test_task_repr_wait_for(self):
401 self.loop.set_debug(False)
406 fut = self.new_future(self.loop)
407 task = self.new_task(self.loop, wait_for(fut))
408 test_utils.run_briefly(self.loop)
409 self.assertRegex(repr(task),
413 self.loop.run_until_complete(task)
415 def test_task_basics(self):
429 self.assertEqual(self.loop.run_until_complete(t), 1042)
431 def test_exception_chaining_after_await(self):
436 self.set_event_loop(loop)
445 task = self.new_task(loop, raise_error())
449 self.assertEqual(type(exc), ValueError)
451 self.assertEqual((type(chained), chained.args),
455 task = self.new_task(loop, run())
460 def test_exception_chaining_after_await_with_context_cycle(self):
465 self.set_event_loop(loop)
475 task = self.new_task(loop, process_exc(exc))
484 task = self.new_task(loop, run())
489 self.assertEqual(has_cycle, False)
492 def test_cancelling(self):
499 t = self.new_task(loop, task())
500 self.assertFalse(t.cancelling())
501 self.assertNotIn(" cancelling ", repr(t))
502 self.assertTrue(t.cancel())
503 self.assertTrue(t.cancelling())
504 self.assertIn(" cancelling ", repr(t))
508 # self.assertFalse(t.cancel())
509 self.assertTrue(t.cancel())
511 with self.assertRaises(asyncio.CancelledError):
516 def test_uncancel_basic(self):
527 t = self.new_task(loop, task())
531 self.assertTrue(t.cancel())
532 self.assertIn(" cancelling ", repr(t))
533 self.assertEqual(t.cancelling(), 1)
534 self.assertFalse(t.cancelled()) # Task is still not complete
538 self.assertNotIn(" cancelling ", repr(t))
539 self.assertEqual(t.cancelling(), 0)
540 self.assertFalse(t.cancelled()) # Task is still not complete
543 self.assertTrue(t.cancel())
544 self.assertEqual(t.cancelling(), 1)
545 self.assertFalse(t.cancelled()) # Task is still not complete
546 with self.assertRaises(asyncio.CancelledError):
548 self.assertTrue(t.cancelled()) # Finally, task complete
549 self.assertTrue(t.done())
553 self.assertTrue(t.cancelled())
554 self.assertTrue(t.done())
558 def test_uncancel_structured_blocks(self):
631 self.assertTrue(timed_out)
640 t1 = self.new_task(loop, make_request_with_timeout(sleep=10.0, timeout=0.1))
644 self.assertTrue(timed_out)
645 self.assertFalse(structured_block_finished) # it was cancelled
646 self.assertTrue(outer_code_reached) # task got uncancelled after leaving
649 self.assertEqual(t1.cancelling(), 0) # no pending cancellation of the outer task
652 t2 = self.new_task(loop, make_request_with_timeout(sleep=0, timeout=10.0))
656 self.assertFalse(timed_out)
657 self.assertTrue(structured_block_finished)
658 self.assertTrue(outer_code_reached)
659 self.assertEqual(t2.cancelling(), 0)
663 def test_cancel(self):
667 self.assertAlmostEqual(10.0, when)
670 loop = self.new_test_loop(gen)
676 t = self.new_task(loop, task())
678 with self.assertRaises(asyncio.CancelledError):
680 self.assertTrue(t.done())
681 self.assertTrue(t.cancelled())
682 self.assertFalse(t.cancel())
684 def test_cancel_with_message_then_future_result(self):
694 with self.subTest(cancel_args=cancel_args):
696 self.set_event_loop(loop)
702 task = self.new_task(loop, sleep())
708 task = self.new_task(loop, coro())
709 with self.assertRaises(asyncio.CancelledError) as cm:
712 self.assertEqual(exc.args, expected_args)
715 self.assertEqual(actual,
718 def test_cancel_with_message_then_future_exception(self):
728 with self.subTest(cancel_args=cancel_args):
730 self.set_event_loop(loop)
736 task = self.new_task(loop, sleep())
742 task = self.new_task(loop, coro())
743 with self.assertRaises(asyncio.CancelledError) as cm:
746 self.assertEqual(exc.args, expected_args)
749 self.assertEqual(actual,
752 def test_cancellation_exception_context(self):
754 self.set_event_loop(loop)
762 inner_task = self.new_task(loop, sleep())
770 task = self.new_task(loop, coro())
771 with self.assertRaises(ValueError) as cm:
774 self.assertEqual(exc.args, ('cancelled',))
777 self.assertEqual(actual,
780 def test_cancel_with_message_before_starting_task(self):
782 self.set_event_loop(loop)
788 task = self.new_task(loop, sleep())
794 task = self.new_task(loop, coro())
795 with self.assertRaises(asyncio.CancelledError) as cm:
798 self.assertEqual(exc.args, ('my message',))
801 self.assertEqual(actual,
804 def test_cancel_yield(self):
810 t = self.new_task(self.loop, task())
811 test_utils.run_briefly(self.loop) # start coro
813 self.assertRaises(
814 asyncio.CancelledError, self.loop.run_until_complete, t)
815 self.assertTrue(t.done())
816 self.assertTrue(t.cancelled())
817 self.assertFalse(t.cancel())
819 def test_cancel_inner_future(self):
820 f = self.new_future(self.loop)
826 t = self.new_task(self.loop, task())
827 test_utils.run_briefly(self.loop) # start task
829 with self.assertRaises(asyncio.CancelledError):
830 self.loop.run_until_complete(t)
831 self.assertTrue(f.cancelled())
832 self.assertTrue(t.cancelled())
834 def test_cancel_both_task_and_inner_future(self):
835 f = self.new_future(self.loop)
841 t = self.new_task(self.loop, task())
842 test_utils.run_briefly(self.loop)
847 with self.assertRaises(asyncio.CancelledError):
848 self.loop.run_until_complete(t)
850 self.assertTrue(t.done())
851 self.assertTrue(f.cancelled())
852 self.assertTrue(t.cancelled())
854 def test_cancel_task_catching(self):
855 fut1 = self.new_future(self.loop)
856 fut2 = self.new_future(self.loop)
865 t = self.new_task(self.loop, task())
866 test_utils.run_briefly(self.loop)
867 self.assertIs(t._fut_waiter, fut1) # White-box test.
869 test_utils.run_briefly(self.loop)
870 self.assertIs(t._fut_waiter, fut2) # White-box test.
872 self.assertTrue(fut2.cancelled())
873 res = self.loop.run_until_complete(t)
874 self.assertEqual(res, 42)
875 self.assertFalse(t.cancelled())
877 def test_cancel_task_ignoring(self):
878 fut1 = self.new_future(self.loop)
879 fut2 = self.new_future(self.loop)
880 fut3 = self.new_future(self.loop)
891 t = self.new_task(self.loop, task())
892 test_utils.run_briefly(self.loop)
893 self.assertIs(t._fut_waiter, fut1) # White-box test.
895 test_utils.run_briefly(self.loop)
896 self.assertIs(t._fut_waiter, fut2) # White-box test.
898 self.assertTrue(fut2.cancelled())
899 test_utils.run_briefly(self.loop)
900 self.assertIs(t._fut_waiter, fut3) # White-box test.
902 res = self.loop.run_until_complete(t)
903 self.assertEqual(res, 42)
904 self.assertFalse(fut3.cancelled())
905 self.assertFalse(t.cancelled())
907 def test_cancel_current_task(self):
909 self.set_event_loop(loop)
913 self.assertTrue(t._must_cancel) # White-box test.
918 t = self.new_task(loop, task())
919 self.assertFalse(t.cancelled())
920 self.assertRaises(
922 self.assertTrue(t.done())
923 self.assertTrue(t.cancelled())
924 self.assertFalse(t._must_cancel) # White-box test.
925 self.assertFalse(t.cancel())
927 def test_cancel_at_end(self):
930 self.set_event_loop(loop)
934 self.assertTrue(t._must_cancel) # White-box test.
937 t = self.new_task(loop, task())
938 self.assertFalse(t.cancelled())
939 self.assertRaises(
941 self.assertTrue(t.done())
942 self.assertTrue(t.cancelled())
943 self.assertFalse(t._must_cancel) # White-box test.
944 self.assertFalse(t.cancel())
946 def test_cancel_awaited_task(self):
954 self.addCleanup(lambda: loop.close())
957 fut = self.new_future(loop)
965 nested_task = self.new_task(loop, nested())
974 task = self.new_task(loop, coro())
975 with self.assertRaises(asyncio.CancelledError):
978 self.assertTrue(task.cancelled())
979 self.assertTrue(nested_task.cancelled())
980 self.assertTrue(fut.cancelled())
982 def assert_text_contains(self, text, substr):
986 def test_cancel_traceback_for_future_result(self):
990 self.set_event_loop(loop)
997 task = self.new_task(loop, nested())
1002 task = self.new_task(loop, coro())
1007 self.assert_text_contains(tb, "await asyncio.sleep(10)")
1009 self.assert_text_contains(tb, "await task # search target")
1011 self.fail('CancelledError did not occur')
1013 def test_cancel_traceback_for_future_exception(self):
1017 self.set_event_loop(loop)
1024 task = self.new_task(loop, nested())
1030 task = self.new_task(loop, coro())
1035 self.assert_text_contains(tb, "await asyncio.sleep(10)")
1037 self.assert_text_contains(tb,
1040 self.fail('CancelledError did not occur')
1042 def test_stop_while_run_in_complete(self):
1046 self.assertAlmostEqual(0.1, when)
1048 self.assertAlmostEqual(0.2, when)
1050 self.assertAlmostEqual(0.3, when)
1053 loop = self.new_test_loop(gen)
1065 t = self.new_task(loop, task())
1066 with self.assertRaises(RuntimeError) as cm:
1068 self.assertEqual(str(cm.exception),
1070 self.assertFalse(t.done())
1071 self.assertEqual(x, 2)
1072 self.assertAlmostEqual(0.3, loop.time())
1075 self.assertRaises(asyncio.CancelledError, loop.run_until_complete, t)
1077 def test_log_traceback(self):
1081 task = self.new_task(self.loop, coro())
1082 with self.assertRaisesRegex(ValueError, 'can only be set to False'):
1084 self.loop.run_until_complete(task)
1086 def test_wait(self):
1090 self.assertAlmostEqual(0.1, when)
1092 self.assertAlmostEqual(0.15, when)
1095 loop = self.new_test_loop(gen)
1097 a = self.new_task(loop, asyncio.sleep(0.1))
1098 b = self.new_task(loop, asyncio.sleep(0.15))
1102 self.assertEqual(done, set([a, b]))
1103 self.assertEqual(pending, set())
1106 res = loop.run_until_complete(self.new_task(loop, foo()))
1107 self.assertEqual(res, 42)
1108 self.assertAlmostEqual(0.15, loop.time())
1111 res = loop.run_until_complete(self.new_task(loop, foo()))
1112 self.assertAlmostEqual(0.15, loop.time())
1113 self.assertEqual(res, 42)
1115 def test_wait_duplicate_coroutines(self):
1119 c = self.loop.create_task(coro('test'))
1120 task = self.new_task(
1121 self.loop,
1122 asyncio.wait([c, c, self.loop.create_task(coro('spam'))]))
1124 done, pending = self.loop.run_until_complete(task)
1126 self.assertFalse(pending)
1127 self.assertEqual(set(f.result() for f in done), {'test', 'spam'})
1129 def test_wait_errors(self):
1130 self.assertRaises(
1131 ValueError, self.loop.run_until_complete,
1137 self.assertRaises(ValueError,
1138 self.loop.run_until_complete, wait_coro)
1142 def test_wait_first_completed(self):
1146 self.assertAlmostEqual(10.0, when)
1148 self.assertAlmostEqual(0.1, when)
1151 loop = self.new_test_loop(gen)
1153 a = self.new_task(loop, asyncio.sleep(10.0))
1154 b = self.new_task(loop, asyncio.sleep(0.1))
1155 task = self.new_task(
1160 self.assertEqual({b}, done)
1161 self.assertEqual({a}, pending)
1162 self.assertFalse(a.done())
1163 self.assertTrue(b.done())
1164 self.assertIsNone(b.result())
1165 self.assertAlmostEqual(0.1, loop.time())
1171 def test_wait_really_done(self):
1182 a = self.new_task(self.loop, coro1())
1183 b = self.new_task(self.loop, coro2())
1184 task = self.new_task(
1185 self.loop,
1188 done, pending = self.loop.run_until_complete(task)
1189 self.assertEqual({a, b}, done)
1190 self.assertTrue(a.done())
1191 self.assertIsNone(a.result())
1192 self.assertTrue(b.done())
1193 self.assertIsNone(b.result())
1195 def test_wait_first_exception(self):
1199 self.assertAlmostEqual(10.0, when)
1202 loop = self.new_test_loop(gen)
1205 a = self.new_task(loop, asyncio.sleep(10.0))
1210 b = self.new_task(loop, exc())
1211 task = self.new_task(
1216 self.assertEqual({b}, done)
1217 self.assertEqual({a}, pending)
1218 self.assertAlmostEqual(0, loop.time())
1224 def test_wait_first_exception_in_wait(self):
1228 self.assertAlmostEqual(10.0, when)
1230 self.assertAlmostEqual(0.01, when)
1233 loop = self.new_test_loop(gen)
1236 a = self.new_task(loop, asyncio.sleep(10.0))
1242 b = self.new_task(loop, exc())
1246 self.assertEqual({b}, done)
1247 self.assertEqual({a}, pending)
1248 self.assertAlmostEqual(0.01, loop.time())
1254 def test_wait_with_exception(self):
1258 self.assertAlmostEqual(0.1, when)
1260 self.assertAlmostEqual(0.15, when)
1263 loop = self.new_test_loop(gen)
1265 a = self.new_task(loop, asyncio.sleep(0.1))
1271 b = self.new_task(loop, sleeper())
1275 self.assertEqual(len(done), 2)
1276 self.assertEqual(pending, set())
1278 self.assertEqual(len(errors), 1)
1280 loop.run_until_complete(self.new_task(loop, foo()))
1281 self.assertAlmostEqual(0.15, loop.time())
1283 loop.run_until_complete(self.new_task(loop, foo()))
1284 self.assertAlmostEqual(0.15, loop.time())
1286 def test_wait_with_timeout(self):
1290 self.assertAlmostEqual(0.1, when)
1292 self.assertAlmostEqual(0.15, when)
1294 self.assertAlmostEqual(0.11, when)
1297 loop = self.new_test_loop(gen)
1299 a = self.new_task(loop, asyncio.sleep(0.1))
1300 b = self.new_task(loop, asyncio.sleep(0.15))
1304 self.assertEqual(done, set([a]))
1305 self.assertEqual(pending, set([b]))
1307 loop.run_until_complete(self.new_task(loop, foo()))
1308 self.assertAlmostEqual(0.11, loop.time())
1314 def test_wait_concurrent_complete(self):
1318 self.assertAlmostEqual(0.1, when)
1320 self.assertAlmostEqual(0.15, when)
1322 self.assertAlmostEqual(0.1, when)
1325 loop = self.new_test_loop(gen)
1327 a = self.new_task(loop, asyncio.sleep(0.1))
1328 b = self.new_task(loop, asyncio.sleep(0.15))
1333 self.assertEqual(done, set([a]))
1334 self.assertEqual(pending, set([b]))
1335 self.assertAlmostEqual(0.1, loop.time())
1341 def test_wait_with_iterator_of_tasks(self):
1345 self.assertAlmostEqual(0.1, when)
1347 self.assertAlmostEqual(0.15, when)
1350 loop = self.new_test_loop(gen)
1352 a = self.new_task(loop, asyncio.sleep(0.1))
1353 b = self.new_task(loop, asyncio.sleep(0.15))
1357 self.assertEqual(done, set([a, b]))
1358 self.assertEqual(pending, set())
1361 res = loop.run_until_complete(self.new_task(loop, foo()))
1362 self.assertEqual(res, 42)
1363 self.assertAlmostEqual(0.15, loop.time())
1365 def test_as_completed(self):
1373 loop = self.new_test_loop(gen)
1398 res = loop.run_until_complete(self.new_task(loop, foo()))
1399 self.assertAlmostEqual(0.15, loop.time())
1400 self.assertTrue('a' in res[:2])
1401 self.assertTrue('b' in res[:2])
1402 self.assertEqual(res[2], 'c')
1404 def test_as_completed_with_timeout(self):
1412 loop = self.new_test_loop(gen)
1429 res = loop.run_until_complete(self.new_task(loop, foo()))
1430 self.assertEqual(len(res), 2, res)
1431 self.assertEqual(res[0], (1, 'a'))
1432 self.assertEqual(res[1][0], 2)
1433 self.assertIsInstance(res[1][1], asyncio.TimeoutError)
1434 self.assertAlmostEqual(0.12, loop.time())
1440 def test_as_completed_with_unused_timeout(self):
1447 loop = self.new_test_loop(gen)
1454 self.assertEqual(v, 'a')
1456 loop.run_until_complete(self.new_task(loop, foo()))
1458 def test_as_completed_reverse_wait(self):
1465 loop = self.new_test_loop(gen)
1473 self.assertEqual(len(futs), 2)
1476 self.assertEqual(x, 'a')
1477 self.assertAlmostEqual(0.05, loop.time())
1480 self.assertEqual(y, 'b')
1481 self.assertAlmostEqual(0.10, loop.time())
1485 def test_as_completed_concurrent(self):
1489 self.assertAlmostEqual(0.05, when)
1491 self.assertAlmostEqual(0.05, when)
1500 self.assertEqual(len(futs), 2)
1504 self.assertEqual(set(f.result() for f in done), {'a', 'b'})
1506 loop = self.new_test_loop(gen)
1509 def test_as_completed_duplicate_coroutines(self):
1521 fut = self.new_task(self.loop, runner())
1522 self.loop.run_until_complete(fut)
1524 self.assertEqual(set(result), {'ham', 'spam'})
1525 self.assertEqual(len(result), 2)
1527 def test_as_completed_coroutine_without_loop(self):
1532 self.addCleanup(a.close)
1535 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
1538 def test_as_completed_coroutine_use_running_loop(self):
1539 loop = self.new_test_loop()
1546 self.assertEqual(len(futs), 1)
1547 self.assertEqual(await futs[0], 42)
1551 def test_sleep(self):
1555 self.assertAlmostEqual(0.05, when)
1557 self.assertAlmostEqual(0.1, when)
1560 loop = self.new_test_loop(gen)
1567 t = self.new_task(loop, sleeper(0.1, 'yeah'))
1569 self.assertTrue(t.done())
1570 self.assertEqual(t.result(), 'yeah')
1571 self.assertAlmostEqual(0.1, loop.time())
1573 def test_sleep_cancel(self):
1577 self.assertAlmostEqual(10.0, when)
1580 loop = self.new_test_loop(gen)
1582 t = self.new_task(loop, asyncio.sleep(10.0, 'yeah'))
1595 self.assertFalse(handle._cancelled)
1599 self.assertTrue(handle._cancelled)
1601 def test_task_cancel_sleeping_task(self):
1605 self.assertAlmostEqual(0.1, when)
1607 self.assertAlmostEqual(5000, when)
1610 loop = self.new_test_loop(gen)
1616 sleeper = self.new_task(loop, sleep(5000))
1626 self.assertEqual(loop.run_until_complete(doer), 'cancelled')
1627 self.assertAlmostEqual(0.1, loop.time())
1629 def test_task_cancel_waiter_future(self):
1630 fut = self.new_future(self.loop)
1635 task = self.new_task(self.loop, coro())
1636 test_utils.run_briefly(self.loop)
1637 self.assertIs(task._fut_waiter, fut)
1640 test_utils.run_briefly(self.loop)
1641 self.assertRaises(
1642 asyncio.CancelledError, self.loop.run_until_complete, task)
1643 self.assertIsNone(task._fut_waiter)
1644 self.assertTrue(fut.cancelled())
1646 def test_task_set_methods(self):
1651 task = self.new_task(self.loop, gen)
1653 with self.assertRaisesRegex(RuntimeError, 'not support set_result'):
1656 with self.assertRaisesRegex(RuntimeError, 'not support set_exception'):
1659 self.assertEqual(
1660 self.loop.run_until_complete(task),
1663 def test_step_result_future(self):
1667 def __init__(self, *args, **kwds):
1668 self.cb_added = False
1671 def add_done_callback(self, *args, **kwargs):
1672 self.cb_added = True
1675 fut = Fut(loop=self.loop)
1682 t = self.new_task(self.loop, wait_for_future())
1683 test_utils.run_briefly(self.loop)
1684 self.assertTrue(fut.cb_added)
1688 test_utils.run_briefly(self.loop)
1689 self.assertIs(res, result)
1690 self.assertTrue(t.done())
1691 self.assertIsNone(t.result())
1693 def test_baseexception_during_cancel(self):
1697 self.assertAlmostEqual(10.0, when)
1700 loop = self.new_test_loop(gen)
1713 task = self.new_task(loop, notmutch())
1717 self.assertFalse(task.done())
1719 self.assertRaises(SystemExit, test_utils.run_briefly, loop)
1721 self.assertTrue(task.done())
1722 self.assertFalse(task.cancelled())
1723 self.assertIs(task.exception(), base_exc)
1725 def test_iscoroutinefunction(self):
1729 self.assertFalse(asyncio.iscoroutinefunction(fn))
1733 self.assertFalse(asyncio.iscoroutinefunction(fn1))
1737 self.assertTrue(asyncio.iscoroutinefunction(fn2))
1739 self.assertFalse(asyncio.iscoroutinefunction(mock.Mock()))
1740 self.assertTrue(asyncio.iscoroutinefunction(mock.AsyncMock()))
1742 def test_coroutine_non_gen_function(self):
1746 self.assertTrue(asyncio.iscoroutinefunction(func))
1749 self.assertTrue(asyncio.iscoroutine(coro))
1751 res = self.loop.run_until_complete(coro)
1752 self.assertEqual(res, 'test')
1754 def test_coroutine_non_gen_function_return_future(self):
1755 fut = self.new_future(self.loop)
1763 t1 = self.new_task(self.loop, func())
1764 t2 = self.new_task(self.loop, coro())
1765 res = self.loop.run_until_complete(t1)
1766 self.assertEqual(res, fut)
1767 self.assertIsNone(t2.result())
1769 def test_current_task(self):
1770 self.assertIsNone(asyncio.current_task(loop=self.loop))
1773 self.assertIs(asyncio.current_task(), task)
1775 self.assertIs(asyncio.current_task(None), task)
1776 self.assertIs(asyncio.current_task(), task)
1778 task = self.new_task(self.loop, coro(self.loop))
1779 self.loop.run_until_complete(task)
1780 self.assertIsNone(asyncio.current_task(loop=self.loop))
1782 def test_current_task_with_interleaving_tasks(self):
1783 self.assertIsNone(asyncio.current_task(loop=self.loop))
1785 fut1 = self.new_future(self.loop)
1786 fut2 = self.new_future(self.loop)
1789 self.assertTrue(asyncio.current_task() is task1)
1791 self.assertTrue(asyncio.current_task() is task1)
1795 self.assertTrue(asyncio.current_task() is task2)
1798 self.assertTrue(asyncio.current_task() is task2)
1800 task1 = self.new_task(self.loop, coro1(self.loop))
1801 task2 = self.new_task(self.loop, coro2(self.loop))
1803 self.loop.run_until_complete(asyncio.wait((task1, task2)))
1804 self.assertIsNone(asyncio.current_task(loop=self.loop))
1809 def test_yield_future_passes_cancel(self):
1812 waiter = self.new_future(self.loop)
1822 self.fail('got past sleep() in inner()')
1833 f = asyncio.ensure_future(outer(), loop=self.loop)
1834 test_utils.run_briefly(self.loop)
1836 self.loop.run_until_complete(f)
1837 self.assertEqual(proof, 101)
1838 self.assertTrue(waiter.cancelled())
1840 def test_yield_wait_does_not_shield_cancel(self):
1844 waiter = self.new_future(self.loop)
1853 with self.assertWarns(DeprecationWarning):
1857 f = asyncio.ensure_future(outer(), loop=self.loop)
1858 test_utils.run_briefly(self.loop)
1860 self.assertRaises(
1861 asyncio.CancelledError, self.loop.run_until_complete, f)
1863 test_utils.run_briefly(self.loop)
1864 self.assertEqual(proof, 1)
1866 def test_shield_result(self):
1867 inner = self.new_future(self.loop)
1870 res = self.loop.run_until_complete(outer)
1871 self.assertEqual(res, 42)
1873 def test_shield_exception(self):
1874 inner = self.new_future(self.loop)
1876 test_utils.run_briefly(self.loop)
1879 test_utils.run_briefly(self.loop)
1880 self.assertIs(outer.exception(), exc)
1882 def test_shield_cancel_inner(self):
1883 inner = self.new_future(self.loop)
1885 test_utils.run_briefly(self.loop)
1887 test_utils.run_briefly(self.loop)
1888 self.assertTrue(outer.cancelled())
1890 def test_shield_cancel_outer(self):
1891 inner = self.new_future(self.loop)
1893 test_utils.run_briefly(self.loop)
1895 test_utils.run_briefly(self.loop)
1896 self.assertTrue(outer.cancelled())
1897 self.assertEqual(0, 0 if outer._callbacks is None else len(outer._callbacks))
1899 def test_shield_shortcut(self):
1900 fut = self.new_future(self.loop)
1902 res = self.loop.run_until_complete(asyncio.shield(fut))
1903 self.assertEqual(res, 42)
1905 def test_shield_effect(self):
1908 waiter = self.new_future(self.loop)
1920 f = asyncio.ensure_future(outer(), loop=self.loop)
1921 test_utils.run_briefly(self.loop)
1923 with self.assertRaises(asyncio.CancelledError):
1924 self.loop.run_until_complete(f)
1926 test_utils.run_briefly(self.loop)
1927 self.assertEqual(proof, 1)
1929 def test_shield_gather(self):
1930 child1 = self.new_future(self.loop)
1931 child2 = self.new_future(self.loop)
1934 test_utils.run_briefly(self.loop)
1936 test_utils.run_briefly(self.loop)
1937 self.assertTrue(outer.cancelled())
1940 test_utils.run_briefly(self.loop)
1941 self.assertEqual(parent.result(), [1, 2])
1943 def test_gather_shield(self):
1944 child1 = self.new_future(self.loop)
1945 child2 = self.new_future(self.loop)
1949 test_utils.run_briefly(self.loop)
1952 test_utils.run_briefly(self.loop)
1953 self.assertIsInstance(parent.exception(), asyncio.CancelledError)
1954 self.assertTrue(inner1.cancelled())
1955 self.assertTrue(inner2.cancelled())
1958 test_utils.run_briefly(self.loop)
1960 def test_shield_coroutine_without_loop(self):
1965 self.addCleanup(inner.close)
1966 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
1969 def test_shield_coroutine_use_running_loop(self):
1975 outer = self.loop.run_until_complete(test())
1976 self.assertEqual(outer._loop, self.loop)
1977 res = self.loop.run_until_complete(outer)
1978 self.assertEqual(res, 42)
1980 def test_shield_coroutine_use_global_loop(self):
1985 asyncio.set_event_loop(self.loop)
1986 self.addCleanup(asyncio.set_event_loop, None)
1988 self.assertEqual(outer._loop, self.loop)
1989 res = self.loop.run_until_complete(outer)
1990 self.assertEqual(res, 42)
1992 def test_as_completed_invalid_args(self):
1993 fut = self.new_future(self.loop)
1996 self.assertRaises(TypeError, self.loop.run_until_complete,
1999 self.assertRaises(TypeError, self.loop.run_until_complete,
2003 def test_wait_invalid_args(self):
2004 fut = self.new_future(self.loop)
2007 self.assertRaises(TypeError, self.loop.run_until_complete,
2010 self.assertRaises(TypeError, self.loop.run_until_complete,
2015 self.assertRaises(ValueError, self.loop.run_until_complete,
2018 def test_log_destroyed_pending_task(self):
2019 Task = self.__class__.Task
2022 future = self.new_future(loop)
2029 self.loop.set_debug(True)
2030 self.loop.set_exception_handler(mock_handler)
2033 coro = kill_me(self.loop)
2034 task = asyncio.ensure_future(coro, loop=self.loop)
2036 self.assertEqual(asyncio.all_tasks(loop=self.loop), {task})
2041 self.loop._run_once()
2042 self.assertEqual(len(self.loop._ready), 0)
2051 self.assertEqual(asyncio.all_tasks(loop=self.loop), set())
2053 mock_handler.assert_called_with(self.loop, {
2061 def test_tb_logger_not_called_after_cancel(self, m_log):
2063 self.set_event_loop(loop)
2069 task = self.new_task(loop, coro())
2075 self.assertFalse(m_log.error.called)
2077 def test_task_source_traceback(self):
2078 self.loop.set_debug(True)
2080 task = self.new_task(self.loop, coroutine_function())
2082 self.assertIsInstance(task._source_traceback, list)
2083 self.assertEqual(task._source_traceback[-2][:3],
2087 self.loop.run_until_complete(task)
2089 def test_cancel_gather_1(self):
2093 self.addCleanup(loop.close)
2095 fut = self.new_future(loop)
2117 self.assertEqual(cancel_result, False)
2118 self.assertFalse(gather_task.cancelled())
2119 self.assertEqual(gather_task.result(), [42])
2121 def test_cancel_gather_2(self):
2130 with self.subTest(cancel_args=cancel_args):
2132 self.addCleanup(loop.close)
2144 qwe = self.new_task(loop, test())
2152 self.assertEqual(exc.args, expected_args)
2154 self.assertEqual(
2159 self.fail(
2164 def test_exception_traceback(self):
2171 task = self.new_task(self.loop, foo())
2173 self.assertIsNotNone(task.exception().__traceback__)
2175 self.loop.run_until_complete(main())
2178 def test_error_in_call_soon(self, m_log):
2181 self.loop.call_soon = call_soon
2186 self.assertFalse(m_log.error.called)
2188 with self.assertRaises(ValueError):
2191 self.new_task(self.loop, gen)
2196 self.assertTrue(m_log.error.called)
2198 self.assertIn('Task was destroyed but it is pending', message)
2200 self.assertEqual(asyncio.all_tasks(self.loop), set())
2202 def test_create_task_with_noncoroutine(self):
2203 with self.assertRaisesRegex(TypeError,
2205 self.new_task(self.loop, 123)
2209 with self.assertRaisesRegex(TypeError,
2211 self.new_task(self.loop, 123)
2213 def test_create_task_with_async_function(self):
2218 task = self.new_task(self.loop, coro())
2219 self.assertIsInstance(task, self.Task)
2220 self.loop.run_until_complete(task)
2224 task = self.new_task(self.loop, coro())
2225 self.assertIsInstance(task, self.Task)
2226 self.loop.run_until_complete(task)
2228 def test_create_task_with_asynclike_function(self):
2229 task = self.new_task(self.loop, CoroLikeObject())
2230 self.assertIsInstance(task, self.Task)
2231 self.assertEqual(self.loop.run_until_complete(task), 42)
2235 task = self.new_task(self.loop, CoroLikeObject())
2236 self.assertIsInstance(task, self.Task)
2237 self.assertEqual(self.loop.run_until_complete(task), 42)
2239 def test_bare_create_task(self):
2246 self.assertIsInstance(task, self.Task)
2248 self.assertEqual(1, ret)
2250 self.loop.run_until_complete(coro())
2252 def test_bare_create_named_task(self):
2259 self.assertEqual(task.get_name(), 'No-op')
2262 self.loop.run_until_complete(coro())
2264 def test_context_1(self):
2269 self.assertEqual(cvar.get(), 'nope')
2273 self.assertEqual(cvar.get(), 'nope')
2274 subtask = self.new_task(loop, sub())
2276 self.assertEqual(cvar.get(), 'yes')
2278 self.assertEqual(cvar.get(), 'yes')
2282 task = self.new_task(loop, main())
2287 def test_context_2(self):
2296 self.assertEqual(cvar.get(), 'nope')
2299 fut = self.new_future(loop)
2304 self.assertEqual(cvar.get(), f'yes{j}')
2310 self.assertEqual(cvar.get(), f'yes{i}-{j}')
2314 task = self.new_task(loop, main())
2319 self.assertEqual(cvar.get(), 'nope')
2321 def test_context_3(self):
2330 self.assertEqual(cvar.get(), num + i)
2346 self.assertEqual(cvar.get(), -1)
2348 def test_context_4(self):
2359 t1 = self.new_task(loop, coro(1), context=ctx)
2362 t2 = self.new_task(loop, coro(2), context=ctx)
2369 task = self.new_task(loop, main())
2374 self.assertEqual([None, 1, 2], ret)
2376 def test_context_5(self):
2397 task = self.new_task(loop, main())
2402 self.assertEqual([None, 1, 2], ret)
2404 def test_context_6(self):
2430 self.assertEqual([None, 1, 2], ret)
2432 def test_get_coro(self):
2436 task = self.new_task(loop, coro)
2438 self.assertIs(task.get_coro(), coro)
2451 def __init__(self, *args, **kwargs):
2452 self.calls = collections.defaultdict(lambda: 0)
2455 def add_done_callback(self, *args, **kwargs):
2456 self.calls['add_done_callback'] += 1
2465 def test_subclasses_ctask_cfuture(self):
2466 fut = self.Future(loop=self.loop)
2469 self.loop.call_soon(lambda: fut.set_result('spam'))
2472 task = self.Task(func(), loop=self.loop)
2474 result = self.loop.run_until_complete(task)
2476 self.assertEqual(result, 'spam')
2478 self.assertEqual(
2482 self.assertEqual(
2503 def test_set_result_causes_invalid_state(self):
2504 Future = type(self).Future
2505 self.loop.call_exception_handler = exc_handler = mock.Mock()
2512 task = self.new_task(self.loop, coro)
2515 self.assertEqual(
2516 self.loop.run_until_complete(task),
2521 with self.assertRaisesRegex(asyncio.InvalidStateError,
2527 def test_set_exception_causes_invalid_state(self):
2531 Future = type(self).Future
2532 self.loop.call_exception_handler = exc_handler = mock.Mock()
2539 task = self.new_task(self.loop, coro)
2542 with self.assertRaises(MyExc):
2543 self.loop.run_until_complete(task)
2547 with self.assertRaisesRegex(asyncio.InvalidStateError,
2564 def test_refleaks_in_task___init__(self):
2568 task = self.new_task(self.loop, coro())
2569 self.loop.run_until_complete(task)
2572 task.__init__(coro(), loop=self.loop)
2573 self.loop.run_until_complete(task)
2574 self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10)
2576 def test_del__log_destroy_pending_segfault(self):
2579 task = self.new_task(self.loop, coro())
2580 self.loop.run_until_complete(task)
2581 with self.assertRaises(AttributeError):
2646 def test_foobar(self):
2649 def get_loop(self):
2656 self.loop = asyncio.new_event_loop()
2658 fut = Fut(loop=self.loop)
2659 self.loop.call_later(0.1, fut.set_result, 1)
2660 task = self.loop.create_task(coro())
2661 res = self.loop.run_until_complete(task)
2663 self.loop.close()
2665 self.assertEqual(res, 'spam')
2674 def test__register_task_1(self):
2677 def _loop(self):
2680 def done(self):
2686 self.assertEqual(asyncio.all_tasks(loop), set())
2687 self._register_task(task)
2688 self.assertEqual(asyncio.all_tasks(loop), {task})
2689 self._unregister_task(task)
2691 def test__register_task_2(self):
2693 def get_loop(self):
2696 def done(self):
2702 self.assertEqual(asyncio.all_tasks(loop), set())
2703 self._register_task(task)
2704 self.assertEqual(asyncio.all_tasks(loop), {task})
2705 self._unregister_task(task)
2707 def test__register_task_3(self):
2709 def get_loop(self):
2712 def done(self):
2718 self.assertEqual(asyncio.all_tasks(loop), set())
2719 self._register_task(task)
2720 self.assertEqual(asyncio.all_tasks(loop), set())
2721 self._unregister_task(task)
2723 def test__enter_task(self):
2726 self.assertIsNone(asyncio.current_task(loop))
2727 self._enter_task(loop, task)
2728 self.assertIs(asyncio.current_task(loop), task)
2729 self._leave_task(loop, task)
2731 def test__enter_task_failure(self):
2735 self._enter_task(loop, task1)
2736 with self.assertRaises(RuntimeError):
2737 self._enter_task(loop, task2)
2738 self.assertIs(asyncio.current_task(loop), task1)
2739 self._leave_task(loop, task1)
2741 def test__leave_task(self):
2744 self._enter_task(loop, task)
2745 self._leave_task(loop, task)
2746 self.assertIsNone(asyncio.current_task(loop))
2748 def test__leave_task_failure1(self):
2752 self._enter_task(loop, task1)
2753 with self.assertRaises(RuntimeError):
2754 self._leave_task(loop, task2)
2755 self.assertIs(asyncio.current_task(loop), task1)
2756 self._leave_task(loop, task1)
2758 def test__leave_task_failure2(self):
2761 with self.assertRaises(RuntimeError):
2762 self._leave_task(loop, task)
2763 self.assertIsNone(asyncio.current_task(loop))
2765 def test__unregister_task(self):
2769 self._register_task(task)
2770 self._unregister_task(task)
2771 self.assertEqual(asyncio.all_tasks(loop), set())
2773 def test__unregister_task_not_registered(self):
2776 self._unregister_task(task)
2777 self.assertEqual(asyncio.all_tasks(loop), set())
2801 def setUp(self):
2803 self.loop = asyncio.new_event_loop()
2804 self.set_event_loop(self.loop)
2806 def new_task(self, coro):
2809 def test_current_task_no_running_loop(self):
2810 self.assertIsNone(asyncio.current_task(loop=self.loop))
2812 def test_current_task_no_running_loop_implicit(self):
2813 with self.assertRaisesRegex(RuntimeError, 'no running event loop'):
2816 def test_current_task_with_implicit_loop(self):
2818 self.assertIs(asyncio.current_task(loop=self.loop), task)
2820 self.assertIs(asyncio.current_task(None), task)
2821 self.assertIs(asyncio.current_task(), task)
2823 task = self.new_task(coro())
2824 self.loop.run_until_complete(task)
2825 self.assertIsNone(asyncio.current_task(loop=self.loop))
2830 def new_task(self, coro):
2831 return tasks._PyTask(coro, loop=self.loop)
2838 def new_task(self, coro):
2839 return getattr(tasks, '_CTask')(coro, loop=self.loop)
2844 def test_future_subclass(self):
2845 self.assertTrue(issubclass(asyncio.Task, asyncio.Future))
2848 def test_asyncio_module_compiled(self):
2858 self.skipTest('C modules are not available')
2863 self.fail('_asyncio module is missing')
2868 def setUp(self):
2870 self.one_loop = self.new_test_loop()
2871 self.other_loop = self.new_test_loop()
2872 self.set_event_loop(self.one_loop, cleanup=False)
2874 def _run_loop(self, loop):
2878 def _check_success(self, **kwargs):
2879 a, b, c = [self.one_loop.create_future() for i in range(3)]
2880 fut = self._gather(*self.wrap_futures(a, b, c), **kwargs)
2885 self._run_loop(self.one_loop)
2886 self.assertEqual(cb.called, False)
2887 self.assertFalse(fut.done())
2889 self._run_loop(self.one_loop)
2891 self.assertEqual(fut.result(), [2, 1, 3])
2893 def test_success(self):
2894 self._check_success()
2895 self._check_success(return_exceptions=False)
2897 def test_result_exception_success(self):
2898 self._check_success(return_exceptions=True)
2900 def test_one_exception(self):
2901 a, b, c, d, e = [self.one_loop.create_future() for i in range(5)]
2902 fut = self._gather(*self.wrap_futures(a, b, c, d, e))
2908 self._run_loop(self.one_loop)
2909 self.assertTrue(fut.done())
2911 self.assertIs(fut.exception(), exc)
2918 def test_return_exceptions(self):
2919 a, b, c, d = [self.one_loop.create_future() for i in range(4)]
2920 fut = self._gather(*self.wrap_futures(a, b, c, d),
2929 self._run_loop(self.one_loop)
2930 self.assertFalse(fut.done())
2932 self._run_loop(self.one_loop)
2933 self.assertTrue(fut.done())
2935 self.assertEqual(fut.result(), [3, 1, exc, exc2])
2937 def test_env_var_debug(self):
2945 self.assertEqual(stdout.rstrip(), b'False')
2950 self.assertEqual(stdout.rstrip(), b'False')
2955 self.assertEqual(stdout.rstrip(), b'True')
2960 self.assertEqual(stdout.rstrip(), b'False')
2965 self.assertEqual(stdout.rstrip(), b'True')
2970 def wrap_futures(self, *futures):
2973 def _gather(self, *args, **kwargs):
2976 def test_constructor_empty_sequence_without_loop(self):
2977 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
2980 def test_constructor_empty_sequence_use_running_loop(self):
2983 fut = self.one_loop.run_until_complete(gather())
2984 self.assertIsInstance(fut, asyncio.Future)
2985 self.assertIs(fut._loop, self.one_loop)
2986 self._run_loop(self.one_loop)
2987 self.assertTrue(fut.done())
2988 self.assertEqual(fut.result(), [])
2990 def test_constructor_empty_sequence_use_global_loop(self):
2992 asyncio.set_event_loop(self.one_loop)
2993 self.addCleanup(asyncio.set_event_loop, None)
2995 self.assertIsInstance(fut, asyncio.Future)
2996 self.assertIs(fut._loop, self.one_loop)
2997 self._run_loop(self.one_loop)
2998 self.assertTrue(fut.done())
2999 self.assertEqual(fut.result(), [])
3001 def test_constructor_heterogenous_futures(self):
3002 fut1 = self.one_loop.create_future()
3003 fut2 = self.other_loop.create_future()
3004 with self.assertRaises(ValueError):
3007 def test_constructor_homogenous_futures(self):
3008 children = [self.other_loop.create_future() for i in range(3)]
3010 self.assertIs(fut._loop, self.other_loop)
3011 self._run_loop(self.other_loop)
3012 self.assertFalse(fut.done())
3014 self.assertIs(fut._loop, self.other_loop)
3015 self._run_loop(self.other_loop)
3016 self.assertFalse(fut.done())
3018 def test_one_cancellation(self):
3019 a, b, c, d, e = [self.one_loop.create_future() for i in range(5)]
3025 self._run_loop(self.one_loop)
3026 self.assertTrue(fut.done())
3028 self.assertFalse(fut.cancelled())
3029 self.assertIsInstance(fut.exception(), asyncio.CancelledError)
3036 def test_result_exception_one_cancellation(self):
3037 a, b, c, d, e, f = [self.one_loop.create_future()
3046 self._run_loop(self.one_loop)
3047 self.assertFalse(fut.done())
3052 res = self.one_loop.run_until_complete(fut)
3053 self.assertIsInstance(res[2], asyncio.CancelledError)
3054 self.assertIsInstance(res[4], asyncio.CancelledError)
3056 self.assertEqual(res, [1, zde, None, 3, None, rte])
3062 def wrap_futures(self, *futures):
3070 def _gather(self, *args, **kwargs):
3073 return self.one_loop.run_until_complete(coro())
3075 def test_constructor_without_loop(self):
3079 self.addCleanup(gen1.close)
3081 self.addCleanup(gen2.close)
3082 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
3085 def test_constructor_use_running_loop(self):
3092 fut = self.one_loop.run_until_complete(gather())
3093 self.assertIs(fut._loop, self.one_loop)
3094 self.one_loop.run_until_complete(fut)
3096 def test_constructor_use_global_loop(self):
3100 asyncio.set_event_loop(self.other_loop)
3101 self.addCleanup(asyncio.set_event_loop, None)
3105 self.assertIs(fut._loop, self.other_loop)
3106 self.other_loop.run_until_complete(fut)
3108 def test_duplicate_coroutines(self):
3112 fut = self._gather(c, c, coro('def'), c)
3113 self._run_loop(self.one_loop)
3114 self.assertEqual(fut.result(), ['abc', 'abc', 'def', 'abc'])
3116 def test_cancellation_broadcast(self):
3119 waiter = self.one_loop.create_future()
3126 child1 = asyncio.ensure_future(inner(), loop=self.one_loop)
3127 child2 = asyncio.ensure_future(inner(), loop=self.one_loop)
3136 f = asyncio.ensure_future(outer(), loop=self.one_loop)
3137 test_utils.run_briefly(self.one_loop)
3138 self.assertTrue(f.cancel())
3139 with self.assertRaises(asyncio.CancelledError):
3140 self.one_loop.run_until_complete(f)
3141 self.assertFalse(gatherer.cancel())
3142 self.assertTrue(waiter.cancelled())
3143 self.assertTrue(child1.cancelled())
3144 self.assertTrue(child2.cancelled())
3145 test_utils.run_briefly(self.one_loop)
3146 self.assertEqual(proof, 0)
3148 def test_exception_marking(self):
3155 a = self.one_loop.create_future()
3156 b = self.one_loop.create_future()
3161 f = asyncio.ensure_future(outer(), loop=self.one_loop)
3162 test_utils.run_briefly(self.one_loop)
3164 test_utils.run_briefly(self.one_loop)
3166 test_utils.run_briefly(self.one_loop)
3167 self.assertIsInstance(f.exception(), RuntimeError)
3169 def test_issue46672(self):
3177 with self.assertRaises(TypeError):
3178 self._gather(c, {})
3179 self._run_loop(self.one_loop)
3181 self.one_loop.call_exception_handler.assert_not_called()
3187 def setUp(self):
3189 self.loop = asyncio.new_event_loop()
3190 self.set_event_loop(self.loop) # Will cleanup properly
3192 async def add(self, a, b, fail=False, cancel=False):
3198 asyncio.current_task(self.loop).cancel()
3202 def target(self, fail=False, cancel=False, timeout=None,
3205 coro = self.add(1, 2, fail=fail, cancel=cancel)
3206 future = asyncio.run_coroutine_threadsafe(coro, self.loop)
3213 self.loop.call_soon_threadsafe(coro.send, None)
3219 def test_run_coroutine_threadsafe(self):
3221 future = self.loop.run_in_executor(None, self.target)
3222 result = self.loop.run_until_complete(future)
3223 self.assertEqual(result, 3)
3225 def test_run_coroutine_threadsafe_with_exception(self):
3228 future = self.loop.run_in_executor(None, self.target, True)
3229 with self.assertRaises(RuntimeError) as exc_context:
3230 self.loop.run_until_complete(future)
3231 self.assertIn("Fail!", exc_context.exception.args)
3233 def test_run_coroutine_threadsafe_with_timeout(self):
3236 callback = lambda: self.target(timeout=0)
3237 future = self.loop.run_in_executor(None, callback)
3238 with self.assertRaises(asyncio.TimeoutError):
3239 self.loop.run_until_complete(future)
3240 test_utils.run_briefly(self.loop)
3242 for task in asyncio.all_tasks(self.loop):
3243 self.assertTrue(task.done())
3245 def test_run_coroutine_threadsafe_task_cancelled(self):
3248 callback = lambda: self.target(cancel=True)
3249 future = self.loop.run_in_executor(None, callback)
3250 with self.assertRaises(asyncio.CancelledError):
3251 self.loop.run_until_complete(future)
3253 def test_run_coroutine_threadsafe_task_factory_exception(self):
3260 run = self.loop.run_in_executor(
3261 None, lambda: self.target(advance_coro=True))
3265 self.loop.set_exception_handler(callback)
3268 self.addCleanup(self.loop.set_task_factory,
3269 self.loop.get_task_factory())
3270 self.loop.set_task_factory(task_factory)
3273 with self.assertRaises(NameError) as exc_context:
3274 self.loop.run_until_complete(run)
3277 self.assertEqual(len(callback.call_args_list), 1)
3279 self.assertEqual(context['exception'], exc_context.exception)
3283 def setUp(self):
3285 self.loop = asyncio.new_event_loop()
3286 self.set_event_loop(self.loop)
3288 def tearDown(self):
3289 self.loop.close()
3290 self.loop = None
3293 def test_sleep_zero(self):
3301 self.loop.call_soon(inc_result, 1)
3302 self.assertEqual(result, 0)
3304 self.assertEqual(result, 1) # inc'ed by call_soon
3307 self.loop.run_until_complete(coro())
3308 self.assertEqual(result, 11)
3315 def setUp(self):
3317 self.loop = asyncio.new_event_loop()
3318 self.set_event_loop(self.loop)
3320 def tearDown(self):
3321 self.loop.close()
3322 self.loop = None