Lines Matching refs:loop
60 loop = asyncio.new_event_loop()
61 asyncio.set_event_loop(loop)
62 return loop.run_until_complete(doit())
83 def __init__(self, loop=None):
87 if loop is not None:
88 self.connected = loop.create_future()
89 self.done = loop.create_future()
126 def __init__(self, loop=None):
129 if loop is not None:
130 self.done = loop.create_future()
158 def __init__(self, loop=None):
162 if loop is not None:
163 self.done = loop.create_future()
194 def __init__(self, loop=None):
197 if loop is not None:
198 self.done = loop.create_future()
218 def __init__(self, loop):
221 self.connected = loop.create_future()
222 self.completed = loop.create_future()
223 self.disconnects = {fd: loop.create_future() for fd in range(3)}
265 self.loop = self.create_event_loop()
266 self.set_event_loop(self.loop)
270 if not self.loop.is_closed():
271 test_utils.run_briefly(self.loop)
282 self.assertTrue(self.loop.is_running())
283 self.loop.run_until_complete(coro1())
290 RuntimeError, self.loop.run_until_complete, coro2())
296 t0 = self.loop.time()
297 self.loop.run_until_complete(asyncio.sleep(0.1))
298 t1 = self.loop.time()
304 self.loop.stop()
308 self.loop.run_until_complete, task)
315 self.loop.stop()
317 self.loop.call_later(0.1, callback, 'hello world')
318 self.loop.run_forever()
326 self.loop.stop()
328 self.loop.call_soon(callback, 'hello', 'world')
329 self.loop.run_forever()
339 self.loop.stop()
342 self.loop.call_soon_threadsafe(callback, 'hello')
350 self.loop.call_soon(callback, 'world')
351 self.loop.run_forever()
361 self.loop.stop()
363 self.loop.call_soon_threadsafe(callback, 'hello')
364 self.loop.call_soon(callback, 'world')
365 self.loop.run_forever()
371 f2 = self.loop.run_in_executor(None, run, 'yo')
372 res, thread_id = self.loop.run_until_complete(f2)
386 f2 = self.loop.run_in_executor(None, run)
388 self.loop.run_until_complete(
389 self.loop.shutdown_default_executor())
390 self.loop.close()
391 self.loop.call_soon = patched_call_soon
392 self.loop.call_soon_threadsafe = patched_call_soon
411 self.assertTrue(self.loop.remove_reader(r.fileno()))
414 self.loop.add_reader(r.fileno(), reader)
415 self.loop.call_soon(w.send, b'abc')
416 test_utils.run_until(self.loop, lambda: len(bytes_read) >= 3)
417 self.loop.call_soon(w.send, b'def')
418 test_utils.run_until(self.loop, lambda: len(bytes_read) >= 6)
419 self.loop.call_soon(w.close)
420 self.loop.call_soon(self.loop.stop)
421 self.loop.run_forever()
430 self.loop.stop()
433 self.loop.add_writer(w.fileno(), writer, data)
434 self.loop.run_forever()
436 self.assertTrue(self.loop.remove_writer(w.fileno()))
437 self.assertFalse(self.loop.remove_writer(w.fileno()))
454 TypeError, self.loop.add_signal_handler, 'boom', my_handler)
456 TypeError, self.loop.remove_signal_handler, 'boom')
458 ValueError, self.loop.add_signal_handler, signal.NSIG+1,
461 ValueError, self.loop.remove_signal_handler, signal.NSIG+1)
463 ValueError, self.loop.add_signal_handler, 0, my_handler)
465 ValueError, self.loop.remove_signal_handler, 0)
467 ValueError, self.loop.add_signal_handler, -1, my_handler)
469 ValueError, self.loop.remove_signal_handler, -1)
471 RuntimeError, self.loop.add_signal_handler, signal.SIGKILL,
474 self.assertFalse(self.loop.remove_signal_handler(signal.SIGKILL))
476 self.loop.add_signal_handler(signal.SIGINT, my_handler)
479 test_utils.run_until(self.loop, lambda: caught)
482 self.assertTrue(self.loop.remove_signal_handler(signal.SIGINT))
486 self.assertFalse(self.loop.remove_signal_handler(signal.SIGINT))
498 self.loop.stop()
500 self.loop.add_signal_handler(signal.SIGALRM, my_handler)
503 self.loop.call_later(60, self.loop.stop)
504 self.loop.run_forever()
518 self.loop.stop()
520 self.loop.add_signal_handler(signal.SIGALRM, my_handler, *some_args)
523 self.loop.call_later(60, self.loop.stop)
524 self.loop.run_forever()
528 tr, pr = self.loop.run_until_complete(connection_fut)
534 self.loop.run_until_complete(pr.done)
540 conn_fut = self.loop.create_connection(
541 lambda: MyProto(loop=self.loop), *httpd.address)
551 conn_fut = self.loop.create_unix_connection(
552 lambda: MyProto(loop=self.loop), httpd.address)
590 tr, pr = self.loop.run_until_complete(connection_fut)
595 self.loop.run_until_complete(pr.done)
640 self.loop.create_connection,
641 lambda: MyProto(loop=self.loop),
655 self.loop.create_unix_connection,
656 lambda: MyProto(loop=self.loop), httpd.address,
666 f = self.loop.create_connection(
667 lambda: MyProto(loop=self.loop),
669 tr, pr = self.loop.run_until_complete(f)
678 getaddrinfo_orig = self.loop.getaddrinfo
686 self.loop.getaddrinfo = getaddrinfo
688 f = self.loop.create_connection(
689 lambda: MyProto(loop=self.loop),
693 self.loop.run_until_complete(f)
699 getaddrinfo_orig = self.loop.getaddrinfo
706 self.loop.getaddrinfo = getaddrinfo
708 f = self.loop.create_connection(
709 lambda: MyProto(loop=self.loop),
713 self.loop.run_until_complete(f)
717 f = self.loop.create_connection(
718 lambda: MyProto(loop=self.loop),
721 self.loop.run_until_complete(f)
726 loop = self.loop
732 loop.call_soon(loop.stop)
764 proto = MyProto(loop=loop)
765 proto.loop = loop
766 loop.run_until_complete(
767 loop.connect_accepted_socket(
769 loop.run_forever()
789 coro = self.loop.connect_accepted_socket(
794 self.loop.run_until_complete(coro)
805 return self.loop.create_task(getaddrinfo(*args, **kwds))
815 self.loop.getaddrinfo = getaddrinfo_task
816 self.loop._start_serving = mock.Mock()
817 self.loop._stop_serving = mock.Mock()
818 f = self.loop.create_server(lambda: MyProto(self.loop), hosts, 80)
819 server = self.loop.run_until_complete(f)
833 proto = MyProto(self.loop)
834 f = self.loop.create_server(lambda: proto, '0.0.0.0', 0)
835 server = self.loop.run_until_complete(f)
844 self.loop.run_until_complete(proto.connected)
847 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
857 self.loop.run_until_complete(proto.done)
870 proto = MyProto(self.loop)
871 f = self.loop.create_server(
873 server = self.loop.run_until_complete(f)
881 test_utils.run_briefly(self.loop)
883 proto = MyProto(self.loop)
884 f = self.loop.create_server(
886 server = self.loop.run_until_complete(f)
898 f = self.loop.create_unix_server(factory, path, **kwargs)
899 server = self.loop.run_until_complete(f)
905 proto = MyProto(loop=self.loop)
913 self.loop.run_until_complete(proto.connected)
915 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
920 self.loop.run_until_complete(proto.done)
933 proto = MyProto(loop=self.loop)
936 f = self.loop.create_unix_server(lambda: proto, '/test', sock=sock)
940 self.loop.run_until_complete(f)
951 f = self.loop.create_server(factory, '127.0.0.1', 0, ssl=sslcontext)
952 server = self.loop.run_until_complete(f)
965 proto = MyProto(loop=self.loop)
969 f_c = self.loop.create_connection(MyBaseProto, host, port,
971 client, pr = self.loop.run_until_complete(f_c)
974 self.loop.run_until_complete(proto.connected)
977 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
985 self.loop.run_until_complete(proto.done)
998 proto = MyProto(loop=self.loop)
1002 f_c = self.loop.create_unix_connection(
1006 client, pr = self.loop.run_until_complete(f_c)
1009 self.loop.run_until_complete(proto.connected)
1011 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
1016 self.loop.run_until_complete(proto.done)
1028 proto = MyProto(loop=self.loop)
1040 f_c = self.loop.create_connection(MyProto, host, port,
1042 with mock.patch.object(self.loop, 'call_exception_handler'):
1046 self.loop.run_until_complete(f_c)
1048 # execute the loop to log the connection error
1049 test_utils.run_briefly(self.loop)
1058 proto = MyProto(loop=self.loop)
1069 f_c = self.loop.create_unix_connection(MyProto, path,
1072 with mock.patch.object(self.loop, 'call_exception_handler'):
1076 self.loop.run_until_complete(f_c)
1078 # execute the loop to log the connection error
1079 test_utils.run_briefly(self.loop)
1087 proto = MyProto(loop=self.loop)
1100 f_c = self.loop.create_connection(MyProto, host, port,
1102 with mock.patch.object(self.loop, 'call_exception_handler'):
1108 self.loop.run_until_complete(f_c)
1118 proto = MyProto(loop=self.loop)
1130 f_c = self.loop.create_unix_connection(MyProto, path,
1133 client, pr = self.loop.run_until_complete(f_c)
1134 self.loop.run_until_complete(proto.connected)
1140 self.loop.run_until_complete(proto.done)
1144 proto = MyProto(loop=self.loop)
1156 f_c = self.loop.create_connection(MyProto, host, port,
1159 client, pr = self.loop.run_until_complete(f_c)
1160 self.loop.run_until_complete(proto.connected)
1170 self.loop.run_until_complete(proto.done)
1173 proto = self.loop.create_future()
1182 f = self.loop.create_server(TestMyProto, sock=sock_ob)
1183 server = self.loop.run_until_complete(f)
1198 f = self.loop.create_server(MyProto, sock=sock_ob)
1199 server = self.loop.run_until_complete(f)
1203 f = self.loop.create_server(MyProto, host=host, port=port)
1205 self.loop.run_until_complete(f)
1212 f_proto = self.loop.create_future()
1223 f = self.loop.create_server(TestMyProto, host=None, port=port)
1224 server = self.loop.run_until_complete(f)
1237 proto = self.loop.run_until_complete(f_proto)
1241 f_proto = self.loop.create_future()
1245 proto = self.loop.run_until_complete(f_proto)
1252 f = self.loop.create_server(MyProto, '0.0.0.0', 0)
1253 server = self.loop.run_until_complete(f)
1272 super().__init__(loop=self.loop)
1278 coro = self.loop.create_datagram_endpoint(
1280 s_transport, server = self.loop.run_until_complete(coro)
1290 coro = self.loop.create_datagram_endpoint(
1291 lambda: MyDatagramProto(loop=self.loop),
1293 transport, client = self.loop.run_until_complete(coro)
1301 test_utils.run_until(self.loop, lambda: server.nbytes)
1303 test_utils.run_until(self.loop, lambda: client.nbytes)
1313 self.loop.run_until_complete(client.done)
1327 infos = self.loop.run_until_complete(
1328 self.loop.getaddrinfo(
1342 f = self.loop.create_datagram_endpoint(
1343 lambda: MyDatagramProto(loop=self.loop), sock=sock)
1344 tr, pr = self.loop.run_until_complete(f)
1348 self.loop.run_until_complete(pr.done)
1351 loop = self.create_event_loop()
1352 if not isinstance(loop, selector_events.BaseSelectorEventLoop):
1353 loop.close()
1354 self.skipTest('loop is not a BaseSelectorEventLoop')
1356 self.assertEqual(1, loop._internal_fds)
1357 loop.close()
1358 self.assertEqual(0, loop._internal_fds)
1359 self.assertIsNone(loop._csock)
1360 self.assertIsNone(loop._ssock)
1365 proto = MyReadPipeProto(loop=self.loop)
1371 t, p = await self.loop.connect_read_pipe(
1378 self.loop.run_until_complete(connect())
1381 test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
1385 test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
1390 self.loop.run_until_complete(proto.done)
1400 loop = self.create_event_loop()
1401 read_proto = MyReadPipeProto(loop=loop)
1402 write_proto = MyWritePipeProto(loop=loop)
1409 read_transport, _ = await loop.connect_read_pipe(
1411 write_transport, _ = await loop.connect_write_pipe(
1415 # Run and close the loop without closing the transports
1416 read_transport, write_transport = loop.run_until_complete(connect())
1417 loop.close()
1434 proto = MyReadPipeProto(loop=self.loop)
1440 t, p = await self.loop.connect_read_pipe(lambda: proto,
1447 self.loop.run_until_complete(connect())
1450 test_utils.run_until(self.loop, lambda: proto.nbytes)
1454 test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
1460 self.loop.run_until_complete(proto.done)
1472 proto = MyWritePipeProto(loop=self.loop)
1473 connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
1474 transport, p = self.loop.run_until_complete(connect)
1487 test_utils.run_until(self.loop, lambda: reader(data) >= 1)
1491 test_utils.run_until(self.loop, lambda: reader(data) >= 5)
1502 self.loop.run_until_complete(proto.done)
1512 proto = MyWritePipeProto(loop=self.loop)
1513 connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
1514 transport, p = self.loop.run_until_complete(connect)
1520 data = self.loop.run_until_complete(self.loop.sock_recv(rsock, 1024))
1525 self.loop.run_until_complete(proto.done)
1538 proto = MyWritePipeProto(loop=self.loop)
1539 connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
1540 transport, p = self.loop.run_until_complete(connect)
1553 test_utils.run_until(self.loop, lambda: reader(data) >= 1,
1558 test_utils.run_until(self.loop, lambda: reader(data) >= 5,
1570 self.loop.run_until_complete(proto.done)
1585 read_proto = MyReadPipeProto(loop=self.loop)
1586 read_connect = self.loop.connect_read_pipe(lambda: read_proto,
1588 read_transport, p = self.loop.run_until_complete(read_connect)
1596 write_proto = MyWritePipeProto(loop=self.loop)
1597 write_connect = self.loop.connect_write_pipe(lambda: write_proto,
1599 write_transport, p = self.loop.run_until_complete(write_connect)
1611 test_utils.run_until(self.loop, lambda: reader(data) >= 1,
1618 test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 1,
1625 test_utils.run_until(self.loop, lambda: reader(data) >= 5,
1632 test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 5,
1641 self.loop.run_until_complete(read_proto.done)
1646 self.loop.run_until_complete(write_proto.done)
1652 f = self.loop.create_task(self.loop.sock_recv(r, 1))
1659 self.loop.call_soon(f.cancel)
1666 self.loop.stop()
1670 t = self.loop.create_task(main())
1671 self.loop.run_forever()
1679 self.loop._stop_serving(r)
1686 self.loop._run_once_counter += 1
1689 orig_run_once = self.loop._run_once
1690 self.loop._run_once_counter = 0
1691 self.loop._run_once = _run_once
1694 loop = self.loop
1701 self.loop.run_until_complete(wait())
1706 self.assertLessEqual(self.loop._run_once_counter, 20,
1707 {'clock_resolution': self.loop._clock_resolution,
1708 'selector': self.loop._selector.__class__.__name__})
1711 loop = self.create_event_loop()
1716 loop.add_reader(r, callback)
1717 loop.add_writer(w, callback)
1718 loop.close()
1719 self.assertFalse(loop.remove_reader(r))
1720 self.assertFalse(loop.remove_writer(w))
1723 loop = self.create_event_loop()
1728 loop.close()
1730 loop.add_reader(r, callback)
1732 loop.add_writer(w, callback)
1735 async def close_loop(loop):
1736 self.loop.close()
1738 coro = close_loop(self.loop)
1740 self.loop.run_until_complete(coro)
1743 self.loop.close()
1752 # operation blocked when the loop is closed
1754 self.loop.run_forever()
1756 fut = self.loop.create_future()
1757 self.loop.run_until_complete(fut)
1759 self.loop.call_soon(func)
1761 self.loop.call_soon_threadsafe(func)
1763 self.loop.call_later(1.0, func)
1765 self.loop.call_at(self.loop.time() + .0, func)
1767 self.loop.create_task(coro)
1769 self.loop.add_signal_handler(signal.SIGTERM, func)
1772 # but run_until_complete cannot be called on closed loop.
1775 it = self.loop.run_in_executor(None, func).__await__()
1798 connect = self.loop.subprocess_exec(
1799 functools.partial(MySubprocessProtocol, self.loop),
1802 transp, proto = self.loop.run_until_complete(connect)
1804 self.loop.run_until_complete(proto.connected)
1809 self.loop.run_until_complete(proto.got_data[1].wait())
1812 self.loop.run_until_complete(proto.completed)
1819 connect = self.loop.subprocess_exec(
1820 functools.partial(MySubprocessProtocol, self.loop),
1823 transp, proto = self.loop.run_until_complete(connect)
1825 self.loop.run_until_complete(proto.connected)
1830 self.loop.run_until_complete(proto.got_data[1].wait())
1835 self.loop.run_until_complete(proto.got_data[1].wait())
1840 self.loop.run_until_complete(proto.completed)
1844 connect = self.loop.subprocess_shell(
1845 functools.partial(MySubprocessProtocol, self.loop),
1847 transp, proto = self.loop.run_until_complete(connect)
1849 self.loop.run_until_complete(proto.connected)
1852 self.loop.run_until_complete(proto.completed)
1860 connect = self.loop.subprocess_shell(
1861 functools.partial(MySubprocessProtocol, self.loop),
1864 transp, proto = self.loop.run_until_complete(connect)
1866 self.loop.run_until_complete(proto.completed)
1871 connect = self.loop.subprocess_shell(
1872 functools.partial(MySubprocessProtocol, self.loop),
1875 transp, proto = self.loop.run_until_complete(connect)
1880 self.loop.run_until_complete(proto.completed)
1887 connect = self.loop.subprocess_exec(
1888 functools.partial(MySubprocessProtocol, self.loop),
1891 transp, proto = self.loop.run_until_complete(connect)
1893 self.loop.run_until_complete(proto.connected)
1896 self.loop.run_until_complete(proto.completed)
1903 connect = self.loop.subprocess_exec(
1904 functools.partial(MySubprocessProtocol, self.loop),
1907 transp, proto = self.loop.run_until_complete(connect)
1909 self.loop.run_until_complete(proto.connected)
1912 self.loop.run_until_complete(proto.completed)
1925 connect = self.loop.subprocess_exec(
1926 functools.partial(MySubprocessProtocol, self.loop),
1930 transp, proto = self.loop.run_until_complete(connect)
1932 self.loop.run_until_complete(proto.connected)
1935 self.loop.run_until_complete(proto.completed)
1944 connect = self.loop.subprocess_exec(
1945 functools.partial(MySubprocessProtocol, self.loop),
1948 transp, proto = self.loop.run_until_complete(connect)
1950 self.loop.run_until_complete(proto.connected)
1955 self.loop.run_until_complete(proto.completed)
1965 connect = self.loop.subprocess_exec(
1966 functools.partial(MySubprocessProtocol, self.loop),
1970 transp, proto = self.loop.run_until_complete(connect)
1972 self.loop.run_until_complete(proto.connected)
1979 self.loop.run_until_complete(proto.completed)
1990 connect = self.loop.subprocess_exec(
1991 functools.partial(MySubprocessProtocol, self.loop),
1994 transp, proto = self.loop.run_until_complete(connect)
1996 self.loop.run_until_complete(proto.connected)
2001 self.loop.run_until_complete(proto.got_data[1].wait())
2005 self.loop.run_until_complete(proto.disconnects[1])
2007 self.loop.run_until_complete(proto.got_data[2].wait())
2018 self.loop.run_until_complete(proto.completed)
2023 connect = self.loop.subprocess_shell(
2024 functools.partial(MySubprocessProtocol, self.loop),
2027 transp, proto = self.loop.run_until_complete(connect)
2029 self.loop.run_until_complete(proto.completed)
2035 await self.loop.subprocess_exec(
2040 self.loop.run_until_complete(connect(universal_newlines=True))
2042 self.loop.run_until_complete(connect(bufsize=4096))
2044 self.loop.run_until_complete(connect(shell=True))
2051 await self.loop.subprocess_shell(
2056 self.loop.run_until_complete(connect(['ls', '-l']))
2058 self.loop.run_until_complete(connect(universal_newlines=True))
2060 self.loop.run_until_complete(connect(bufsize=4096))
2062 self.loop.run_until_complete(connect(shell=False))
2101 watcher.attach_loop(self.loop)
2167 self.loop = mock.Mock()
2168 self.loop.get_debug.return_value = True
2175 h = asyncio.Handle(callback, args, self.loop)
2187 self.loop = mock.Mock()
2188 self.loop.call_exception_handler = mock.Mock()
2190 h = asyncio.Handle(callback, (), self.loop)
2193 self.loop.call_exception_handler.assert_called_with({
2202 h = asyncio.Handle(lambda: None, (), self.loop)
2206 self.loop.get_debug.return_value = False
2209 h = asyncio.Handle(noop, (1, 2), self.loop)
2222 h = asyncio.Handle(cb, (), self.loop)
2229 h = asyncio.Handle(cb, (3,), self.loop)
2236 h = asyncio.Handle(cb, (2, 3), self.loop)
2245 h = asyncio.Handle(cb, (), self.loop)
2253 self.loop.get_debug.return_value = True
2258 h = asyncio.Handle(noop, (1, 2), self.loop)
2279 loop = asyncio.get_event_loop_policy().new_event_loop()
2280 loop.set_debug(True)
2281 self.set_event_loop(loop)
2292 h = loop.call_soon(noop)
2296 h = loop.call_soon_threadsafe(noop)
2300 h = loop.call_later(0, noop)
2304 h = loop.call_later(0, noop)
2345 self.loop = mock.Mock()
2378 self.loop.get_debug.return_value = False
2381 h = asyncio.TimerHandle(123, noop, (), self.loop)
2392 self.loop.get_debug.return_value = True
2397 h = asyncio.TimerHandle(123, noop, (), self.loop)
2418 h1 = asyncio.TimerHandle(when, callback, (), self.loop)
2419 h2 = asyncio.TimerHandle(when, callback, (), self.loop)
2435 h1 = asyncio.TimerHandle(when, callback, (), self.loop)
2436 h2 = asyncio.TimerHandle(when + 10.0, callback, (), self.loop)
2448 h3 = asyncio.Handle(callback, (), self.loop)
2479 loop = asyncio.AbstractEventLoop()
2481 NotImplementedError, loop.run_forever)
2483 NotImplementedError, loop.run_until_complete, None)
2485 NotImplementedError, loop.stop)
2487 NotImplementedError, loop.is_running)
2489 NotImplementedError, loop.is_closed)
2491 NotImplementedError, loop.close)
2493 NotImplementedError, loop.create_task, None)
2495 NotImplementedError, loop.call_later, None, None)
2497 NotImplementedError, loop.call_at, f, f)
2499 NotImplementedError, loop.call_soon, None)
2501 NotImplementedError, loop.time)
2503 NotImplementedError, loop.call_soon_threadsafe, None)
2505 NotImplementedError, loop.set_default_executor, f)
2507 NotImplementedError, loop.add_reader, 1, f)
2509 NotImplementedError, loop.remove_reader, 1)
2511 NotImplementedError, loop.add_writer, 1, f)
2513 NotImplementedError, loop.remove_writer, 1)
2515 NotImplementedError, loop.add_signal_handler, 1, f)
2517 NotImplementedError, loop.remove_signal_handler, 1)
2519 NotImplementedError, loop.remove_signal_handler, 1)
2521 NotImplementedError, loop.set_exception_handler, f)
2523 NotImplementedError, loop.default_exception_handler, f)
2525 NotImplementedError, loop.call_exception_handler, f)
2527 NotImplementedError, loop.get_debug)
2529 NotImplementedError, loop.set_debug, f)
2535 loop = asyncio.AbstractEventLoop()
2538 await loop.run_in_executor(f, f)
2540 await loop.getaddrinfo('localhost', 8080)
2542 await loop.getnameinfo(('localhost', 8080))
2544 await loop.create_connection(f)
2546 await loop.create_server(f)
2548 await loop.create_datagram_endpoint(f)
2550 await loop.sock_recv(f, 10)
2552 await loop.sock_recv_into(f, 10)
2554 await loop.sock_sendall(f, 10)
2556 await loop.sock_connect(f, f)
2558 await loop.sock_accept(f)
2560 await loop.sock_sendfile(f, f)
2562 await loop.sendfile(f, f)
2564 await loop.connect_read_pipe(f, mock.sentinel.pipe)
2566 await loop.connect_write_pipe(f, mock.sentinel.pipe)
2568 await loop.subprocess_shell(f, mock.sentinel)
2570 await loop.subprocess_exec(f)
2572 loop = asyncio.new_event_loop()
2573 loop.run_until_complete(inner())
2574 loop.close()
2591 loop = policy.get_event_loop()
2592 self.assertIsInstance(loop, asyncio.AbstractEventLoop)
2594 self.assertIs(policy._local._loop, loop)
2595 self.assertIs(loop, policy.get_event_loop())
2596 loop.close()
2605 loop = policy.get_event_loop()
2606 self.addCleanup(loop.close)
2611 m_set_event_loop.assert_called_with(loop)
2613 loop.close()
2634 loop = policy.new_event_loop()
2635 self.assertIsInstance(loop, asyncio.AbstractEventLoop)
2636 loop.close()
2645 loop = policy.new_event_loop()
2646 policy.set_event_loop(loop)
2647 self.assertIs(loop, policy.get_event_loop())
2649 loop.close()
2694 self.loop = asyncio.new_event_loop()
2695 asyncio.set_event_loop(self.loop)
2699 watcher.attach_loop(self.loop)
2709 self.loop.close()
2732 result = await self.loop.run_in_executor(
2738 self.loop.run_until_complete(main()),
2752 loop = asyncio.new_event_loop()
2765 self.assertIs(asyncio.get_event_loop(), loop)
2766 self.assertIs(asyncio.get_running_loop(), loop)
2767 self.assertIs(asyncio._get_running_loop(), loop)
2769 loop.run_until_complete(func())
2771 asyncio.set_event_loop(loop)
2780 if loop is not None:
2781 loop.close()
2792 loop = asyncio.new_event_loop()
2793 self.addCleanup(loop.close)
2806 self.assertIs(asyncio.get_event_loop(), loop)
2807 self.assertIs(asyncio.get_running_loop(), loop)
2808 self.assertIs(asyncio._get_running_loop(), loop)
2810 loop.run_until_complete(func())
2812 asyncio.set_event_loop(loop)
2813 self.assertIs(asyncio.get_event_loop(), loop)
2821 if loop is not None:
2822 loop.close()
2855 loop = asyncio.new_event_loop()
2856 self.addCleanup(loop.close)
2857 proto = MyProto(loop)
2858 server = loop.run_until_complete(loop.create_server(lambda: proto, '0.0.0.0', 0))
2859 self.assertEqual(server.get_loop(), loop)
2861 loop.run_until_complete(server.wait_closed())
2871 loop = asyncio.new_event_loop()
2872 self.addCleanup(loop.close)
2875 loop.run_until_complete(events.AbstractServer().wait_closed())