Lines Matching refs:self
28 async def test_repr(self):
30 self.assertTrue(repr(lock).endswith('[unlocked]>'))
31 self.assertTrue(RGX_REPR.match(repr(lock)))
34 self.assertTrue(repr(lock).endswith('[locked]>'))
35 self.assertTrue(RGX_REPR.match(repr(lock)))
37 async def test_lock(self):
40 with self.assertRaisesRegex(
46 self.assertFalse(lock.locked())
48 async def test_lock_doesnt_accept_loop_parameter(self):
60 with self.assertRaisesRegex(
67 async def test_lock_by_with_statement(self):
77 self.assertFalse(lock.locked())
78 with self.assertRaisesRegex(
84 self.assertFalse(lock.locked())
86 async def test_acquire(self):
90 self.assertTrue(await lock.acquire())
111 self.assertEqual([], result)
115 self.assertEqual([1], result)
118 self.assertEqual([1], result)
124 self.assertEqual([1, 2], result)
128 self.assertEqual([1, 2, 3], result)
130 self.assertTrue(t1.done())
131 self.assertTrue(t1.result())
132 self.assertTrue(t2.done())
133 self.assertTrue(t2.result())
134 self.assertTrue(t3.done())
135 self.assertTrue(t3.result())
137 async def test_acquire_cancel(self):
139 self.assertTrue(await lock.acquire())
143 with self.assertRaises(asyncio.CancelledError):
145 self.assertFalse(lock._waiters)
147 async def test_cancel_race(self):
175 self.assertTrue(lock.locked())
178 self.assertEqual(len(lock._waiters), 1)
181 self.assertEqual(len(lock._waiters), 2)
187 self.assertTrue(lock._waiters[0].cancelled())
189 self.assertFalse(lock.locked())
190 self.assertTrue(ta.done())
191 self.assertTrue(tb.cancelled())
194 async def test_cancel_release_race(self):
224 with self.assertRaises(asyncio.CancelledError):
229 self.assertEqual(lock_count, 1)
231 self.assertEqual(call_count, 3)
232 self.assertTrue(t1.cancelled() and t2.done())
237 self.assertTrue(t3.cancelled())
239 async def test_finished_waiter_cancelled(self):
243 self.assertTrue(lock.locked())
247 self.assertEqual(len(lock._waiters), 1)
256 self.assertTrue(lock.locked())
257 self.assertTrue(tb.cancelled())
262 async def test_release_not_acquired(self):
265 self.assertRaises(RuntimeError, lock.release)
267 async def test_release_no_waiters(self):
270 self.assertTrue(lock.locked())
273 self.assertFalse(lock.locked())
275 async def test_context_manager(self):
277 self.assertFalse(lock.locked())
280 self.assertTrue(lock.locked())
282 self.assertFalse(lock.locked())
287 def test_repr(self):
289 self.assertTrue(repr(ev).endswith('[unset]>'))
291 self.assertEqual(match.group('extras'), 'unset')
294 self.assertTrue(repr(ev).endswith('[set]>'))
295 self.assertTrue(RGX_REPR.match(repr(ev)))
298 self.assertTrue('waiters:1' in repr(ev))
299 self.assertTrue(RGX_REPR.match(repr(ev)))
301 async def test_wait(self):
303 self.assertFalse(ev.is_set())
323 self.assertEqual([], result)
329 self.assertEqual([3, 1, 2], result)
331 self.assertTrue(t1.done())
332 self.assertIsNone(t1.result())
333 self.assertTrue(t2.done())
334 self.assertIsNone(t2.result())
335 self.assertTrue(t3.done())
336 self.assertIsNone(t3.result())
338 async def test_wait_on_set(self):
343 self.assertTrue(res)
345 async def test_wait_cancel(self):
350 with self.assertRaises(asyncio.CancelledError):
352 self.assertFalse(ev._waiters)
354 async def test_clear(self):
356 self.assertFalse(ev.is_set())
359 self.assertTrue(ev.is_set())
362 self.assertFalse(ev.is_set())
364 async def test_clear_with_waiters(self):
375 self.assertEqual([], result)
379 self.assertFalse(ev.is_set())
383 self.assertEqual(1, len(ev._waiters))
386 self.assertEqual([1], result)
387 self.assertEqual(0, len(ev._waiters))
389 self.assertTrue(t.done())
390 self.assertTrue(t.result())
395 async def test_wait(self):
422 self.assertEqual([], result)
423 self.assertFalse(cond.locked())
425 self.assertTrue(await cond.acquire())
428 self.assertEqual([], result)
429 self.assertTrue(cond.locked())
433 self.assertEqual([1], result)
434 self.assertTrue(cond.locked())
438 self.assertEqual([1], result)
439 self.assertTrue(cond.locked())
443 self.assertEqual([1, 2], result)
444 self.assertTrue(cond.locked())
448 self.assertEqual([1, 2, 3], result)
449 self.assertTrue(cond.locked())
451 self.assertTrue(t1.done())
452 self.assertTrue(t1.result())
453 self.assertTrue(t2.done())
454 self.assertTrue(t2.result())
455 self.assertTrue(t3.done())
456 self.assertTrue(t3.result())
458 async def test_wait_cancel(self):
464 with self.assertRaises(asyncio.CancelledError):
466 self.assertFalse(cond._waiters)
467 self.assertTrue(cond.locked())
469 async def test_wait_cancel_contested(self):
473 self.assertTrue(cond.locked())
477 self.assertFalse(cond.locked())
481 self.assertTrue(cond.locked())
492 self.assertTrue(cond.locked())
494 async def test_wait_cancel_after_notify(self):
517 self.assertTrue(waiter.cancelled())
518 self.assertTrue(waited)
520 async def test_wait_unacquired(self):
522 with self.assertRaises(RuntimeError):
525 async def test_wait_for(self):
544 self.assertEqual([], result)
550 self.assertEqual([], result)
557 self.assertEqual([1], result)
559 self.assertTrue(t.done())
560 self.assertTrue(t.result())
562 async def test_wait_for_unacquired(self):
567 self.assertEqual([1, 2, 3], res)
569 with self.assertRaises(RuntimeError):
572 async def test_notify(self):
602 self.assertEqual([], result)
608 self.assertEqual([1], result)
615 self.assertEqual([1, 2, 3], result)
617 self.assertTrue(t1.done())
618 self.assertTrue(t1.result())
619 self.assertTrue(t2.done())
620 self.assertTrue(t2.result())
621 self.assertTrue(t3.done())
622 self.assertTrue(t3.result())
624 async def test_notify_all(self):
647 self.assertEqual([], result)
653 self.assertEqual([1, 2], result)
655 self.assertTrue(t1.done())
656 self.assertTrue(t1.result())
657 self.assertTrue(t2.done())
658 self.assertTrue(t2.result())
660 def test_notify_unacquired(self):
662 self.assertRaises(RuntimeError, cond.notify)
664 def test_notify_all_unacquired(self):
666 self.assertRaises(RuntimeError, cond.notify_all)
668 async def test_repr(self):
670 self.assertTrue('unlocked' in repr(cond))
671 self.assertTrue(RGX_REPR.match(repr(cond)))
674 self.assertTrue('locked' in repr(cond))
677 self.assertTrue('waiters:1' in repr(cond))
678 self.assertTrue(RGX_REPR.match(repr(cond)))
681 self.assertTrue('waiters:2' in repr(cond))
682 self.assertTrue(RGX_REPR.match(repr(cond)))
684 async def test_context_manager(self):
686 self.assertFalse(cond.locked())
688 self.assertTrue(cond.locked())
689 self.assertFalse(cond.locked())
691 async def test_explicit_lock(self):
697 self.assertIs(cond._lock, lock)
698 self.assertFalse(lock.locked())
699 self.assertFalse(cond.locked())
701 self.assertTrue(lock.locked())
702 self.assertTrue(cond.locked())
703 self.assertFalse(lock.locked())
704 self.assertFalse(cond.locked())
706 self.assertTrue(lock.locked())
707 self.assertTrue(cond.locked())
708 self.assertFalse(lock.locked())
709 self.assertFalse(cond.locked())
717 async def test_ambiguous_loops(self):
719 self.addCleanup(loop.close)
722 with self.assertRaises(TypeError):
732 with self.assertRaisesRegex(
742 with self.assertRaises(TypeError):
746 with self.assertRaisesRegex(
755 async def test_timeout_in_block(self):
758 with self.assertRaises(asyncio.TimeoutError):
764 def test_initial_value_zero(self):
766 self.assertTrue(sem.locked())
768 async def test_repr(self):
770 self.assertTrue(repr(sem).endswith('[unlocked, value:1]>'))
771 self.assertTrue(RGX_REPR.match(repr(sem)))
774 self.assertTrue(repr(sem).endswith('[locked]>'))
775 self.assertTrue('waiters' not in repr(sem))
776 self.assertTrue(RGX_REPR.match(repr(sem)))
782 self.assertTrue('waiters:1' in repr(sem))
783 self.assertTrue(RGX_REPR.match(repr(sem)))
786 self.assertTrue('waiters:2' in repr(sem))
787 self.assertTrue(RGX_REPR.match(repr(sem)))
789 async def test_semaphore(self):
791 self.assertEqual(1, sem._value)
793 with self.assertRaisesRegex(
799 self.assertFalse(sem.locked())
800 self.assertEqual(1, sem._value)
802 def test_semaphore_value(self):
803 self.assertRaises(ValueError, asyncio.Semaphore, -1)
805 async def test_acquire(self):
809 self.assertTrue(await sem.acquire())
810 self.assertTrue(await sem.acquire())
811 self.assertFalse(sem.locked())
838 self.assertEqual([1], result)
839 self.assertTrue(sem.locked())
840 self.assertEqual(2, len(sem._waiters))
841 self.assertEqual(0, sem._value)
847 self.assertEqual(0, sem._value)
850 self.assertEqual(0, sem._value)
851 self.assertEqual(3, len(result))
852 self.assertTrue(sem.locked())
853 self.assertEqual(1, len(sem._waiters))
854 self.assertEqual(0, sem._value)
856 self.assertTrue(t1.done())
857 self.assertTrue(t1.result())
860 self.assertEqual(2, len(done_tasks))
866 async def test_acquire_cancel(self):
872 with self.assertRaises(asyncio.CancelledError):
874 self.assertTrue((not sem._waiters) or
877 async def test_acquire_cancel_before_awoken(self):
894 self.assertEqual(num_done, 1)
895 self.assertTrue(t3.done())
896 self.assertFalse(t4.done())
902 async def test_acquire_hang(self):
913 self.assertTrue(sem.locked())
914 self.assertTrue(t2.done())
916 async def test_acquire_no_hang(self):
927 self.assertFalse(True)
933 self.assertTrue(r1 is None)
934 self.assertTrue(isinstance(r2, asyncio.CancelledError))
938 def test_release_not_acquired(self):
941 self.assertRaises(ValueError, sem.release)
943 async def test_release_no_waiters(self):
946 self.assertTrue(sem.locked())
949 self.assertFalse(sem.locked())
951 async def test_acquire_fifo_order(self):
971 self.assertEqual(
976 async def test_acquire_fifo_order_2(self):
1009 self.assertEqual([1, 2, 3, 4], result)
1011 async def test_acquire_fifo_order_3(self):
1045 self.assertEqual([2, 3], result)
1050 async def asyncSetUp(self):
1052 self.N = 5
1054 def make_tasks(self, n, coro):
1058 async def gather_tasks(self, n, coro):
1059 tasks = self.make_tasks(n, coro)
1063 async def test_barrier(self):
1064 barrier = asyncio.Barrier(self.N)
1065 self.assertIn("filling", repr(barrier))
1066 with self.assertRaisesRegex(
1072 self.assertIn("filling", repr(barrier))
1074 async def test_repr(self):
1075 barrier = asyncio.Barrier(self.N)
1077 self.assertTrue(RGX_REPR.match(repr(barrier)))
1078 self.assertIn("filling", repr(barrier))
1089 self.assertTrue(RGX_REPR.match(repr(barrier)))
1090 self.assertTrue(f"waiters:{incr}/{self.N}" in repr(barrier))
1091 self.assertIn("filling", repr(barrier))
1098 self.assertTrue(RGX_REPR.match(repr(barrier)))
1099 self.assertIn("draining", repr(barrier))
1108 self.assertTrue(RGX_REPR.match(repr(barrier)))
1109 self.assertIn("resetting", repr(barrier))
1118 self.assertTrue(RGX_REPR.match(repr(barrier)))
1119 self.assertIn("broken", repr(barrier))
1120 self.assertTrue(barrier.broken)
1125 async def test_barrier_parties(self):
1126 self.assertRaises(ValueError, lambda: asyncio.Barrier(0))
1127 self.assertRaises(ValueError, lambda: asyncio.Barrier(-4))
1129 self.assertIsInstance(asyncio.Barrier(self.N), asyncio.Barrier)
1131 async def test_context_manager(self):
1132 self.N = 3
1133 barrier = asyncio.Barrier(self.N)
1140 await self.gather_tasks(self.N, coro)
1142 self.assertListEqual(sorted(results), list(range(self.N)))
1143 self.assertEqual(barrier.n_waiting, 0)
1144 self.assertFalse(barrier.broken)
1146 async def test_filling_one_task(self):
1155 self.assertTrue(ret)
1156 self.assertEqual(barrier.n_waiting, 0)
1157 self.assertFalse(barrier.broken)
1159 async def test_filling_one_task_twice(self):
1164 self.assertEqual(barrier.n_waiting, 0)
1169 self.assertEqual(t1.result(), t2.result())
1170 self.assertEqual(t1.done(), t2.done())
1172 self.assertEqual(barrier.n_waiting, 0)
1173 self.assertFalse(barrier.broken)
1175 async def test_filling_task_by_task(self):
1176 self.N = 3
1177 barrier = asyncio.Barrier(self.N)
1181 self.assertEqual(barrier.n_waiting, 1)
1182 self.assertIn("filling", repr(barrier))
1186 self.assertEqual(barrier.n_waiting, 2)
1187 self.assertIn("filling", repr(barrier))
1194 self.assertEqual(barrier.n_waiting, 0)
1195 self.assertFalse(barrier.broken)
1197 async def test_filling_tasks_wait_twice(self):
1198 barrier = asyncio.Barrier(self.N)
1208 await self.gather_tasks(self.N, coro)
1210 self.assertEqual(len(results), self.N*2)
1211 self.assertEqual(results.count(True), self.N)
1212 self.assertEqual(results.count(False), self.N)
1214 self.assertEqual(barrier.n_waiting, 0)
1215 self.assertFalse(barrier.broken)
1217 async def test_filling_tasks_check_return_value(self):
1218 barrier = asyncio.Barrier(self.N)
1230 res, _ = await self.gather_tasks(self.N, coro)
1232 self.assertEqual(len(results1), self.N)
1233 self.assertTrue(all(results1))
1234 self.assertEqual(len(results2), self.N)
1235 self.assertTrue(all(results2))
1236 self.assertListEqual(sorted(res), list(range(self.N)))
1238 self.assertEqual(barrier.n_waiting, 0)
1239 self.assertFalse(barrier.broken)
1241 async def test_draining_state(self):
1242 barrier = asyncio.Barrier(self.N)
1250 await self.gather_tasks(self.N, coro)
1252 self.assertEqual(len(results), self.N)
1253 self.assertEqual(results[-1], False)
1254 self.assertTrue(all(results[:self.N-1]))
1256 self.assertEqual(barrier.n_waiting, 0)
1257 self.assertFalse(barrier.broken)
1259 async def test_blocking_tasks_while_draining(self):
1261 barrier = asyncio.Barrier(self.N)
1262 barrier_nowaiting = asyncio.Barrier(self.N - rewait)
1286 await self.gather_tasks(self.N, coro)
1288 async def test_filling_tasks_cancel_one(self):
1289 self.N = 3
1290 barrier = asyncio.Barrier(self.N)
1299 self.assertEqual(barrier.n_waiting, 1)
1303 self.assertEqual(barrier.n_waiting, 2)
1307 self.assertEqual(barrier.n_waiting, 1)
1308 with self.assertRaises(asyncio.CancelledError):
1310 self.assertTrue(t1.cancelled())
1314 self.assertEqual(barrier.n_waiting, 2)
1319 self.assertEqual(len(results), self.N)
1320 self.assertTrue(all(results))
1322 self.assertEqual(barrier.n_waiting, 0)
1323 self.assertFalse(barrier.broken)
1325 async def test_reset_barrier(self):
1331 self.assertEqual(barrier.n_waiting, 0)
1332 self.assertFalse(barrier.broken)
1334 async def test_reset_barrier_while_tasks_waiting(self):
1335 barrier = asyncio.Barrier(self.N)
1348 tasks = self.make_tasks(self.N-1, coro)
1355 self.assertEqual(len(results), self.N-1)
1356 self.assertTrue(all(results))
1357 self.assertEqual(barrier.n_waiting, 0)
1358 self.assertNotIn("resetting", repr(barrier))
1359 self.assertFalse(barrier.broken)
1361 async def test_reset_barrier_when_tasks_half_draining(self):
1362 barrier = asyncio.Barrier(self.N)
1364 rest_of_tasks = self.N//2
1378 await self.gather_tasks(self.N, coro)
1380 self.assertEqual(results1, [True]*rest_of_tasks)
1381 self.assertEqual(barrier.n_waiting, 0)
1382 self.assertNotIn("resetting", repr(barrier))
1383 self.assertFalse(barrier.broken)
1385 async def test_reset_barrier_when_tasks_half_draining_half_blocking(self):
1386 barrier = asyncio.Barrier(self.N)
1389 blocking_tasks = self.N//2
1417 await self.gather_tasks(self.N, coro)
1419 self.assertEqual(results1, [True]*blocking_tasks)
1420 self.assertEqual(results2, [])
1421 self.assertEqual(barrier.n_waiting, 0)
1422 self.assertNotIn("resetting", repr(barrier))
1423 self.assertFalse(barrier.broken)
1425 async def test_reset_barrier_while_tasks_waiting_and_waiting_again(self):
1426 barrier = asyncio.Barrier(self.N)
1443 tasks = self.make_tasks(self.N-1, coro1)
1454 self.assertFalse(barrier.broken)
1455 self.assertEqual(len(results1), self.N-1)
1456 self.assertTrue(all(results1))
1457 self.assertEqual(len(results2), self.N)
1458 self.assertTrue(all(results2))
1460 self.assertEqual(barrier.n_waiting, 0)
1463 async def test_reset_barrier_while_tasks_draining(self):
1464 barrier = asyncio.Barrier(self.N)
1475 if count == self.N:
1497 await self.gather_tasks(self.N, coro)
1499 self.assertFalse(barrier.broken)
1500 self.assertTrue(all(results1))
1501 self.assertEqual(len(results1), self.N-1)
1502 self.assertEqual(len(results2), 0)
1503 self.assertEqual(len(results3), self.N)
1504 self.assertTrue(all(results3))
1506 self.assertEqual(barrier.n_waiting, 0)
1508 async def test_abort_barrier(self):
1514 self.assertEqual(barrier.n_waiting, 0)
1515 self.assertTrue(barrier.broken)
1517 async def test_abort_barrier_when_tasks_half_draining_half_blocking(self):
1518 barrier = asyncio.Barrier(self.N)
1521 blocking_tasks = self.N//2
1543 await self.gather_tasks(self.N, coro)
1545 self.assertTrue(barrier.broken)
1546 self.assertEqual(results1, [True]*blocking_tasks)
1547 self.assertEqual(results2, [True]*(self.N-blocking_tasks-1))
1548 self.assertEqual(barrier.n_waiting, 0)
1549 self.assertNotIn("resetting", repr(barrier))
1551 async def test_abort_barrier_when_exception(self):
1553 barrier = asyncio.Barrier(self.N)
1560 if i == self.N//2:
1569 await self.gather_tasks(self.N, coro)
1571 self.assertTrue(barrier.broken)
1572 self.assertEqual(len(results1), 0)
1573 self.assertEqual(len(results2), self.N-1)
1574 self.assertTrue(all(results2))
1575 self.assertEqual(barrier.n_waiting, 0)
1577 async def test_abort_barrier_when_exception_then_resetting(self):
1579 barrier1 = asyncio.Barrier(self.N)
1580 barrier2 = asyncio.Barrier(self.N)
1588 if i == self.N//2:
1601 if i == self.N//2:
1607 await self.gather_tasks(self.N, coro)
1609 self.assertFalse(barrier1.broken)
1610 self.assertEqual(len(results1), 0)
1611 self.assertEqual(len(results2), self.N-1)
1612 self.assertTrue(all(results2))
1613 self.assertEqual(len(results3), self.N)
1614 self.assertTrue(all(results3))
1616 self.assertEqual(barrier1.n_waiting, 0)