Debian Codegraph @

Lib/test/test_asyncio/test_unix_events.py

raw
1 """Tests for unix_events.py."""
2
3 import contextlib
4 import errno
5 import io
6 import multiprocessing
7 from multiprocessing.util import _cleanup_tests as multiprocessing_cleanup_tests
8 import os
9 import signal
10 import socket
11 import stat
12 import sys
13 import time
14 import unittest
15 from unittest import mock
16
17 from test import support
18 from test.support import os_helper
19 from test.support import socket_helper
20 from test.support import wait_process
21 from test.support import hashlib_helper
22
23 if sys.platform == 'win32':
24 raise unittest.SkipTest('UNIX only')
25
26
27 import asyncio
28 from asyncio import unix_events
29 from test.test_asyncio import utils as test_utils
30
31
32 def tearDownModule():
33 asyncio.events._set_event_loop_policy(None)
34
35
36 MOCK_ANY = mock.ANY
37
38
39 def EXITCODE(exitcode):
40 return 32768 + exitcode
41
42
43 def SIGNAL(signum):
44 if not 1 <= signum <= 68:
45 raise AssertionError(f'invalid signum {signum}')
46 return 32768 - signum
47
48
49 def close_pipe_transport(transport):
50 # Don't call transport.close() because the event loop and the selector
51 # are mocked
52 if transport._pipe is None:
53 return
54 transport._pipe.close()
55 transport._pipe = None
56
57
58 @unittest.skipUnless(signal, 'Signals are not supported')
59 class SelectorEventLoopSignalTests(test_utils.TestCase):
60
61 def setUp(self):
62 super().setUp()
63 self.loop = asyncio.SelectorEventLoop()
64 self.set_event_loop(self.loop)
65
66 def test_check_signal(self):
67 self.assertRaises(
68 TypeError, self.loop._check_signal, '1')
69 self.assertRaises(
70 ValueError, self.loop._check_signal, signal.NSIG + 1)
71
72 def test_handle_signal_no_handler(self):
73 self.loop._handle_signal(signal.NSIG + 1)
74
75 def test_handle_signal_cancelled_handler(self):
76 h = asyncio.Handle(mock.Mock(), (),
77 loop=mock.Mock())
78 h.cancel()
79 self.loop._signal_handlers[signal.NSIG + 1] = h
80 self.loop.remove_signal_handler = mock.Mock()
81 self.loop._handle_signal(signal.NSIG + 1)
82 self.loop.remove_signal_handler.assert_called_with(signal.NSIG + 1)
83
84 @mock.patch('asyncio.unix_events.signal')
85 def test_add_signal_handler_setup_error(self, m_signal):
86 m_signal.NSIG = signal.NSIG
87 m_signal.valid_signals = signal.valid_signals
88 m_signal.set_wakeup_fd.side_effect = ValueError
89
90 self.assertRaises(
91 RuntimeError,
92 self.loop.add_signal_handler,
93 signal.SIGINT, lambda: True)
94
95 @mock.patch('asyncio.unix_events.signal')
96 def test_add_signal_handler_coroutine_error(self, m_signal):
97 m_signal.NSIG = signal.NSIG
98
99 async def simple_coroutine():
100 pass
101
102 # callback must not be a coroutine function
103 coro_func = simple_coroutine
104 coro_obj = coro_func()
105 self.addCleanup(coro_obj.close)
106 for func in (coro_func, coro_obj):
107 self.assertRaisesRegex(
108 TypeError, 'coroutines cannot be used with add_signal_handler',
109 self.loop.add_signal_handler,
110 signal.SIGINT, func)
111
112 @mock.patch('asyncio.unix_events.signal')
113 def test_add_signal_handler(self, m_signal):
114 m_signal.NSIG = signal.NSIG
115 m_signal.valid_signals = signal.valid_signals
116
117 cb = lambda: True
118 self.loop.add_signal_handler(signal.SIGHUP, cb)
119 h = self.loop._signal_handlers.get(signal.SIGHUP)
120 self.assertIsInstance(h, asyncio.Handle)
121 self.assertEqual(h._callback, cb)
122
123 @mock.patch('asyncio.unix_events.signal')
124 def test_add_signal_handler_install_error(self, m_signal):
125 m_signal.NSIG = signal.NSIG
126 m_signal.valid_signals = signal.valid_signals
127
128 def set_wakeup_fd(fd):
129 if fd == -1:
130 raise ValueError()
131 m_signal.set_wakeup_fd = set_wakeup_fd
132
133 class Err(OSError):
134 errno = errno.EFAULT
135 m_signal.signal.side_effect = Err
136
137 self.assertRaises(
138 Err,
139 self.loop.add_signal_handler,
140 signal.SIGINT, lambda: True)
141
142 @mock.patch('asyncio.unix_events.signal')
143 @mock.patch('asyncio.base_events.logger')
144 def test_add_signal_handler_install_error2(self, m_logging, m_signal):
145 m_signal.NSIG = signal.NSIG
146 m_signal.valid_signals = signal.valid_signals
147
148 class Err(OSError):
149 errno = errno.EINVAL
150 m_signal.signal.side_effect = Err
151
152 self.loop._signal_handlers[signal.SIGHUP] = lambda: True
153 self.assertRaises(
154 RuntimeError,
155 self.loop.add_signal_handler,
156 signal.SIGINT, lambda: True)
157 self.assertFalse(m_logging.info.called)
158 self.assertEqual(1, m_signal.set_wakeup_fd.call_count)
159
160 @mock.patch('asyncio.unix_events.signal')
161 @mock.patch('asyncio.base_events.logger')
162 def test_add_signal_handler_install_error3(self, m_logging, m_signal):
163 class Err(OSError):
164 errno = errno.EINVAL
165 m_signal.signal.side_effect = Err
166 m_signal.NSIG = signal.NSIG
167 m_signal.valid_signals = signal.valid_signals
168
169 self.assertRaises(
170 RuntimeError,
171 self.loop.add_signal_handler,
172 signal.SIGINT, lambda: True)
173 self.assertFalse(m_logging.info.called)
174 self.assertEqual(2, m_signal.set_wakeup_fd.call_count)
175
176 @mock.patch('asyncio.unix_events.signal')
177 def test_remove_signal_handler(self, m_signal):
178 m_signal.NSIG = signal.NSIG
179 m_signal.valid_signals = signal.valid_signals
180
181 self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
182
183 self.assertTrue(
184 self.loop.remove_signal_handler(signal.SIGHUP))
185 self.assertTrue(m_signal.set_wakeup_fd.called)
186 self.assertTrue(m_signal.signal.called)
187 self.assertEqual(
188 (signal.SIGHUP, m_signal.SIG_DFL), m_signal.signal.call_args[0])
189
190 @mock.patch('asyncio.unix_events.signal')
191 def test_remove_signal_handler_2(self, m_signal):
192 m_signal.NSIG = signal.NSIG
193 m_signal.SIGINT = signal.SIGINT
194 m_signal.valid_signals = signal.valid_signals
195
196 self.loop.add_signal_handler(signal.SIGINT, lambda: True)
197 self.loop._signal_handlers[signal.SIGHUP] = object()
198 m_signal.set_wakeup_fd.reset_mock()
199
200 self.assertTrue(
201 self.loop.remove_signal_handler(signal.SIGINT))
202 self.assertFalse(m_signal.set_wakeup_fd.called)
203 self.assertTrue(m_signal.signal.called)
204 self.assertEqual(
205 (signal.SIGINT, m_signal.default_int_handler),
206 m_signal.signal.call_args[0])
207
208 @mock.patch('asyncio.unix_events.signal')
209 @mock.patch('asyncio.base_events.logger')
210 def test_remove_signal_handler_cleanup_error(self, m_logging, m_signal):
211 m_signal.NSIG = signal.NSIG
212 m_signal.valid_signals = signal.valid_signals
213 self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
214
215 m_signal.set_wakeup_fd.side_effect = ValueError
216
217 self.loop.remove_signal_handler(signal.SIGHUP)
218 self.assertTrue(m_logging.info)
219
220 @mock.patch('asyncio.unix_events.signal')
221 def test_remove_signal_handler_error(self, m_signal):
222 m_signal.NSIG = signal.NSIG
223 m_signal.valid_signals = signal.valid_signals
224 self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
225
226 m_signal.signal.side_effect = OSError
227
228 self.assertRaises(
229 OSError, self.loop.remove_signal_handler, signal.SIGHUP)
230
231 @mock.patch('asyncio.unix_events.signal')
232 def test_remove_signal_handler_error2(self, m_signal):
233 m_signal.NSIG = signal.NSIG
234 m_signal.valid_signals = signal.valid_signals
235 self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
236
237 class Err(OSError):
238 errno = errno.EINVAL
239 m_signal.signal.side_effect = Err
240
241 self.assertRaises(
242 RuntimeError, self.loop.remove_signal_handler, signal.SIGHUP)
243
244 @mock.patch('asyncio.unix_events.signal')
245 def test_close(self, m_signal):
246 m_signal.NSIG = signal.NSIG
247 m_signal.valid_signals = signal.valid_signals
248
249 self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
250 self.loop.add_signal_handler(signal.SIGCHLD, lambda: True)
251
252 self.assertEqual(len(self.loop._signal_handlers), 2)
253
254 m_signal.set_wakeup_fd.reset_mock()
255
256 self.loop.close()
257
258 self.assertEqual(len(self.loop._signal_handlers), 0)
259 m_signal.set_wakeup_fd.assert_called_once_with(-1)
260
261 @mock.patch('asyncio.unix_events.sys')
262 @mock.patch('asyncio.unix_events.signal')
263 def test_close_on_finalizing(self, m_signal, m_sys):
264 m_signal.NSIG = signal.NSIG
265 m_signal.valid_signals = signal.valid_signals
266 self.loop.add_signal_handler(signal.SIGHUP, lambda: True)
267
268 self.assertEqual(len(self.loop._signal_handlers), 1)
269 m_sys.is_finalizing.return_value = True
270 m_signal.signal.reset_mock()
271
272 with self.assertWarnsRegex(ResourceWarning,
273 "skipping signal handlers removal"):
274 self.loop.close()
275
276 self.assertEqual(len(self.loop._signal_handlers), 0)
277 self.assertFalse(m_signal.signal.called)
278
279
280 @unittest.skipUnless(hasattr(socket, 'AF_UNIX'),
281 'UNIX Sockets are not supported')
282 class SelectorEventLoopUnixSocketTests(test_utils.TestCase):
283
284 def setUp(self):
285 super().setUp()
286 self.loop = asyncio.SelectorEventLoop()
287 self.set_event_loop(self.loop)
288
289 @socket_helper.skip_unless_bind_unix_socket
290 def test_create_unix_server_existing_path_sock(self):
291 with test_utils.unix_socket_path() as path:
292 sock = socket.socket(socket.AF_UNIX)
293 sock.bind(path)
294 sock.listen(1)
295 sock.close()
296
297 coro = self.loop.create_unix_server(lambda: None, path)
298 srv = self.loop.run_until_complete(coro)
299 srv.close()
300 self.loop.run_until_complete(srv.wait_closed())
301
302 @socket_helper.skip_unless_bind_unix_socket
303 def test_create_unix_server_pathlike(self):
304 with test_utils.unix_socket_path() as path:
305 path = os_helper.FakePath(path)
306 srv_coro = self.loop.create_unix_server(lambda: None, path)
307 srv = self.loop.run_until_complete(srv_coro)
308 srv.close()
309 self.loop.run_until_complete(srv.wait_closed())
310
311 def test_create_unix_connection_pathlike(self):
312 with test_utils.unix_socket_path() as path:
313 path = os_helper.FakePath(path)
314 coro = self.loop.create_unix_connection(lambda: None, path)
315 with self.assertRaises(FileNotFoundError):
316 # If path-like object weren't supported, the exception would be
317 # different.
318 self.loop.run_until_complete(coro)
319
320 def test_create_unix_server_existing_path_nonsock(self):
321 path = test_utils.gen_unix_socket_path()
322 self.addCleanup(os_helper.unlink, path)
323 # create the file
324 open(path, "wb").close()
325
326 coro = self.loop.create_unix_server(lambda: None, path)
327 with self.assertRaisesRegex(OSError,
328 'Address.*is already in use'):
329 self.loop.run_until_complete(coro)
330
331 def test_create_unix_server_ssl_bool(self):
332 coro = self.loop.create_unix_server(lambda: None, path='spam',
333 ssl=True)
334 with self.assertRaisesRegex(TypeError,
335 'ssl argument must be an SSLContext'):
336 self.loop.run_until_complete(coro)
337
338 def test_create_unix_server_nopath_nosock(self):
339 coro = self.loop.create_unix_server(lambda: None, path=None)
340 with self.assertRaisesRegex(ValueError,
341 'path was not specified, and no sock'):
342 self.loop.run_until_complete(coro)
343
344 def test_create_unix_server_path_inetsock(self):
345 sock = socket.socket()
346 with sock:
347 coro = self.loop.create_unix_server(lambda: None, path=None,
348 sock=sock)
349 with self.assertRaisesRegex(ValueError,
350 'A UNIX Domain Stream.*was expected'):
351 self.loop.run_until_complete(coro)
352
353 def test_create_unix_server_path_dgram(self):
354 sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
355 with sock:
356 coro = self.loop.create_unix_server(lambda: None, path=None,
357 sock=sock)
358 with self.assertRaisesRegex(ValueError,
359 'A UNIX Domain Stream.*was expected'):
360 self.loop.run_until_complete(coro)
361
362 @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
363 'no socket.SOCK_NONBLOCK (linux only)')
364 @socket_helper.skip_unless_bind_unix_socket
365 def test_create_unix_server_path_stream_bittype(self):
366 fn = test_utils.gen_unix_socket_path()
367 self.addCleanup(os_helper.unlink, fn)
368
369 sock = socket.socket(socket.AF_UNIX,
370 socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
371 with sock:
372 sock.bind(fn)
373 coro = self.loop.create_unix_server(lambda: None, path=None,
374 sock=sock)
375 srv = self.loop.run_until_complete(coro)
376 srv.close()
377 self.loop.run_until_complete(srv.wait_closed())
378
379 def test_create_unix_server_ssl_timeout_with_plain_sock(self):
380 coro = self.loop.create_unix_server(lambda: None, path='spam',
381 ssl_handshake_timeout=1)
382 with self.assertRaisesRegex(
383 ValueError,
384 'ssl_handshake_timeout is only meaningful with ssl'):
385 self.loop.run_until_complete(coro)
386
387 def test_create_unix_connection_path_inetsock(self):
388 sock = socket.socket()
389 with sock:
390 coro = self.loop.create_unix_connection(lambda: None,
391 sock=sock)
392 with self.assertRaisesRegex(ValueError,
393 'A UNIX Domain Stream.*was expected'):
394 self.loop.run_until_complete(coro)
395
396 @mock.patch('asyncio.unix_events.socket')
397 def test_create_unix_server_bind_error(self, m_socket):
398 # Ensure that the socket is closed on any bind error
399 sock = mock.Mock()
400 m_socket.socket.return_value = sock
401
402 sock.bind.side_effect = OSError
403 coro = self.loop.create_unix_server(lambda: None, path="/test")
404 with self.assertRaises(OSError):
405 self.loop.run_until_complete(coro)
406 self.assertTrue(sock.close.called)
407
408 sock.bind.side_effect = MemoryError
409 coro = self.loop.create_unix_server(lambda: None, path="/test")
410 with self.assertRaises(MemoryError):
411 self.loop.run_until_complete(coro)
412 self.assertTrue(sock.close.called)
413
414 def test_create_unix_connection_path_sock(self):
415 coro = self.loop.create_unix_connection(
416 lambda: None, os.devnull, sock=object())
417 with self.assertRaisesRegex(ValueError, 'path and sock can not be'):
418 self.loop.run_until_complete(coro)
419
420 def test_create_unix_connection_nopath_nosock(self):
421 coro = self.loop.create_unix_connection(
422 lambda: None, None)
423 with self.assertRaisesRegex(ValueError,
424 'no path and sock were specified'):
425 self.loop.run_until_complete(coro)
426
427 def test_create_unix_connection_nossl_serverhost(self):
428 coro = self.loop.create_unix_connection(
429 lambda: None, os.devnull, server_hostname='spam')
430 with self.assertRaisesRegex(ValueError,
431 'server_hostname is only meaningful'):
432 self.loop.run_until_complete(coro)
433
434 def test_create_unix_connection_ssl_noserverhost(self):
435 coro = self.loop.create_unix_connection(
436 lambda: None, os.devnull, ssl=True)
437
438 with self.assertRaisesRegex(
439 ValueError, 'you have to pass server_hostname when using ssl'):
440
441 self.loop.run_until_complete(coro)
442
443 def test_create_unix_connection_ssl_timeout_with_plain_sock(self):
444 coro = self.loop.create_unix_connection(lambda: None, path='spam',
445 ssl_handshake_timeout=1)
446 with self.assertRaisesRegex(
447 ValueError,
448 'ssl_handshake_timeout is only meaningful with ssl'):
449 self.loop.run_until_complete(coro)
450
451
452 @unittest.skipUnless(hasattr(os, 'sendfile'),
453 'sendfile is not supported')
454 class SelectorEventLoopUnixSockSendfileTests(test_utils.TestCase):
455 DATA = b"12345abcde" * 16 * 1024 # 160 KiB
456
457 class MyProto(asyncio.Protocol):
458
459 def __init__(self, loop):
460 self.started = False
461 self.closed = False
462 self.data = bytearray()
463 self.fut = loop.create_future()
464 self.transport = None
465 self._ready = loop.create_future()
466
467 def connection_made(self, transport):
468 self.started = True
469 self.transport = transport
470 self._ready.set_result(None)
471
472 def data_received(self, data):
473 self.data.extend(data)
474
475 def connection_lost(self, exc):
476 self.closed = True
477 self.fut.set_result(None)
478
479 async def wait_closed(self):
480 await self.fut
481
482 @classmethod
483 def setUpClass(cls):
484 with open(os_helper.TESTFN, 'wb') as fp:
485 fp.write(cls.DATA)
486 super().setUpClass()
487
488 @classmethod
489 def tearDownClass(cls):
490 os_helper.unlink(os_helper.TESTFN)
491 super().tearDownClass()
492
493 def setUp(self):
494 self.loop = asyncio.new_event_loop()
495 self.set_event_loop(self.loop)
496 self.file = open(os_helper.TESTFN, 'rb')
497 self.addCleanup(self.file.close)
498 super().setUp()
499
500 def make_socket(self, cleanup=True):
501 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
502 sock.setblocking(False)
503 sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024)
504 sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1024)
505 if cleanup:
506 self.addCleanup(sock.close)
507 return sock
508
509 def run_loop(self, coro):
510 return self.loop.run_until_complete(coro)
511
512 def prepare(self):
513 sock = self.make_socket()
514 proto = self.MyProto(self.loop)
515 port = socket_helper.find_unused_port()
516 srv_sock = self.make_socket(cleanup=False)
517 srv_sock.bind((socket_helper.HOST, port))
518 server = self.run_loop(self.loop.create_server(
519 lambda: proto, sock=srv_sock))
520 self.run_loop(self.loop.sock_connect(sock, (socket_helper.HOST, port)))
521 self.run_loop(proto._ready)
522
523 def cleanup():
524 proto.transport.close()
525 self.run_loop(proto.wait_closed())
526
527 server.close()
528 self.run_loop(server.wait_closed())
529
530 self.addCleanup(cleanup)
531
532 return sock, proto
533
534 def test_sock_sendfile_not_available(self):
535 sock, proto = self.prepare()
536 with mock.patch('asyncio.unix_events.os', spec=[]):
537 with self.assertRaisesRegex(asyncio.SendfileNotAvailableError,
538 "os[.]sendfile[(][)] is not available"):
539 self.run_loop(self.loop._sock_sendfile_native(sock, self.file,
540 0, None))
541 self.assertEqual(self.file.tell(), 0)
542
543 def test_sock_sendfile_not_a_file(self):
544 sock, proto = self.prepare()
545 f = object()
546 with self.assertRaisesRegex(asyncio.SendfileNotAvailableError,
547 "not a regular file"):
548 self.run_loop(self.loop._sock_sendfile_native(sock, f,
549 0, None))
550 self.assertEqual(self.file.tell(), 0)
551
552 def test_sock_sendfile_iobuffer(self):
553 sock, proto = self.prepare()
554 f = io.BytesIO()
555 with self.assertRaisesRegex(asyncio.SendfileNotAvailableError,
556 "not a regular file"):
557 self.run_loop(self.loop._sock_sendfile_native(sock, f,
558 0, None))
559 self.assertEqual(self.file.tell(), 0)
560
561 def test_sock_sendfile_not_regular_file(self):
562 sock, proto = self.prepare()
563 f = mock.Mock()
564 f.fileno.return_value = -1
565 with self.assertRaisesRegex(asyncio.SendfileNotAvailableError,
566 "not a regular file"):
567 self.run_loop(self.loop._sock_sendfile_native(sock, f,
568 0, None))
569 self.assertEqual(self.file.tell(), 0)
570
571 def test_sock_sendfile_cancel1(self):
572 sock, proto = self.prepare()
573
574 fut = self.loop.create_future()
575 fileno = self.file.fileno()
576 self.loop._sock_sendfile_native_impl(fut, None, sock, fileno,
577 0, None, len(self.DATA), 0)
578 fut.cancel()
579 with contextlib.suppress(asyncio.CancelledError):
580 self.run_loop(fut)
581 with self.assertRaises(KeyError):
582 self.loop._selector.get_key(sock)
583
584 def test_sock_sendfile_cancel2(self):
585 sock, proto = self.prepare()
586
587 fut = self.loop.create_future()
588 fileno = self.file.fileno()
589 self.loop._sock_sendfile_native_impl(fut, None, sock, fileno,
590 0, None, len(self.DATA), 0)
591 fut.cancel()
592 self.loop._sock_sendfile_native_impl(fut, sock.fileno(), sock, fileno,
593 0, None, len(self.DATA), 0)
594 with self.assertRaises(KeyError):
595 self.loop._selector.get_key(sock)
596
597 def test_sock_sendfile_blocking_error(self):
598 sock, proto = self.prepare()
599
600 fileno = self.file.fileno()
601 fut = mock.Mock()
602 fut.cancelled.return_value = False
603 with mock.patch('os.sendfile', side_effect=BlockingIOError()):
604 self.loop._sock_sendfile_native_impl(fut, None, sock, fileno,
605 0, None, len(self.DATA), 0)
606 key = self.loop._selector.get_key(sock)
607 self.assertIsNotNone(key)
608 fut.add_done_callback.assert_called_once_with(mock.ANY)
609
610 def test_sock_sendfile_os_error_first_call(self):
611 sock, proto = self.prepare()
612
613 fileno = self.file.fileno()
614 fut = self.loop.create_future()
615 with mock.patch('os.sendfile', side_effect=OSError()):
616 self.loop._sock_sendfile_native_impl(fut, None, sock, fileno,
617 0, None, len(self.DATA), 0)
618 with self.assertRaises(KeyError):
619 self.loop._selector.get_key(sock)
620 exc = fut.exception()
621 self.assertIsInstance(exc, asyncio.SendfileNotAvailableError)
622 self.assertEqual(0, self.file.tell())
623
624 def test_sock_sendfile_os_error_next_call(self):
625 sock, proto = self.prepare()
626
627 fileno = self.file.fileno()
628 fut = self.loop.create_future()
629 err = OSError()
630 with mock.patch('os.sendfile', side_effect=err):
631 self.loop._sock_sendfile_native_impl(fut, sock.fileno(),
632 sock, fileno,
633 1000, None, len(self.DATA),
634 1000)
635 with self.assertRaises(KeyError):
636 self.loop._selector.get_key(sock)
637 exc = fut.exception()
638 self.assertIs(exc, err)
639 self.assertEqual(1000, self.file.tell())
640
641 def test_sock_sendfile_exception(self):
642 sock, proto = self.prepare()
643
644 fileno = self.file.fileno()
645 fut = self.loop.create_future()
646 err = asyncio.SendfileNotAvailableError()
647 with mock.patch('os.sendfile', side_effect=err):
648 self.loop._sock_sendfile_native_impl(fut, sock.fileno(),
649 sock, fileno,
650 1000, None, len(self.DATA),
651 1000)
652 with self.assertRaises(KeyError):
653 self.loop._selector.get_key(sock)
654 exc = fut.exception()
655 self.assertIs(exc, err)
656 self.assertEqual(1000, self.file.tell())
657
658
659 class UnixReadPipeTransportTests(test_utils.TestCase):
660
661 def setUp(self):
662 super().setUp()
663 self.loop = self.new_test_loop()
664 self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
665 self.pipe = mock.Mock(spec_set=io.RawIOBase)
666 self.pipe.fileno.return_value = 5
667
668 blocking_patcher = mock.patch('os.set_blocking')
669 blocking_patcher.start()
670 self.addCleanup(blocking_patcher.stop)
671
672 fstat_patcher = mock.patch('os.fstat')
673 m_fstat = fstat_patcher.start()
674 st = mock.Mock()
675 st.st_mode = stat.S_IFIFO
676 m_fstat.return_value = st
677 self.addCleanup(fstat_patcher.stop)
678
679 def read_pipe_transport(self, waiter=None):
680 transport = unix_events._UnixReadPipeTransport(self.loop, self.pipe,
681 self.protocol,
682 waiter=waiter)
683 self.addCleanup(close_pipe_transport, transport)
684 return transport
685
686 def test_ctor(self):
687 waiter = self.loop.create_future()
688 tr = self.read_pipe_transport(waiter=waiter)
689 self.loop.run_until_complete(waiter)
690
691 self.protocol.connection_made.assert_called_with(tr)
692 self.loop.assert_reader(5, tr._read_ready)
693 self.assertIsNone(waiter.result())
694
695 @mock.patch('os.read')
696 def test__read_ready(self, m_read):
697 tr = self.read_pipe_transport()
698 m_read.return_value = b'data'
699 tr._read_ready()
700
701 m_read.assert_called_with(5, tr.max_size)
702 self.protocol.data_received.assert_called_with(b'data')
703
704 @mock.patch('os.read')
705 def test__read_ready_eof(self, m_read):
706 tr = self.read_pipe_transport()
707 m_read.return_value = b''
708 tr._read_ready()
709
710 m_read.assert_called_with(5, tr.max_size)
711 self.assertFalse(self.loop.readers)
712 test_utils.run_briefly(self.loop)
713 self.protocol.eof_received.assert_called_with()
714 self.protocol.connection_lost.assert_called_with(None)
715
716 @mock.patch('os.read')
717 def test__read_ready_blocked(self, m_read):
718 tr = self.read_pipe_transport()
719 m_read.side_effect = BlockingIOError
720 tr._read_ready()
721
722 m_read.assert_called_with(5, tr.max_size)
723 test_utils.run_briefly(self.loop)
724 self.assertFalse(self.protocol.data_received.called)
725
726 @mock.patch('asyncio.log.logger.error')
727 @mock.patch('os.read')
728 def test__read_ready_error(self, m_read, m_logexc):
729 tr = self.read_pipe_transport()
730 err = OSError()
731 m_read.side_effect = err
732 tr._close = mock.Mock()
733 tr._read_ready()
734
735 m_read.assert_called_with(5, tr.max_size)
736 tr._close.assert_called_with(err)
737 m_logexc.assert_called_with(
738 test_utils.MockPattern(
739 'Fatal read error on pipe transport'
740 '\nprotocol:.*\ntransport:.*'),
741 exc_info=(OSError, MOCK_ANY, MOCK_ANY))
742
743 @mock.patch('os.read')
744 def test_pause_reading(self, m_read):
745 tr = self.read_pipe_transport()
746 m = mock.Mock()
747 self.loop.add_reader(5, m)
748 tr.pause_reading()
749 self.assertFalse(self.loop.readers)
750
751 @mock.patch('os.read')
752 def test_resume_reading(self, m_read):
753 tr = self.read_pipe_transport()
754 tr.pause_reading()
755 tr.resume_reading()
756 self.loop.assert_reader(5, tr._read_ready)
757
758 @mock.patch('os.read')
759 def test_close(self, m_read):
760 tr = self.read_pipe_transport()
761 tr._close = mock.Mock()
762 tr.close()
763 tr._close.assert_called_with(None)
764
765 @mock.patch('os.read')
766 def test_close_already_closing(self, m_read):
767 tr = self.read_pipe_transport()
768 tr._closing = True
769 tr._close = mock.Mock()
770 tr.close()
771 self.assertFalse(tr._close.called)
772
773 @mock.patch('os.read')
774 def test__close(self, m_read):
775 tr = self.read_pipe_transport()
776 err = object()
777 tr._close(err)
778 self.assertTrue(tr.is_closing())
779 self.assertFalse(self.loop.readers)
780 test_utils.run_briefly(self.loop)
781 self.protocol.connection_lost.assert_called_with(err)
782
783 def test__call_connection_lost(self):
784 tr = self.read_pipe_transport()
785 self.assertIsNotNone(tr._protocol)
786 self.assertIsNotNone(tr._loop)
787
788 err = None
789 tr._call_connection_lost(err)
790 self.protocol.connection_lost.assert_called_with(err)
791 self.pipe.close.assert_called_with()
792
793 self.assertIsNone(tr._protocol)
794 self.assertIsNone(tr._loop)
795
796 def test__call_connection_lost_with_err(self):
797 tr = self.read_pipe_transport()
798 self.assertIsNotNone(tr._protocol)
799 self.assertIsNotNone(tr._loop)
800
801 err = OSError()
802 tr._call_connection_lost(err)
803 self.protocol.connection_lost.assert_called_with(err)
804 self.pipe.close.assert_called_with()
805
806 self.assertIsNone(tr._protocol)
807 self.assertIsNone(tr._loop)
808
809 def test_pause_reading_on_closed_pipe(self):
810 tr = self.read_pipe_transport()
811 tr.close()
812 test_utils.run_briefly(self.loop)
813 self.assertIsNone(tr._loop)
814 tr.pause_reading()
815
816 def test_pause_reading_on_paused_pipe(self):
817 tr = self.read_pipe_transport()
818 tr.pause_reading()
819 # the second call should do nothing
820 tr.pause_reading()
821
822 def test_resume_reading_on_closed_pipe(self):
823 tr = self.read_pipe_transport()
824 tr.close()
825 test_utils.run_briefly(self.loop)
826 self.assertIsNone(tr._loop)
827 tr.resume_reading()
828
829 def test_resume_reading_on_paused_pipe(self):
830 tr = self.read_pipe_transport()
831 # the pipe is not paused
832 # resuming should do nothing
833 tr.resume_reading()
834
835
836 class UnixWritePipeTransportTests(test_utils.TestCase):
837
838 def setUp(self):
839 super().setUp()
840 self.loop = self.new_test_loop()
841 self.protocol = test_utils.make_test_protocol(asyncio.BaseProtocol)
842 self.pipe = mock.Mock(spec_set=io.RawIOBase)
843 self.pipe.fileno.return_value = 5
844
845 blocking_patcher = mock.patch('os.set_blocking')
846 blocking_patcher.start()
847 self.addCleanup(blocking_patcher.stop)
848
849 fstat_patcher = mock.patch('os.fstat')
850 m_fstat = fstat_patcher.start()
851 st = mock.Mock()
852 st.st_mode = stat.S_IFSOCK
853 m_fstat.return_value = st
854 self.addCleanup(fstat_patcher.stop)
855
856 def write_pipe_transport(self, waiter=None):
857 transport = unix_events._UnixWritePipeTransport(self.loop, self.pipe,
858 self.protocol,
859 waiter=waiter)
860 self.addCleanup(close_pipe_transport, transport)
861 return transport
862
863 def test_ctor(self):
864 waiter = self.loop.create_future()
865 tr = self.write_pipe_transport(waiter=waiter)
866 self.loop.run_until_complete(waiter)
867
868 self.protocol.connection_made.assert_called_with(tr)
869 self.loop.assert_reader(5, tr._read_ready)
870 self.assertEqual(None, waiter.result())
871
872 def test_can_write_eof(self):
873 tr = self.write_pipe_transport()
874 self.assertTrue(tr.can_write_eof())
875
876 @mock.patch('os.write')
877 def test_write(self, m_write):
878 tr = self.write_pipe_transport()
879 m_write.return_value = 4
880 tr.write(b'data')
881 m_write.assert_called_with(5, b'data')
882 self.assertFalse(self.loop.writers)
883 self.assertEqual(bytearray(), tr._buffer)
884
885 @mock.patch('os.write')
886 def test_write_no_data(self, m_write):
887 tr = self.write_pipe_transport()
888 tr.write(b'')
889 self.assertFalse(m_write.called)
890 self.assertFalse(self.loop.writers)
891 self.assertEqual(bytearray(b''), tr._buffer)
892
893 @mock.patch('os.write')
894 def test_write_partial(self, m_write):
895 tr = self.write_pipe_transport()
896 m_write.return_value = 2
897 tr.write(b'data')
898 self.loop.assert_writer(5, tr._write_ready)
899 self.assertEqual(bytearray(b'ta'), tr._buffer)
900
901 @mock.patch('os.write')
902 def test_write_buffer(self, m_write):
903 tr = self.write_pipe_transport()
904 self.loop.add_writer(5, tr._write_ready)
905 tr._buffer = bytearray(b'previous')
906 tr.write(b'data')
907 self.assertFalse(m_write.called)
908 self.loop.assert_writer(5, tr._write_ready)
909 self.assertEqual(bytearray(b'previousdata'), tr._buffer)
910
911 @mock.patch('os.write')
912 def test_write_again(self, m_write):
913 tr = self.write_pipe_transport()
914 m_write.side_effect = BlockingIOError()
915 tr.write(b'data')
916 m_write.assert_called_with(5, bytearray(b'data'))
917 self.loop.assert_writer(5, tr._write_ready)
918 self.assertEqual(bytearray(b'data'), tr._buffer)
919
920 @mock.patch('asyncio.unix_events.logger')
921 @mock.patch('os.write')
922 def test_write_err(self, m_write, m_log):
923 tr = self.write_pipe_transport()
924 err = OSError()
925 m_write.side_effect = err
926 tr._fatal_error = mock.Mock()
927 tr.write(b'data')
928 m_write.assert_called_with(5, b'data')
929 self.assertFalse(self.loop.writers)
930 self.assertEqual(bytearray(), tr._buffer)
931 tr._fatal_error.assert_called_with(
932 err,
933 'Fatal write error on pipe transport')
934 self.assertEqual(1, tr._conn_lost)
935
936 tr.write(b'data')
937 self.assertEqual(2, tr._conn_lost)
938 tr.write(b'data')
939 tr.write(b'data')
940 tr.write(b'data')
941 tr.write(b'data')
942 # This is a bit overspecified. :-(
943 m_log.warning.assert_called_with(
944 'pipe closed by peer or os.write(pipe, data) raised exception.')
945 tr.close()
946
947 @mock.patch('os.write')
948 def test_write_close(self, m_write):
949 tr = self.write_pipe_transport()
950 tr._read_ready() # pipe was closed by peer
951
952 tr.write(b'data')
953 self.assertEqual(tr._conn_lost, 1)
954 tr.write(b'data')
955 self.assertEqual(tr._conn_lost, 2)
956
957 def test__read_ready(self):
958 tr = self.write_pipe_transport()
959 tr._read_ready()
960 self.assertFalse(self.loop.readers)
961 self.assertFalse(self.loop.writers)
962 self.assertTrue(tr.is_closing())
963 test_utils.run_briefly(self.loop)
964 self.protocol.connection_lost.assert_called_with(None)
965
966 @mock.patch('os.write')
967 def test__write_ready(self, m_write):
968 tr = self.write_pipe_transport()
969 self.loop.add_writer(5, tr._write_ready)
970 tr._buffer = bytearray(b'data')
971 m_write.return_value = 4
972 tr._write_ready()
973 self.assertFalse(self.loop.writers)
974 self.assertEqual(bytearray(), tr._buffer)
975
976 @mock.patch('os.write')
977 def test__write_ready_partial(self, m_write):
978 tr = self.write_pipe_transport()
979 self.loop.add_writer(5, tr._write_ready)
980 tr._buffer = bytearray(b'data')
981 m_write.return_value = 3
982 tr._write_ready()
983 self.loop.assert_writer(5, tr._write_ready)
984 self.assertEqual(bytearray(b'a'), tr._buffer)
985
986 @mock.patch('os.write')
987 def test__write_ready_again(self, m_write):
988 tr = self.write_pipe_transport()
989 self.loop.add_writer(5, tr._write_ready)
990 tr._buffer = bytearray(b'data')
991 m_write.side_effect = BlockingIOError()
992 tr._write_ready()
993 m_write.assert_called_with(5, bytearray(b'data'))
994 self.loop.assert_writer(5, tr._write_ready)
995 self.assertEqual(bytearray(b'data'), tr._buffer)
996
997 @mock.patch('os.write')
998 def test__write_ready_empty(self, m_write):
999 tr = self.write_pipe_transport()
1000 self.loop.add_writer(5, tr._write_ready)
1001 tr._buffer = bytearray(b'data')
1002 m_write.return_value = 0
1003 tr._write_ready()
1004 m_write.assert_called_with(5, bytearray(b'data'))
1005 self.loop.assert_writer(5, tr._write_ready)
1006 self.assertEqual(bytearray(b'data'), tr._buffer)
1007
1008 @mock.patch('asyncio.log.logger.error')
1009 @mock.patch('os.write')
1010 def test__write_ready_err(self, m_write, m_logexc):
1011 tr = self.write_pipe_transport()
1012 self.loop.add_writer(5, tr._write_ready)
1013 tr._buffer = bytearray(b'data')
1014 m_write.side_effect = err = OSError()
1015 tr._write_ready()
1016 self.assertFalse(self.loop.writers)
1017 self.assertFalse(self.loop.readers)
1018 self.assertEqual(bytearray(), tr._buffer)
1019 self.assertTrue(tr.is_closing())
1020 m_logexc.assert_not_called()
1021 self.assertEqual(1, tr._conn_lost)
1022 test_utils.run_briefly(self.loop)
1023 self.protocol.connection_lost.assert_called_with(err)
1024
1025 @mock.patch('os.write')
1026 def test__write_ready_closing(self, m_write):
1027 tr = self.write_pipe_transport()
1028 self.loop.add_writer(5, tr._write_ready)
1029 tr._closing = True
1030 tr._buffer = bytearray(b'data')
1031 m_write.return_value = 4
1032 tr._write_ready()
1033 self.assertFalse(self.loop.writers)
1034 self.assertFalse(self.loop.readers)
1035 self.assertEqual(bytearray(), tr._buffer)
1036 self.protocol.connection_lost.assert_called_with(None)
1037 self.pipe.close.assert_called_with()
1038
1039 @mock.patch('os.write')
1040 def test_abort(self, m_write):
1041 tr = self.write_pipe_transport()
1042 self.loop.add_writer(5, tr._write_ready)
1043 self.loop.add_reader(5, tr._read_ready)
1044 tr._buffer = [b'da', b'ta']
1045 tr.abort()
1046 self.assertFalse(m_write.called)
1047 self.assertFalse(self.loop.readers)
1048 self.assertFalse(self.loop.writers)
1049 self.assertEqual([], tr._buffer)
1050 self.assertTrue(tr.is_closing())
1051 test_utils.run_briefly(self.loop)
1052 self.protocol.connection_lost.assert_called_with(None)
1053
1054 def test__call_connection_lost(self):
1055 tr = self.write_pipe_transport()
1056 self.assertIsNotNone(tr._protocol)
1057 self.assertIsNotNone(tr._loop)
1058
1059 err = None
1060 tr._call_connection_lost(err)
1061 self.protocol.connection_lost.assert_called_with(err)
1062 self.pipe.close.assert_called_with()
1063
1064 self.assertIsNone(tr._protocol)
1065 self.assertIsNone(tr._loop)
1066
1067 def test__call_connection_lost_with_err(self):
1068 tr = self.write_pipe_transport()
1069 self.assertIsNotNone(tr._protocol)
1070 self.assertIsNotNone(tr._loop)
1071
1072 err = OSError()
1073 tr._call_connection_lost(err)
1074 self.protocol.connection_lost.assert_called_with(err)
1075 self.pipe.close.assert_called_with()
1076
1077 self.assertIsNone(tr._protocol)
1078 self.assertIsNone(tr._loop)
1079
1080 def test_close(self):
1081 tr = self.write_pipe_transport()
1082 tr.write_eof = mock.Mock()
1083 tr.close()
1084 tr.write_eof.assert_called_with()
1085
1086 # closing the transport twice must not fail
1087 tr.close()
1088
1089 def test_close_closing(self):
1090 tr = self.write_pipe_transport()
1091 tr.write_eof = mock.Mock()
1092 tr._closing = True
1093 tr.close()
1094 self.assertFalse(tr.write_eof.called)
1095
1096 def test_write_eof(self):
1097 tr = self.write_pipe_transport()
1098 tr.write_eof()
1099 self.assertTrue(tr.is_closing())
1100 self.assertFalse(self.loop.readers)
1101 test_utils.run_briefly(self.loop)
1102 self.protocol.connection_lost.assert_called_with(None)
1103
1104 def test_write_eof_pending(self):
1105 tr = self.write_pipe_transport()
1106 tr._buffer = [b'data']
1107 tr.write_eof()
1108 self.assertTrue(tr.is_closing())
1109 self.assertFalse(self.protocol.connection_lost.called)
1110
1111
1112 class TestFunctional(unittest.TestCase):
1113
1114 def setUp(self):
1115 self.loop = asyncio.new_event_loop()
1116 asyncio.set_event_loop(self.loop)
1117
1118 def tearDown(self):
1119 self.loop.close()
1120 asyncio.set_event_loop(None)
1121
1122 def test_add_reader_invalid_argument(self):
1123 def assert_raises():
1124 return self.assertRaisesRegex(ValueError, r'Invalid file object')
1125
1126 cb = lambda: None
1127
1128 with assert_raises():
1129 self.loop.add_reader(object(), cb)
1130 with assert_raises():
1131 self.loop.add_writer(object(), cb)
1132
1133 with assert_raises():
1134 self.loop.remove_reader(object())
1135 with assert_raises():
1136 self.loop.remove_writer(object())
1137
1138 def test_add_reader_or_writer_transport_fd(self):
1139 def assert_raises():
1140 return self.assertRaisesRegex(
1141 RuntimeError,
1142 r'File descriptor .* is used by transport')
1143
1144 async def runner():
1145 tr, pr = await self.loop.create_connection(
1146 lambda: asyncio.Protocol(), sock=rsock)
1147
1148 try:
1149 cb = lambda: None
1150
1151 with assert_raises():
1152 self.loop.add_reader(rsock, cb)
1153 with assert_raises():
1154 self.loop.add_reader(rsock.fileno(), cb)
1155
1156 with assert_raises():
1157 self.loop.remove_reader(rsock)
1158 with assert_raises():
1159 self.loop.remove_reader(rsock.fileno())
1160
1161 with assert_raises():
1162 self.loop.add_writer(rsock, cb)
1163 with assert_raises():
1164 self.loop.add_writer(rsock.fileno(), cb)
1165
1166 with assert_raises():
1167 self.loop.remove_writer(rsock)
1168 with assert_raises():
1169 self.loop.remove_writer(rsock.fileno())
1170
1171 finally:
1172 tr.close()
1173
1174 rsock, wsock = socket.socketpair()
1175 try:
1176 self.loop.run_until_complete(runner())
1177 finally:
1178 rsock.close()
1179 wsock.close()
1180
1181
1182 @support.requires_fork()
1183 class TestFork(unittest.TestCase):
1184
1185 def test_fork_not_share_current_task(self):
1186 loop = object()
1187 task = object()
1188 asyncio._set_running_loop(loop)
1189 self.addCleanup(asyncio._set_running_loop, None)
1190 asyncio.tasks._enter_task(loop, task)
1191 self.addCleanup(asyncio.tasks._leave_task, loop, task)
1192 self.assertIs(asyncio.current_task(), task)
1193 r, w = os.pipe()
1194 self.addCleanup(os.close, r)
1195 self.addCleanup(os.close, w)
1196 pid = os.fork()
1197 if pid == 0:
1198 # child
1199 try:
1200 asyncio._set_running_loop(loop)
1201 current_task = asyncio.current_task()
1202 if current_task is None:
1203 os.write(w, b'NO TASK')
1204 else:
1205 os.write(w, b'TASK:' + str(id(current_task)).encode())
1206 except BaseException as e:
1207 os.write(w, b'ERROR:' + ascii(e).encode())
1208 finally:
1209 asyncio._set_running_loop(None)
1210 os._exit(0)
1211 else:
1212 # parent
1213 result = os.read(r, 100)
1214 self.assertEqual(result, b'NO TASK')
1215 wait_process(pid, exitcode=0)
1216
1217 def test_fork_not_share_event_loop(self):
1218 # The forked process should not share the event loop with the parent
1219 loop = object()
1220 asyncio._set_running_loop(loop)
1221 self.assertIs(asyncio.get_running_loop(), loop)
1222 self.addCleanup(asyncio._set_running_loop, None)
1223 r, w = os.pipe()
1224 self.addCleanup(os.close, r)
1225 self.addCleanup(os.close, w)
1226 pid = os.fork()
1227 if pid == 0:
1228 # child
1229 try:
1230 loop = asyncio.get_event_loop()
1231 os.write(w, b'LOOP:' + str(id(loop)).encode())
1232 except RuntimeError:
1233 os.write(w, b'NO LOOP')
1234 except BaseException as e:
1235 os.write(w, b'ERROR:' + ascii(e).encode())
1236 finally:
1237 os._exit(0)
1238 else:
1239 # parent
1240 result = os.read(r, 100)
1241 self.assertEqual(result, b'NO LOOP')
1242 wait_process(pid, exitcode=0)
1243
1244 @hashlib_helper.requires_hashdigest('md5')
1245 @support.skip_if_sanitizer("TSAN doesn't support threads after fork", thread=True)
1246 def test_fork_signal_handling(self):
1247 self.addCleanup(multiprocessing_cleanup_tests)
1248
1249 # Sending signal to the forked process should not affect the parent
1250 # process
1251 ctx = multiprocessing.get_context('fork')
1252 manager = ctx.Manager()
1253 self.addCleanup(manager.shutdown)
1254 child_started = manager.Event()
1255 child_handled = manager.Event()
1256 parent_handled = manager.Event()
1257
1258 def child_main():
1259 def on_sigterm(*args):
1260 child_handled.set()
1261 sys.exit()
1262
1263 signal.signal(signal.SIGTERM, on_sigterm)
1264 child_started.set()
1265 while True:
1266 time.sleep(1)
1267
1268 async def main():
1269 loop = asyncio.get_running_loop()
1270 loop.add_signal_handler(signal.SIGTERM, lambda *args: parent_handled.set())
1271
1272 process = ctx.Process(target=child_main)
1273 process.start()
1274 child_started.wait()
1275 os.kill(process.pid, signal.SIGTERM)
1276 process.join(timeout=support.SHORT_TIMEOUT)
1277
1278 async def func():
1279 await asyncio.sleep(0.1)
1280 return 42
1281
1282 # Test parent's loop is still functional
1283 self.assertEqual(await asyncio.create_task(func()), 42)
1284
1285 asyncio.run(main())
1286
1287 child_handled.wait(timeout=support.SHORT_TIMEOUT)
1288 self.assertFalse(parent_handled.is_set())
1289 self.assertTrue(child_handled.is_set())
1290
1291 @hashlib_helper.requires_hashdigest('md5')
1292 @support.skip_if_sanitizer("TSAN doesn't support threads after fork", thread=True)
1293 def test_fork_asyncio_run(self):
1294 self.addCleanup(multiprocessing_cleanup_tests)
1295
1296 ctx = multiprocessing.get_context('fork')
1297 manager = ctx.Manager()
1298 self.addCleanup(manager.shutdown)
1299 result = manager.Value('i', 0)
1300
1301 async def child_main():
1302 await asyncio.sleep(0.1)
1303 result.value = 42
1304
1305 process = ctx.Process(target=lambda: asyncio.run(child_main()))
1306 process.start()
1307 process.join()
1308
1309 self.assertEqual(result.value, 42)
1310
1311 @hashlib_helper.requires_hashdigest('md5')
1312 @support.skip_if_sanitizer("TSAN doesn't support threads after fork", thread=True)
1313 def test_fork_asyncio_subprocess(self):
1314 self.addCleanup(multiprocessing_cleanup_tests)
1315
1316 ctx = multiprocessing.get_context('fork')
1317 manager = ctx.Manager()
1318 self.addCleanup(manager.shutdown)
1319 result = manager.Value('i', 1)
1320
1321 async def child_main():
1322 proc = await asyncio.create_subprocess_exec(sys.executable, '-c', 'pass')
1323 result.value = await proc.wait()
1324
1325 process = ctx.Process(target=lambda: asyncio.run(child_main()))
1326 process.start()
1327 process.join()
1328
1329 self.assertEqual(result.value, 0)
1330
1331 if __name__ == '__main__':
1332 unittest.main()