Lines Matching refs:self
66 def send(self, v):
69 def throw(self, *exc):
72 def close(self):
75 def __await__(self):
83 def __init__(self, loop=None):
84 self.transport = None
85 self.state = 'INITIAL'
86 self.nbytes = 0
88 self.connected = loop.create_future()
89 self.done = loop.create_future()
91 def _assert_state(self, *expected):
92 if self.state not in expected:
93 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
95 def connection_made(self, transport):
96 self.transport = transport
97 self._assert_state('INITIAL')
98 self.state = 'CONNECTED'
99 if self.connected:
100 self.connected.set_result(None)
102 def data_received(self, data):
103 self._assert_state('CONNECTED')
104 self.nbytes += len(data)
106 def eof_received(self):
107 self._assert_state('CONNECTED')
108 self.state = 'EOF'
110 def connection_lost(self, exc):
111 self._assert_state('CONNECTED', 'EOF')
112 self.state = 'CLOSED'
113 if self.done:
114 self.done.set_result(None)
118 def connection_made(self, transport):
126 def __init__(self, loop=None):
127 self.state = 'INITIAL'
128 self.nbytes = 0
130 self.done = loop.create_future()
132 def _assert_state(self, expected):
133 if self.state != expected:
134 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
136 def connection_made(self, transport):
137 self.transport = transport
138 self._assert_state('INITIAL')
139 self.state = 'INITIALIZED'
141 def datagram_received(self, data, addr):
142 self._assert_state('INITIALIZED')
143 self.nbytes += len(data)
145 def error_received(self, exc):
146 self._assert_state('INITIALIZED')
148 def connection_lost(self, exc):
149 self._assert_state('INITIALIZED')
150 self.state = 'CLOSED'
151 if self.done:
152 self.done.set_result(None)
158 def __init__(self, loop=None):
159 self.state = ['INITIAL']
160 self.nbytes = 0
161 self.transport = None
163 self.done = loop.create_future()
165 def _assert_state(self, expected):
166 if self.state != expected:
167 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
169 def connection_made(self, transport):
170 self.transport = transport
171 self._assert_state(['INITIAL'])
172 self.state.append('CONNECTED')
174 def data_received(self, data):
175 self._assert_state(['INITIAL', 'CONNECTED'])
176 self.nbytes += len(data)
178 def eof_received(self):
179 self._assert_state(['INITIAL', 'CONNECTED'])
180 self.state.append('EOF')
182 def connection_lost(self, exc):
183 if 'EOF' not in self.state:
184 self.state.append('EOF') # It is okay if EOF is missed.
185 self._assert_state(['INITIAL', 'CONNECTED', 'EOF'])
186 self.state.append('CLOSED')
187 if self.done:
188 self.done.set_result(None)
194 def __init__(self, loop=None):
195 self.state = 'INITIAL'
196 self.transport = None
198 self.done = loop.create_future()
200 def _assert_state(self, expected):
201 if self.state != expected:
202 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
204 def connection_made(self, transport):
205 self.transport = transport
206 self._assert_state('INITIAL')
207 self.state = 'CONNECTED'
209 def connection_lost(self, exc):
210 self._assert_state('CONNECTED')
211 self.state = 'CLOSED'
212 if self.done:
213 self.done.set_result(None)
218 def __init__(self, loop):
219 self.state = 'INITIAL'
220 self.transport = None
221 self.connected = loop.create_future()
222 self.completed = loop.create_future()
223 self.disconnects = {fd: loop.create_future() for fd in range(3)}
224 self.data = {1: b'', 2: b''}
225 self.returncode = None
226 self.got_data = {1: asyncio.Event(),
229 def _assert_state(self, expected):
230 if self.state != expected:
231 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
233 def connection_made(self, transport):
234 self.transport = transport
235 self._assert_state('INITIAL')
236 self.state = 'CONNECTED'
237 self.connected.set_result(None)
239 def connection_lost(self, exc):
240 self._assert_state('CONNECTED')
241 self.state = 'CLOSED'
242 self.completed.set_result(None)
244 def pipe_data_received(self, fd, data):
245 self._assert_state('CONNECTED')
246 self.data[fd] += data
247 self.got_data[fd].set()
249 def pipe_connection_lost(self, fd, exc):
250 self._assert_state('CONNECTED')
252 self.disconnects[fd].set_exception(exc)
254 self.disconnects[fd].set_result(exc)
256 def process_exited(self):
257 self._assert_state('CONNECTED')
258 self.returncode = self.transport.get_returncode()
263 def setUp(self):
265 self.loop = self.create_event_loop()
266 self.set_event_loop(self.loop)
268 def tearDown(self):
270 if not self.loop.is_closed():
271 test_utils.run_briefly(self.loop)
273 self.doCleanups()
277 def test_run_until_complete_nesting(self):
282 self.assertTrue(self.loop.is_running())
283 self.loop.run_until_complete(coro1())
285 with self.assertWarnsRegex(
289 self.assertRaises(
290 RuntimeError, self.loop.run_until_complete, coro2())
295 def test_run_until_complete(self):
296 t0 = self.loop.time()
297 self.loop.run_until_complete(asyncio.sleep(0.1))
298 t1 = self.loop.time()
299 self.assertTrue(0.08 <= t1-t0 <= 0.8, t1-t0)
301 def test_run_until_complete_stopped(self):
304 self.loop.stop()
307 self.assertRaises(RuntimeError,
308 self.loop.run_until_complete, task)
310 def test_call_later(self):
315 self.loop.stop()
317 self.loop.call_later(0.1, callback, 'hello world')
318 self.loop.run_forever()
319 self.assertEqual(results, ['hello world'])
321 def test_call_soon(self):
326 self.loop.stop()
328 self.loop.call_soon(callback, 'hello', 'world')
329 self.loop.run_forever()
330 self.assertEqual(results, [('hello', 'world')])
332 def test_call_soon_threadsafe(self):
339 self.loop.stop()
342 self.loop.call_soon_threadsafe(callback, 'hello')
350 self.loop.call_soon(callback, 'world')
351 self.loop.run_forever()
353 self.assertEqual(results, ['hello', 'world'])
355 def test_call_soon_threadsafe_same_thread(self):
361 self.loop.stop()
363 self.loop.call_soon_threadsafe(callback, 'hello')
364 self.loop.call_soon(callback, 'world')
365 self.loop.run_forever()
366 self.assertEqual(results, ['hello', 'world'])
368 def test_run_in_executor(self):
371 f2 = self.loop.run_in_executor(None, run, 'yo')
372 res, thread_id = self.loop.run_until_complete(f2)
373 self.assertEqual(res, 'yo')
374 self.assertNotEqual(thread_id, threading.get_ident())
376 def test_run_in_executor_cancel(self):
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
394 self.assertFalse(called)
396 def test_reader_callback(self):
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()
422 self.assertEqual(bytes_read, b'abcdef')
424 def test_writer_callback(self):
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()))
442 self.assertEqual(read, data)
445 def test_add_signal_handler(self):
453 self.assertRaises(
454 TypeError, self.loop.add_signal_handler, 'boom', my_handler)
455 self.assertRaises(
456 TypeError, self.loop.remove_signal_handler, 'boom')
457 self.assertRaises(
458 ValueError, self.loop.add_signal_handler, signal.NSIG+1,
460 self.assertRaises(
461 ValueError, self.loop.remove_signal_handler, signal.NSIG+1)
462 self.assertRaises(
463 ValueError, self.loop.add_signal_handler, 0, my_handler)
464 self.assertRaises(
465 ValueError, self.loop.remove_signal_handler, 0)
466 self.assertRaises(
467 ValueError, self.loop.add_signal_handler, -1, my_handler)
468 self.assertRaises(
469 ValueError, self.loop.remove_signal_handler, -1)
470 self.assertRaises(
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))
483 self.assertEqual(signal.getsignal(signal.SIGINT),
486 self.assertFalse(self.loop.remove_signal_handler(signal.SIGINT))
491 def test_signal_handling_while_selecting(self):
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()
505 self.assertEqual(caught, 1)
510 def test_signal_handling_args(self):
517 self.assertEqual(args, some_args)
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()
525 self.assertEqual(caught, 1)
527 def _basetest_create_connection(self, connection_fut, check_sockname=True):
528 tr, pr = self.loop.run_until_complete(connection_fut)
529 self.assertIsInstance(tr, asyncio.Transport)
530 self.assertIsInstance(pr, asyncio.Protocol)
531 self.assertIs(pr.transport, tr)
533 self.assertIsNotNone(tr.get_extra_info('sockname'))
534 self.loop.run_until_complete(pr.done)
535 self.assertGreater(pr.nbytes, 0)
538 def test_create_connection(self):
540 conn_fut = self.loop.create_connection(
541 lambda: MyProto(loop=self.loop), *httpd.address)
542 self._basetest_create_connection(conn_fut)
545 def test_create_unix_connection(self):
551 conn_fut = self.loop.create_unix_connection(
552 lambda: MyProto(loop=self.loop), httpd.address)
553 self._basetest_create_connection(conn_fut, check_sockname)
555 def check_ssl_extra_info(self, client, check_sockname=True,
558 self.assertIsNotNone(client.get_extra_info('sockname'))
560 self.assertEqual(peername,
563 self.assertIsNotNone(client.get_extra_info('peername'))
564 self.assertEqual(peercert,
569 self.assertIsInstance(cipher, tuple)
570 self.assertEqual(len(cipher), 3, cipher)
571 self.assertIsInstance(cipher[0], str)
572 self.assertIsInstance(cipher[1], str)
573 self.assertIsInstance(cipher[2], int)
577 self.assertIsNotNone(sslobj)
578 self.assertEqual(sslobj.compression(),
580 self.assertEqual(sslobj.cipher(),
582 self.assertEqual(sslobj.getpeercert(),
584 self.assertEqual(sslobj.compression(),
587 def _basetest_create_ssl_connection(self, connection_fut,
590 tr, pr = self.loop.run_until_complete(connection_fut)
591 self.assertIsInstance(tr, asyncio.Transport)
592 self.assertIsInstance(pr, asyncio.Protocol)
593 self.assertTrue('ssl' in tr.__class__.__name__.lower())
594 self.check_ssl_extra_info(tr, check_sockname, peername)
595 self.loop.run_until_complete(pr.done)
596 self.assertGreater(pr.nbytes, 0)
599 def _test_create_ssl_connection(self, httpd, create_connection,
602 self._basetest_create_ssl_connection(conn_fut, check_sockname,
614 self.assertEqual(purpose, ssl.Purpose.SERVER_AUTH)
621 self._basetest_create_ssl_connection(conn_fut, check_sockname,
623 self.assertEqual(m.call_count, 1)
627 with self.assertRaises(ssl.SSLError) as cm:
631 self._basetest_create_ssl_connection(conn_fut, check_sockname,
634 self.assertEqual(cm.exception.reason, 'CERTIFICATE_VERIFY_FAILED')
637 def test_create_ssl_connection(self):
640 self.loop.create_connection,
641 lambda: MyProto(loop=self.loop),
643 self._test_create_ssl_connection(httpd, create_connection,
648 def test_create_ssl_unix_connection(self):
655 self.loop.create_unix_connection,
656 lambda: MyProto(loop=self.loop), httpd.address,
659 self._test_create_ssl_connection(httpd, create_connection,
663 def test_create_connection_local_addr(self):
666 f = self.loop.create_connection(
667 lambda: MyProto(loop=self.loop),
669 tr, pr = self.loop.run_until_complete(f)
671 self.assertEqual(port, expected)
674 def test_create_connection_local_addr_skip_different_family(self):
678 getaddrinfo_orig = self.loop.getaddrinfo
686 self.loop.getaddrinfo = getaddrinfo
688 f = self.loop.create_connection(
689 lambda: MyProto(loop=self.loop),
692 with self.assertRaises(OSError):
693 self.loop.run_until_complete(f)
695 def test_create_connection_local_addr_nomatch_family(self):
699 getaddrinfo_orig = self.loop.getaddrinfo
706 self.loop.getaddrinfo = getaddrinfo
708 f = self.loop.create_connection(
709 lambda: MyProto(loop=self.loop),
712 with self.assertRaises(OSError):
713 self.loop.run_until_complete(f)
715 def test_create_connection_local_addr_in_use(self):
717 f = self.loop.create_connection(
718 lambda: MyProto(loop=self.loop),
720 with self.assertRaises(OSError) as cm:
721 self.loop.run_until_complete(f)
722 self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
723 self.assertIn(str(httpd.address), cm.exception.strerror)
725 def test_connect_accepted_socket(self, server_ssl=None, client_ssl=None):
726 loop = self.loop
730 def connection_lost(self, exc):
734 def data_received(self, data):
736 self.transport.write(expected_response)
774 self.assertFalse(thread.is_alive())
775 self.assertEqual(proto.state, 'CLOSED')
776 self.assertEqual(proto.nbytes, len(message))
777 self.assertEqual(response, expected_response)
780 def test_ssl_connect_accepted_socket(self):
784 self.test_connect_accepted_socket(server_context, client_context)
786 def test_connect_accepted_socket_ssl_timeout_for_plain_socket(self):
788 self.addCleanup(sock.close)
789 coro = self.loop.connect_accepted_socket(
791 with self.assertRaisesRegex(
794 self.loop.run_until_complete(coro)
797 def create_server_multiple_hosts(self, family, hosts, mock_sock):
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)
820 self.addCleanup(server.close)
822 self.assertEqual(server_hosts, unique_hosts)
824 def test_create_server_multiple_hosts_ipv4(self):
825 self.create_server_multiple_hosts(socket.AF_INET,
828 def test_create_server_multiple_hosts_ipv6(self):
829 self.create_server_multiple_hosts(socket.AF_INET6,
832 def test_create_server(self):
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)
836 self.assertEqual(len(server.sockets), 1)
839 self.assertEqual(host, '0.0.0.0')
844 self.loop.run_until_complete(proto.connected)
845 self.assertEqual('CONNECTED', proto.state)
847 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
848 self.assertEqual(3, proto.nbytes)
851 self.assertIsNotNone(proto.transport.get_extra_info('sockname'))
852 self.assertEqual('127.0.0.1',
857 self.loop.run_until_complete(proto.done)
859 self.assertEqual('CLOSED', proto.state)
869 def test_create_server_reuse_port(self):
870 proto = MyProto(self.loop)
871 f = self.loop.create_server(
873 server = self.loop.run_until_complete(f)
874 self.assertEqual(len(server.sockets), 1)
876 self.assertFalse(
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)
887 self.assertEqual(len(server.sockets), 1)
889 self.assertTrue(
894 def _make_unix_server(self, factory, **kwargs):
896 self.addCleanup(lambda: os.path.exists(path) and os.unlink(path))
898 f = self.loop.create_unix_server(factory, path, **kwargs)
899 server = self.loop.run_until_complete(f)
904 def test_create_unix_server(self):
905 proto = MyProto(loop=self.loop)
906 server, path = self._make_unix_server(lambda: proto)
907 self.assertEqual(len(server.sockets), 1)
913 self.loop.run_until_complete(proto.connected)
914 self.assertEqual('CONNECTED', proto.state)
915 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
916 self.assertEqual(3, proto.nbytes)
920 self.loop.run_until_complete(proto.done)
922 self.assertEqual('CLOSED', proto.state)
932 def test_create_unix_server_path_socket_error(self):
933 proto = MyProto(loop=self.loop)
936 f = self.loop.create_unix_server(lambda: proto, '/test', sock=sock)
937 with self.assertRaisesRegex(ValueError,
940 self.loop.run_until_complete(f)
942 def _create_ssl_context(self, certfile, keyfile=None):
948 def _make_ssl_server(self, factory, certfile, keyfile=None):
949 sslcontext = self._create_ssl_context(certfile, keyfile)
951 f = self.loop.create_server(factory, '127.0.0.1', 0, ssl=sslcontext)
952 server = self.loop.run_until_complete(f)
956 self.assertEqual(host, '127.0.0.1')
959 def _make_ssl_unix_server(self, factory, certfile, keyfile=None):
960 sslcontext = self._create_ssl_context(certfile, keyfile)
961 return self._make_unix_server(factory, ssl=sslcontext)
964 def test_create_server_ssl(self):
965 proto = MyProto(loop=self.loop)
966 server, host, port = self._make_ssl_server(
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)
975 self.assertEqual('CONNECTED', proto.state)
977 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
978 self.assertEqual(3, proto.nbytes)
981 self.check_ssl_extra_info(client, peername=(host, port))
985 self.loop.run_until_complete(proto.done)
986 self.assertEqual('CLOSED', proto.state)
997 def test_create_unix_server_ssl(self):
998 proto = MyProto(loop=self.loop)
999 server, path = self._make_ssl_unix_server(
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)
1010 self.assertEqual('CONNECTED', proto.state)
1011 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
1012 self.assertEqual(3, proto.nbytes)
1016 self.loop.run_until_complete(proto.done)
1017 self.assertEqual('CLOSED', proto.state)
1027 def test_create_server_ssl_verify_failed(self):
1028 proto = MyProto(loop=self.loop)
1029 server, host, port = self._make_ssl_server(
1040 f_c = self.loop.create_connection(MyProto, host, port,
1042 with mock.patch.object(self.loop, 'call_exception_handler'):
1044 with self.assertRaisesRegex(ssl.SSLError,
1046 self.loop.run_until_complete(f_c)
1049 test_utils.run_briefly(self.loop)
1052 self.assertIsNone(proto.transport)
1057 def test_create_unix_server_ssl_verify_failed(self):
1058 proto = MyProto(loop=self.loop)
1059 server, path = self._make_ssl_unix_server(
1069 f_c = self.loop.create_unix_connection(MyProto, path,
1072 with mock.patch.object(self.loop, 'call_exception_handler'):
1074 with self.assertRaisesRegex(ssl.SSLError,
1076 self.loop.run_until_complete(f_c)
1079 test_utils.run_briefly(self.loop)
1082 self.assertIsNone(proto.transport)
1086 def test_create_server_ssl_match_failed(self):
1087 proto = MyProto(loop=self.loop)
1088 server, host, port = self._make_ssl_server(
1100 f_c = self.loop.create_connection(MyProto, host, port,
1102 with mock.patch.object(self.loop, 'call_exception_handler'):
1104 with self.assertRaisesRegex(
1108 self.loop.run_until_complete(f_c)
1112 self.assertIsNone(proto.transport)
1117 def test_create_unix_server_ssl_verified(self):
1118 proto = MyProto(loop=self.loop)
1119 server, path = self._make_ssl_unix_server(
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)
1143 def test_create_server_ssl_verified(self):
1144 proto = MyProto(loop=self.loop)
1145 server, host, port = self._make_ssl_server(
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)
1163 self.check_ssl_extra_info(client, peername=(host, port),
1170 self.loop.run_until_complete(proto.done)
1172 def test_create_server_sock(self):
1173 proto = self.loop.create_future()
1176 def connection_made(self, transport):
1178 proto.set_result(self)
1182 f = self.loop.create_server(TestMyProto, sock=sock_ob)
1183 server = self.loop.run_until_complete(f)
1185 self.assertEqual(sock.fileno(), sock_ob.fileno())
1188 self.assertEqual(host, '0.0.0.0')
1195 def test_create_server_addr_in_use(self):
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)
1204 with self.assertRaises(OSError) as cm:
1205 self.loop.run_until_complete(f)
1206 self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
1211 def test_create_server_dual_stack(self):
1212 f_proto = self.loop.create_future()
1215 def connection_made(self, transport):
1217 f_proto.set_result(self)
1223 f = self.loop.create_server(TestMyProto, host=None, port=port)
1224 server = self.loop.run_until_complete(f)
1228 self.assertGreaterEqual(5, try_count)
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)
1251 def test_server_close(self):
1252 f = self.loop.create_server(MyProto, '0.0.0.0', 0)
1253 server = self.loop.run_until_complete(f)
1265 self.assertRaises(
1269 def _test_create_datagram_endpoint(self, local_addr, family):
1272 super().__init__(loop=self.loop)
1274 def datagram_received(self, data, addr):
1276 self.transport.sendto(b'resp:'+data, addr)
1278 coro = self.loop.create_datagram_endpoint(
1280 s_transport, server = self.loop.run_until_complete(coro)
1285 self.assertIsInstance(s_transport, asyncio.Transport)
1286 self.assertIsInstance(server, TestMyDatagramProto)
1287 self.assertEqual('INITIALIZED', server.state)
1288 self.assertIs(server.transport, s_transport)
1290 coro = self.loop.create_datagram_endpoint(
1291 lambda: MyDatagramProto(loop=self.loop),
1293 transport, client = self.loop.run_until_complete(coro)
1295 self.assertIsInstance(transport, asyncio.Transport)
1296 self.assertIsInstance(client, MyDatagramProto)
1297 self.assertEqual('INITIALIZED', client.state)
1298 self.assertIs(client.transport, transport)
1301 test_utils.run_until(self.loop, lambda: server.nbytes)
1302 self.assertEqual(3, server.nbytes)
1303 test_utils.run_until(self.loop, lambda: client.nbytes)
1306 self.assertEqual(8, client.nbytes)
1309 self.assertIsNotNone(transport.get_extra_info('sockname'))
1313 self.loop.run_until_complete(client.done)
1314 self.assertEqual('CLOSED', client.state)
1317 def test_create_datagram_endpoint(self):
1318 self._test_create_datagram_endpoint(('127.0.0.1', 0), socket.AF_INET)
1321 def test_create_datagram_endpoint_ipv6(self):
1322 self._test_create_datagram_endpoint(('::1', 0), socket.AF_INET6)
1324 def test_create_datagram_endpoint_sock(self):
1327 infos = self.loop.run_until_complete(
1328 self.loop.getaddrinfo(
1340 self.fail('Can not create socket.')
1342 f = self.loop.create_datagram_endpoint(
1343 lambda: MyDatagramProto(loop=self.loop), sock=sock)
1344 tr, pr = self.loop.run_until_complete(f)
1345 self.assertIsInstance(tr, asyncio.Transport)
1346 self.assertIsInstance(pr, MyDatagramProto)
1348 self.loop.run_until_complete(pr.done)
1350 def test_internal_fds(self):
1351 loop = self.create_event_loop()
1354 self.skipTest('loop is not a BaseSelectorEventLoop')
1356 self.assertEqual(1, loop._internal_fds)
1358 self.assertEqual(0, loop._internal_fds)
1359 self.assertIsNone(loop._csock)
1360 self.assertIsNone(loop._ssock)
1364 def test_read_pipe(self):
1365 proto = MyReadPipeProto(loop=self.loop)
1371 t, p = await self.loop.connect_read_pipe(
1373 self.assertIs(p, proto)
1374 self.assertIs(t, proto.transport)
1375 self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
1376 self.assertEqual(0, proto.nbytes)
1378 self.loop.run_until_complete(connect())
1381 test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
1382 self.assertEqual(1, proto.nbytes)
1385 test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
1386 self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
1387 self.assertEqual(5, proto.nbytes)
1390 self.loop.run_until_complete(proto.done)
1391 self.assertEqual(
1394 self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
1398 def test_unclosed_pipe_transport(self):
1400 loop = self.create_event_loop()
1421 self.assertIn('open', repr(read_transport))
1422 self.assertIn('open', repr(write_transport))
1433 def test_read_pty_output(self):
1434 proto = MyReadPipeProto(loop=self.loop)
1440 t, p = await self.loop.connect_read_pipe(lambda: proto,
1442 self.assertIs(p, proto)
1443 self.assertIs(t, proto.transport)
1444 self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
1445 self.assertEqual(0, proto.nbytes)
1447 self.loop.run_until_complete(connect())
1450 test_utils.run_until(self.loop, lambda: proto.nbytes)
1451 self.assertEqual(1, proto.nbytes)
1454 test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
1455 self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
1456 self.assertEqual(5, proto.nbytes)
1460 self.loop.run_until_complete(proto.done)
1461 self.assertEqual(
1464 self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
1468 def test_write_pipe(self):
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)
1475 self.assertIs(p, proto)
1476 self.assertIs(transport, proto.transport)
1477 self.assertEqual('CONNECTED', proto.state)
1487 test_utils.run_until(self.loop, lambda: reader(data) >= 1)
1488 self.assertEqual(b'1', data)
1491 test_utils.run_until(self.loop, lambda: reader(data) >= 5)
1492 self.assertEqual(b'12345', data)
1493 self.assertEqual('CONNECTED', proto.state)
1498 self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
1502 self.loop.run_until_complete(proto.done)
1503 self.assertEqual('CLOSED', proto.state)
1507 def test_write_pipe_disconnect_on_close(self):
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)
1515 self.assertIs(p, proto)
1516 self.assertIs(transport, proto.transport)
1517 self.assertEqual('CONNECTED', proto.state)
1520 data = self.loop.run_until_complete(self.loop.sock_recv(rsock, 1024))
1521 self.assertEqual(b'1', data)
1525 self.loop.run_until_complete(proto.done)
1526 self.assertEqual('CLOSED', proto.state)
1534 def test_write_pty(self):
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)
1541 self.assertIs(p, proto)
1542 self.assertIs(transport, proto.transport)
1543 self.assertEqual('CONNECTED', proto.state)
1553 test_utils.run_until(self.loop, lambda: reader(data) >= 1,
1555 self.assertEqual(b'1', data)
1558 test_utils.run_until(self.loop, lambda: reader(data) >= 5,
1560 self.assertEqual(b'12345', data)
1561 self.assertEqual('CONNECTED', proto.state)
1566 self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
1570 self.loop.run_until_complete(proto.done)
1571 self.assertEqual('CLOSED', proto.state)
1579 def test_bidirectional_pty(self):
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)
1589 self.assertIs(p, read_proto)
1590 self.assertIs(read_transport, read_proto.transport)
1591 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1592 self.assertEqual(0, read_proto.nbytes)
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)
1600 self.assertIs(p, write_proto)
1601 self.assertIs(write_transport, write_proto.transport)
1602 self.assertEqual('CONNECTED', write_proto.state)
1611 test_utils.run_until(self.loop, lambda: reader(data) >= 1,
1613 self.assertEqual(b'1', data)
1614 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1615 self.assertEqual('CONNECTED', write_proto.state)
1618 test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 1,
1620 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1621 self.assertEqual(1, read_proto.nbytes)
1622 self.assertEqual('CONNECTED', write_proto.state)
1625 test_utils.run_until(self.loop, lambda: reader(data) >= 5,
1627 self.assertEqual(b'12345', data)
1628 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1629 self.assertEqual('CONNECTED', write_proto.state)
1632 test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 5,
1634 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1635 self.assertEqual(5, read_proto.nbytes)
1636 self.assertEqual('CONNECTED', write_proto.state)
1641 self.loop.run_until_complete(read_proto.done)
1642 self.assertEqual(
1646 self.loop.run_until_complete(write_proto.done)
1647 self.assertEqual('CLOSED', write_proto.state)
1649 def test_prompt_cancellation(self):
1652 f = self.loop.create_task(self.loop.sock_recv(r, 1))
1655 self.assertTrue(ov.pending)
1659 self.loop.call_soon(f.cancel)
1666 self.loop.stop()
1670 t = self.loop.create_task(main())
1671 self.loop.run_forever()
1674 self.assertLess(elapsed, 0.1)
1675 self.assertEqual(t.result(), 'cancelled')
1676 self.assertRaises(asyncio.CancelledError, f.result)
1678 self.assertFalse(ov.pending)
1679 self.loop._stop_serving(r)
1684 def test_timeout_rounding(self):
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__})
1710 def test_remove_fds_after_closing(self):
1711 loop = self.create_event_loop()
1714 self.addCleanup(r.close)
1715 self.addCleanup(w.close)
1719 self.assertFalse(loop.remove_reader(r))
1720 self.assertFalse(loop.remove_writer(w))
1722 def test_add_fds_after_closing(self):
1723 loop = self.create_event_loop()
1726 self.addCleanup(r.close)
1727 self.addCleanup(w.close)
1729 with self.assertRaises(RuntimeError):
1731 with self.assertRaises(RuntimeError):
1734 def test_close_running_event_loop(self):
1736 self.loop.close()
1738 coro = close_loop(self.loop)
1739 with self.assertRaises(RuntimeError):
1740 self.loop.run_until_complete(coro)
1742 def test_close(self):
1743 self.loop.close()
1750 self.addCleanup(coro.close)
1753 with self.assertRaises(RuntimeError):
1754 self.loop.run_forever()
1755 with self.assertRaises(RuntimeError):
1756 fut = self.loop.create_future()
1757 self.loop.run_until_complete(fut)
1758 with self.assertRaises(RuntimeError):
1759 self.loop.call_soon(func)
1760 with self.assertRaises(RuntimeError):
1761 self.loop.call_soon_threadsafe(func)
1762 with self.assertRaises(RuntimeError):
1763 self.loop.call_later(1.0, func)
1764 with self.assertRaises(RuntimeError):
1765 self.loop.call_at(self.loop.time() + .0, func)
1766 with self.assertRaises(RuntimeError):
1767 self.loop.create_task(coro)
1768 with self.assertRaises(RuntimeError):
1769 self.loop.add_signal_handler(signal.SIGTERM, func)
1774 with self.assertRaises(RuntimeError):
1775 it = self.loop.run_in_executor(None, func).__await__()
1781 def check_terminated(self, returncode):
1783 self.assertIsInstance(returncode, int)
1786 self.assertEqual(-signal.SIGTERM, returncode)
1788 def check_killed(self, returncode):
1790 self.assertIsInstance(returncode, int)
1793 self.assertEqual(-signal.SIGKILL, returncode)
1795 def test_subprocess_exec(self):
1798 connect = self.loop.subprocess_exec(
1799 functools.partial(MySubprocessProtocol, self.loop),
1802 transp, proto = self.loop.run_until_complete(connect)
1803 self.assertIsInstance(proto, MySubprocessProtocol)
1804 self.loop.run_until_complete(proto.connected)
1805 self.assertEqual('CONNECTED', proto.state)
1809 self.loop.run_until_complete(proto.got_data[1].wait())
1812 self.loop.run_until_complete(proto.completed)
1813 self.check_killed(proto.returncode)
1814 self.assertEqual(b'Python The Winner', proto.data[1])
1816 def test_subprocess_interactive(self):
1819 connect = self.loop.subprocess_exec(
1820 functools.partial(MySubprocessProtocol, self.loop),
1823 transp, proto = self.loop.run_until_complete(connect)
1824 self.assertIsInstance(proto, MySubprocessProtocol)
1825 self.loop.run_until_complete(proto.connected)
1826 self.assertEqual('CONNECTED', proto.state)
1830 self.loop.run_until_complete(proto.got_data[1].wait())
1832 self.assertEqual(b'Python ', proto.data[1])
1835 self.loop.run_until_complete(proto.got_data[1].wait())
1836 self.assertEqual(b'Python The Winner', proto.data[1])
1840 self.loop.run_until_complete(proto.completed)
1841 self.check_killed(proto.returncode)
1843 def test_subprocess_shell(self):
1844 connect = self.loop.subprocess_shell(
1845 functools.partial(MySubprocessProtocol, self.loop),
1847 transp, proto = self.loop.run_until_complete(connect)
1848 self.assertIsInstance(proto, MySubprocessProtocol)
1849 self.loop.run_until_complete(proto.connected)
1852 self.loop.run_until_complete(proto.completed)
1853 self.assertEqual(0, proto.returncode)
1854 self.assertTrue(all(f.done() for f in proto.disconnects.values()))
1855 self.assertEqual(proto.data[1].rstrip(b'\r\n'), b'Python')
1856 self.assertEqual(proto.data[2], b'')
1859 def test_subprocess_exitcode(self):
1860 connect = self.loop.subprocess_shell(
1861 functools.partial(MySubprocessProtocol, self.loop),
1864 transp, proto = self.loop.run_until_complete(connect)
1865 self.assertIsInstance(proto, MySubprocessProtocol)
1866 self.loop.run_until_complete(proto.completed)
1867 self.assertEqual(7, proto.returncode)
1870 def test_subprocess_close_after_finish(self):
1871 connect = self.loop.subprocess_shell(
1872 functools.partial(MySubprocessProtocol, self.loop),
1875 transp, proto = self.loop.run_until_complete(connect)
1876 self.assertIsInstance(proto, MySubprocessProtocol)
1877 self.assertIsNone(transp.get_pipe_transport(0))
1878 self.assertIsNone(transp.get_pipe_transport(1))
1879 self.assertIsNone(transp.get_pipe_transport(2))
1880 self.loop.run_until_complete(proto.completed)
1881 self.assertEqual(7, proto.returncode)
1882 self.assertIsNone(transp.close())
1884 def test_subprocess_kill(self):
1887 connect = self.loop.subprocess_exec(
1888 functools.partial(MySubprocessProtocol, self.loop),
1891 transp, proto = self.loop.run_until_complete(connect)
1892 self.assertIsInstance(proto, MySubprocessProtocol)
1893 self.loop.run_until_complete(proto.connected)
1896 self.loop.run_until_complete(proto.completed)
1897 self.check_killed(proto.returncode)
1900 def test_subprocess_terminate(self):
1903 connect = self.loop.subprocess_exec(
1904 functools.partial(MySubprocessProtocol, self.loop),
1907 transp, proto = self.loop.run_until_complete(connect)
1908 self.assertIsInstance(proto, MySubprocessProtocol)
1909 self.loop.run_until_complete(proto.connected)
1912 self.loop.run_until_complete(proto.completed)
1913 self.check_terminated(proto.returncode)
1917 def test_subprocess_send_signal(self):
1925 connect = self.loop.subprocess_exec(
1926 functools.partial(MySubprocessProtocol, self.loop),
1930 transp, proto = self.loop.run_until_complete(connect)
1931 self.assertIsInstance(proto, MySubprocessProtocol)
1932 self.loop.run_until_complete(proto.connected)
1935 self.loop.run_until_complete(proto.completed)
1936 self.assertEqual(-signal.SIGHUP, proto.returncode)
1941 def test_subprocess_stderr(self):
1944 connect = self.loop.subprocess_exec(
1945 functools.partial(MySubprocessProtocol, self.loop),
1948 transp, proto = self.loop.run_until_complete(connect)
1949 self.assertIsInstance(proto, MySubprocessProtocol)
1950 self.loop.run_until_complete(proto.connected)
1955 self.loop.run_until_complete(proto.completed)
1958 self.assertEqual(b'OUT:test', proto.data[1])
1959 self.assertTrue(proto.data[2].startswith(b'ERR:test'), proto.data[2])
1960 self.assertEqual(0, proto.returncode)
1962 def test_subprocess_stderr_redirect_to_stdout(self):
1965 connect = self.loop.subprocess_exec(
1966 functools.partial(MySubprocessProtocol, self.loop),
1970 transp, proto = self.loop.run_until_complete(connect)
1971 self.assertIsInstance(proto, MySubprocessProtocol)
1972 self.loop.run_until_complete(proto.connected)
1975 self.assertIsNotNone(transp.get_pipe_transport(1))
1976 self.assertIsNone(transp.get_pipe_transport(2))
1979 self.loop.run_until_complete(proto.completed)
1980 self.assertTrue(proto.data[1].startswith(b'OUT:testERR:test'),
1982 self.assertEqual(b'', proto.data[2])
1985 self.assertEqual(0, proto.returncode)
1987 def test_subprocess_close_client_stream(self):
1990 connect = self.loop.subprocess_exec(
1991 functools.partial(MySubprocessProtocol, self.loop),
1994 transp, proto = self.loop.run_until_complete(connect)
1995 self.assertIsInstance(proto, MySubprocessProtocol)
1996 self.loop.run_until_complete(proto.connected)
2001 self.loop.run_until_complete(proto.got_data[1].wait())
2002 self.assertEqual(b'OUT:test', proto.data[1])
2005 self.loop.run_until_complete(proto.disconnects[1])
2007 self.loop.run_until_complete(proto.got_data[2].wait())
2009 self.assertEqual(b'ERR:BrokenPipeError', proto.data[2])
2015 self.assertEqual(b'ERR:OSError', proto.data[2])
2018 self.loop.run_until_complete(proto.completed)
2019 self.check_killed(proto.returncode)
2021 def test_subprocess_wait_no_same_group(self):
2023 connect = self.loop.subprocess_shell(
2024 functools.partial(MySubprocessProtocol, self.loop),
2027 transp, proto = self.loop.run_until_complete(connect)
2028 self.assertIsInstance(proto, MySubprocessProtocol)
2029 self.loop.run_until_complete(proto.completed)
2030 self.assertEqual(7, proto.returncode)
2033 def test_subprocess_exec_invalid_args(self):
2035 await self.loop.subprocess_exec(
2039 with self.assertRaises(ValueError):
2040 self.loop.run_until_complete(connect(universal_newlines=True))
2041 with self.assertRaises(ValueError):
2042 self.loop.run_until_complete(connect(bufsize=4096))
2043 with self.assertRaises(ValueError):
2044 self.loop.run_until_complete(connect(shell=True))
2046 def test_subprocess_shell_invalid_args(self):
2051 await self.loop.subprocess_shell(
2055 with self.assertRaises(ValueError):
2056 self.loop.run_until_complete(connect(['ls', '-l']))
2057 with self.assertRaises(ValueError):
2058 self.loop.run_until_complete(connect(universal_newlines=True))
2059 with self.assertRaises(ValueError):
2060 self.loop.run_until_complete(connect(bufsize=4096))
2061 with self.assertRaises(ValueError):
2062 self.loop.run_until_complete(connect(shell=False))
2070 def create_event_loop(self):
2077 def create_event_loop(self):
2080 def test_reader_callback(self):
2083 def test_reader_callback_cancel(self):
2086 def test_writer_callback(self):
2089 def test_writer_callback_cancel(self):
2092 def test_remove_fds_after_closing(self):
2098 def setUp(self):
2101 watcher.attach_loop(self.loop)
2104 def tearDown(self):
2114 def create_event_loop(self):
2125 def test_read_pty_output(self):
2131 def test_write_pty(self):
2139 def create_event_loop(self):
2147 def create_event_loop(self):
2155 def create_event_loop(self):
2165 def setUp(self):
2167 self.loop = mock.Mock()
2168 self.loop.get_debug.return_value = True
2170 def test_handle(self):
2175 h = asyncio.Handle(callback, args, self.loop)
2176 self.assertIs(h._callback, callback)
2177 self.assertIs(h._args, args)
2178 self.assertFalse(h.cancelled())
2181 self.assertTrue(h.cancelled())
2183 def test_callback_with_exception(self):
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({
2200 def test_handle_weakref(self):
2202 h = asyncio.Handle(lambda: None, (), self.loop)
2205 def test_handle_repr(self):
2206 self.loop.get_debug.return_value = False
2209 h = asyncio.Handle(noop, (1, 2), self.loop)
2211 self.assertEqual(repr(h),
2217 self.assertEqual(repr(h),
2222 h = asyncio.Handle(cb, (), self.loop)
2223 self.assertEqual(repr(h),
2229 h = asyncio.Handle(cb, (3,), self.loop)
2232 self.assertRegex(repr(h), regex)
2236 h = asyncio.Handle(cb, (2, 3), self.loop)
2239 self.assertRegex(repr(h), regex)
2245 h = asyncio.Handle(cb, (), self.loop)
2250 self.assertRegex(repr(h), regex)
2252 def test_handle_repr_debug(self):
2253 self.loop.get_debug.return_value = True
2258 h = asyncio.Handle(noop, (1, 2), self.loop)
2260 self.assertEqual(repr(h),
2266 self.assertEqual(
2273 self.assertEqual(
2278 def test_handle_source_traceback(self):
2281 self.set_event_loop(loop)
2285 self.assertIsInstance(h._source_traceback, list)
2286 self.assertEqual(h._source_traceback[-1][:3],
2309 def test_coroutine_like_object_debug_formatting(self):
2316 self.assertTrue(asyncio.iscoroutine(coro))
2317 self.assertEqual(coroutines._format_coroutine(coro), 'AAA()')
2320 self.assertEqual(coroutines._format_coroutine(coro), 'BBB()')
2323 self.assertEqual(coroutines._format_coroutine(coro), 'BBB() running')
2326 self.assertEqual(coroutines._format_coroutine(coro),
2333 self.assertEqual(coroutines._format_coroutine(coro), 'CoroLike()')
2338 self.assertEqual(coroutines._format_coroutine(coro), 'AAA()')
2343 def setUp(self):
2345 self.loop = mock.Mock()
2347 def test_hash(self):
2351 self.assertEqual(hash(h), hash(when))
2353 def test_when(self):
2357 self.assertEqual(when, h.when())
2359 def test_timer(self):
2366 self.assertIs(h._callback, callback)
2367 self.assertIs(h._args, args)
2368 self.assertFalse(h.cancelled())
2372 self.assertTrue(h.cancelled())
2373 self.assertIsNone(h._callback)
2374 self.assertIsNone(h._args)
2377 def test_timer_repr(self):
2378 self.loop.get_debug.return_value = False
2381 h = asyncio.TimerHandle(123, noop, (), self.loop)
2383 self.assertEqual(repr(h),
2388 self.assertEqual(repr(h),
2391 def test_timer_repr_debug(self):
2392 self.loop.get_debug.return_value = True
2397 h = asyncio.TimerHandle(123, noop, (), self.loop)
2399 self.assertEqual(repr(h),
2406 self.assertEqual(repr(h),
2412 def test_timer_comparison(self):
2418 h1 = asyncio.TimerHandle(when, callback, (), self.loop)
2419 h2 = asyncio.TimerHandle(when, callback, (), self.loop)
2421 self.assertFalse(h1 < h2)
2422 self.assertFalse(h2 < h1)
2423 self.assertTrue(h1 <= h2)
2424 self.assertTrue(h2 <= h1)
2425 self.assertFalse(h1 > h2)
2426 self.assertFalse(h2 > h1)
2427 self.assertTrue(h1 >= h2)
2428 self.assertTrue(h2 >= h1)
2429 self.assertTrue(h1 == h2)
2430 self.assertFalse(h1 != h2)
2433 self.assertFalse(h1 == h2)
2435 h1 = asyncio.TimerHandle(when, callback, (), self.loop)
2436 h2 = asyncio.TimerHandle(when + 10.0, callback, (), self.loop)
2437 self.assertTrue(h1 < h2)
2438 self.assertFalse(h2 < h1)
2439 self.assertTrue(h1 <= h2)
2440 self.assertFalse(h2 <= h1)
2441 self.assertFalse(h1 > h2)
2442 self.assertTrue(h2 > h1)
2443 self.assertFalse(h1 >= h2)
2444 self.assertTrue(h2 >= h1)
2445 self.assertFalse(h1 == h2)
2446 self.assertTrue(h1 != h2)
2448 h3 = asyncio.Handle(callback, (), self.loop)
2449 self.assertIs(NotImplemented, h1.__eq__(h3))
2450 self.assertIs(NotImplemented, h1.__ne__(h3))
2452 with self.assertRaises(TypeError):
2454 with self.assertRaises(TypeError):
2456 with self.assertRaises(TypeError):
2458 with self.assertRaises(TypeError):
2460 self.assertFalse(h1 == ())
2461 self.assertTrue(h1 != ())
2463 self.assertTrue(h1 == ALWAYS_EQ)
2464 self.assertFalse(h1 != ALWAYS_EQ)
2465 self.assertTrue(h1 < LARGEST)
2466 self.assertFalse(h1 > LARGEST)
2467 self.assertTrue(h1 <= LARGEST)
2468 self.assertFalse(h1 >= LARGEST)
2469 self.assertFalse(h1 < SMALLEST)
2470 self.assertTrue(h1 > SMALLEST)
2471 self.assertFalse(h1 <= SMALLEST)
2472 self.assertTrue(h1 >= SMALLEST)
2477 def test_not_implemented(self):
2480 self.assertRaises(
2482 self.assertRaises(
2484 self.assertRaises(
2486 self.assertRaises(
2488 self.assertRaises(
2490 self.assertRaises(
2492 self.assertRaises(
2494 self.assertRaises(
2496 self.assertRaises(
2498 self.assertRaises(
2500 self.assertRaises(
2502 self.assertRaises(
2504 self.assertRaises(
2506 self.assertRaises(
2508 self.assertRaises(
2510 self.assertRaises(
2512 self.assertRaises(
2514 self.assertRaises(
2516 self.assertRaises(
2518 self.assertRaises(
2520 self.assertRaises(
2522 self.assertRaises(
2524 self.assertRaises(
2526 self.assertRaises(
2528 self.assertRaises(
2531 def test_not_implemented_async(self):
2537 with self.assertRaises(NotImplementedError):
2539 with self.assertRaises(NotImplementedError):
2541 with self.assertRaises(NotImplementedError):
2543 with self.assertRaises(NotImplementedError):
2545 with self.assertRaises(NotImplementedError):
2547 with self.assertRaises(NotImplementedError):
2549 with self.assertRaises(NotImplementedError):
2551 with self.assertRaises(NotImplementedError):
2553 with self.assertRaises(NotImplementedError):
2555 with self.assertRaises(NotImplementedError):
2557 with self.assertRaises(NotImplementedError):
2559 with self.assertRaises(NotImplementedError):
2561 with self.assertRaises(NotImplementedError):
2563 with self.assertRaises(NotImplementedError):
2565 with self.assertRaises(NotImplementedError):
2567 with self.assertRaises(NotImplementedError):
2569 with self.assertRaises(NotImplementedError):
2579 def test_event_loop_policy(self):
2581 self.assertRaises(NotImplementedError, policy.get_event_loop)
2582 self.assertRaises(NotImplementedError, policy.set_event_loop, object())
2583 self.assertRaises(NotImplementedError, policy.new_event_loop)
2584 self.assertRaises(NotImplementedError, policy.get_child_watcher)
2585 self.assertRaises(NotImplementedError, policy.set_child_watcher,
2588 def test_get_event_loop(self):
2590 self.assertIsNone(policy._local._loop)
2592 self.assertIsInstance(loop, asyncio.AbstractEventLoop)
2594 self.assertIs(policy._local._loop, loop)
2595 self.assertIs(loop, policy.get_event_loop())
2598 def test_get_event_loop_calls_set_event_loop(self):
2606 self.addCleanup(loop.close)
2615 def test_get_event_loop_after_set_none(self):
2618 self.assertRaises(RuntimeError, policy.get_event_loop)
2621 def test_get_event_loop_thread(self, m_current_thread):
2625 self.assertRaises(RuntimeError, policy.get_event_loop)
2631 def test_new_event_loop(self):
2635 self.assertIsInstance(loop, asyncio.AbstractEventLoop)
2638 def test_set_event_loop(self):
2643 self.assertRaises(TypeError, policy.set_event_loop, object())
2647 self.assertIs(loop, policy.get_event_loop())
2648 self.assertIsNot(old_loop, policy.get_event_loop())
2652 def test_get_event_loop_policy(self):
2654 self.assertIsInstance(policy, asyncio.AbstractEventLoopPolicy)
2655 self.assertIs(policy, asyncio.get_event_loop_policy())
2657 def test_set_event_loop_policy(self):
2658 self.assertRaises(
2665 self.assertIs(policy, asyncio.get_event_loop_policy())
2666 self.assertIsNot(policy, old_policy)
2676 def setUp(self):
2677 self._get_running_loop_saved = events._get_running_loop
2678 self._set_running_loop_saved = events._set_running_loop
2679 self.get_running_loop_saved = events.get_running_loop
2680 self.get_event_loop_saved = events.get_event_loop
2682 events._get_running_loop = type(self)._get_running_loop_impl
2683 events._set_running_loop = type(self)._set_running_loop_impl
2684 events.get_running_loop = type(self).get_running_loop_impl
2685 events.get_event_loop = type(self).get_event_loop_impl
2687 asyncio._get_running_loop = type(self)._get_running_loop_impl
2688 asyncio._set_running_loop = type(self)._set_running_loop_impl
2689 asyncio.get_running_loop = type(self).get_running_loop_impl
2690 asyncio.get_event_loop = type(self).get_event_loop_impl
2694 self.loop = asyncio.new_event_loop()
2695 asyncio.set_event_loop(self.loop)
2699 watcher.attach_loop(self.loop)
2702 def tearDown(self):
2709 self.loop.close()
2712 events._get_running_loop = self._get_running_loop_saved
2713 events._set_running_loop = self._set_running_loop_saved
2714 events.get_running_loop = self.get_running_loop_saved
2715 events.get_event_loop = self.get_event_loop_saved
2717 asyncio._get_running_loop = self._get_running_loop_saved
2718 asyncio._set_running_loop = self._set_running_loop_saved
2719 asyncio.get_running_loop = self.get_running_loop_saved
2720 asyncio.get_event_loop = self.get_event_loop_saved
2724 def test_get_event_loop_new_process(self):
2732 result = await self.loop.run_in_executor(
2737 self.assertEqual(
2738 self.loop.run_until_complete(main()),
2741 def test_get_event_loop_returns_running_loop(self):
2746 def get_event_loop(self):
2754 with self.assertRaises(TestError):
2757 with self.assertRaises(TestError):
2760 with self.assertRaisesRegex(RuntimeError, 'no running'):
2762 self.assertIs(asyncio._get_running_loop(), None)
2765 self.assertIs(asyncio.get_event_loop(), loop)
2766 self.assertIs(asyncio.get_running_loop(), loop)
2767 self.assertIs(asyncio._get_running_loop(), loop)
2772 with self.assertRaises(TestError):
2775 with self.assertRaises(TestError):
2783 with self.assertRaisesRegex(RuntimeError, 'no running'):
2786 self.assertIs(asyncio._get_running_loop(), None)
2788 def test_get_event_loop_returns_running_loop2(self):
2793 self.addCleanup(loop.close)
2796 self.addCleanup(loop2.close)
2798 with self.assertRaisesRegex(RuntimeError, 'no current'):
2801 with self.assertRaisesRegex(RuntimeError, 'no running'):
2803 self.assertIs(asyncio._get_running_loop(), None)
2806 self.assertIs(asyncio.get_event_loop(), loop)
2807 self.assertIs(asyncio.get_running_loop(), loop)
2808 self.assertIs(asyncio._get_running_loop(), loop)
2813 self.assertIs(asyncio.get_event_loop(), loop)
2816 with self.assertRaisesRegex(RuntimeError, 'no current'):
2824 with self.assertRaisesRegex(RuntimeError, 'no running'):
2827 self.assertIs(asyncio._get_running_loop(), None)
2854 def test_get_loop(self):
2856 self.addCleanup(loop.close)
2859 self.assertEqual(server.get_loop(), loop)
2866 def test_close(self):
2867 with self.assertRaises(NotImplementedError):
2870 def test_wait_closed(self):
2872 self.addCleanup(loop.close)
2874 with self.assertRaises(NotImplementedError):
2877 def test_get_loop(self):
2878 with self.assertRaises(NotImplementedError):