Lines Matching refs:barrier
16 r'(, waiters:\d+\/\d+)?' # barrier
1064 barrier = asyncio.Barrier(self.N)
1065 self.assertIn("filling", repr(barrier))
1070 await barrier
1072 self.assertIn("filling", repr(barrier))
1075 barrier = asyncio.Barrier(self.N)
1077 self.assertTrue(RGX_REPR.match(repr(barrier)))
1078 self.assertIn("filling", repr(barrier))
1081 async def wait(barrier):
1082 await barrier.wait()
1086 waiters.append(asyncio.create_task(wait(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))
1094 for i in range(barrier.parties - barrier.n_waiting):
1095 waiters.append(asyncio.create_task(wait(barrier)))
1098 self.assertTrue(RGX_REPR.match(repr(barrier)))
1099 self.assertIn("draining", repr(barrier))
1103 waiters.append(asyncio.create_task(wait(barrier)))
1106 await barrier.reset()
1108 self.assertTrue(RGX_REPR.match(repr(barrier)))
1109 self.assertIn("resetting", repr(barrier))
1113 waiters.append(asyncio.create_task(wait(barrier)))
1116 await barrier.abort()
1118 self.assertTrue(RGX_REPR.match(repr(barrier)))
1119 self.assertIn("broken", repr(barrier))
1120 self.assertTrue(barrier.broken)
1133 barrier = asyncio.Barrier(self.N)
1137 async with barrier as i:
1143 self.assertEqual(barrier.n_waiting, 0)
1144 self.assertFalse(barrier.broken)
1147 barrier = asyncio.Barrier(1)
1150 async with barrier as i:
1156 self.assertEqual(barrier.n_waiting, 0)
1157 self.assertFalse(barrier.broken)
1160 barrier = asyncio.Barrier(1)
1162 t1 = asyncio.create_task(barrier.wait())
1164 self.assertEqual(barrier.n_waiting, 0)
1166 t2 = asyncio.create_task(barrier.wait())
1172 self.assertEqual(barrier.n_waiting, 0)
1173 self.assertFalse(barrier.broken)
1177 barrier = asyncio.Barrier(self.N)
1179 t1 = asyncio.create_task(barrier.wait())
1181 self.assertEqual(barrier.n_waiting, 1)
1182 self.assertIn("filling", repr(barrier))
1184 t2 = asyncio.create_task(barrier.wait())
1186 self.assertEqual(barrier.n_waiting, 2)
1187 self.assertIn("filling", repr(barrier))
1189 t3 = asyncio.create_task(barrier.wait())
1194 self.assertEqual(barrier.n_waiting, 0)
1195 self.assertFalse(barrier.broken)
1198 barrier = asyncio.Barrier(self.N)
1202 async with barrier:
1205 async with barrier:
1214 self.assertEqual(barrier.n_waiting, 0)
1215 self.assertFalse(barrier.broken)
1218 barrier = asyncio.Barrier(self.N)
1223 async with barrier:
1226 async with barrier as i:
1238 self.assertEqual(barrier.n_waiting, 0)
1239 self.assertFalse(barrier.broken)
1242 barrier = asyncio.Barrier(self.N)
1246 async with barrier:
1247 # barrier state change to filling for the last task release
1248 results.append("draining" in repr(barrier))
1256 self.assertEqual(barrier.n_waiting, 0)
1257 self.assertFalse(barrier.broken)
1261 barrier = asyncio.Barrier(self.N)
1271 await barrier.wait()
1277 await barrier.wait()
1282 await barrier.wait()
1290 barrier = asyncio.Barrier(self.N)
1294 await barrier.wait()
1299 self.assertEqual(barrier.n_waiting, 1)
1303 self.assertEqual(barrier.n_waiting, 2)
1307 self.assertEqual(barrier.n_waiting, 1)
1314 self.assertEqual(barrier.n_waiting, 2)
1322 self.assertEqual(barrier.n_waiting, 0)
1323 self.assertFalse(barrier.broken)
1326 barrier = asyncio.Barrier(1)
1328 asyncio.create_task(barrier.reset())
1331 self.assertEqual(barrier.n_waiting, 0)
1332 self.assertFalse(barrier.broken)
1335 barrier = asyncio.Barrier(self.N)
1340 await barrier.wait()
1345 await barrier.reset()
1347 # N-1 tasks waiting on barrier with N parties
1351 # reset the barrier
1357 self.assertEqual(barrier.n_waiting, 0)
1358 self.assertNotIn("resetting", repr(barrier))
1359 self.assertFalse(barrier.broken)
1362 barrier = asyncio.Barrier(self.N)
1368 await barrier.wait()
1373 # here drained task ouside the barrier
1374 if rest_of_tasks == barrier._count:
1375 # tasks outside the barrier
1376 await barrier.reset()
1381 self.assertEqual(barrier.n_waiting, 0)
1382 self.assertNotIn("resetting", repr(barrier))
1383 self.assertFalse(barrier.broken)
1386 barrier = asyncio.Barrier(self.N)
1395 await barrier.wait()
1401 await barrier.wait()
1406 await barrier.reset()
1409 await barrier.wait()
1412 await barrier.wait()
1421 self.assertEqual(barrier.n_waiting, 0)
1422 self.assertNotIn("resetting", repr(barrier))
1423 self.assertFalse(barrier.broken)
1426 barrier = asyncio.Barrier(self.N)
1432 await barrier.wait()
1436 await barrier.wait()
1440 async with barrier:
1445 # reset barrier, N-1 waiting tasks raise an BrokenBarrierError
1446 asyncio.create_task(barrier.reset())
1454 self.assertFalse(barrier.broken)
1460 self.assertEqual(barrier.n_waiting, 0)
1464 barrier = asyncio.Barrier(self.N)
1473 i = await barrier.wait()
1476 # last task exited from barrier
1477 await barrier.reset()
1480 await barrier.wait()
1484 await barrier.wait()
1492 # Now, pass the barrier again
1494 k = await barrier.wait()
1499 self.assertFalse(barrier.broken)
1506 self.assertEqual(barrier.n_waiting, 0)
1509 barrier = asyncio.Barrier(1)
1511 asyncio.create_task(barrier.abort())
1514 self.assertEqual(barrier.n_waiting, 0)
1515 self.assertTrue(barrier.broken)
1518 barrier = asyncio.Barrier(self.N)
1527 await barrier.wait()
1535 await barrier.abort()
1538 await barrier.wait()
1545 self.assertTrue(barrier.broken)
1548 self.assertEqual(barrier.n_waiting, 0)
1549 self.assertNotIn("resetting", repr(barrier))
1553 barrier = asyncio.Barrier(self.N)
1559 async with barrier as i :
1562 async with barrier:
1567 await barrier.abort()
1571 self.assertTrue(barrier.broken)
1575 self.assertEqual(barrier.n_waiting, 0)
1597 # Synchronize and reset the barrier. Must synchronize first so