Debian Codegraph @

Lib/test/test_asyncio/test_windows_utils.py

raw
1 """Tests for window_utils"""
2
3 import sys
4 import unittest
5 import warnings
6
7 if sys.platform != 'win32':
8 raise unittest.SkipTest('Windows only')
9
10 import _overlapped
11 import _winapi
12
13 import asyncio
14 from asyncio import windows_utils
15 from test import support
16
17
18 def tearDownModule():
19 asyncio.events._set_event_loop_policy(None)
20
21
22 class PipeTests(unittest.TestCase):
23
24 def test_pipe_overlapped(self):
25 h1, h2 = windows_utils.pipe(overlapped=(True, True))
26 try:
27 ov1 = _overlapped.Overlapped()
28 self.assertFalse(ov1.pending)
29 self.assertEqual(ov1.error, 0)
30
31 ov1.ReadFile(h1, 100)
32 self.assertTrue(ov1.pending)
33 self.assertEqual(ov1.error, _winapi.ERROR_IO_PENDING)
34 ERROR_IO_INCOMPLETE = 996
35 try:
36 ov1.getresult()
37 except OSError as e:
38 self.assertEqual(e.winerror, ERROR_IO_INCOMPLETE)
39 else:
40 raise RuntimeError('expected ERROR_IO_INCOMPLETE')
41
42 ov2 = _overlapped.Overlapped()
43 self.assertFalse(ov2.pending)
44 self.assertEqual(ov2.error, 0)
45
46 ov2.WriteFile(h2, b"hello")
47 self.assertIn(ov2.error, {0, _winapi.ERROR_IO_PENDING})
48
49 res = _winapi.WaitForMultipleObjects([ov2.event], False, 100)
50 self.assertEqual(res, _winapi.WAIT_OBJECT_0)
51
52 self.assertFalse(ov1.pending)
53 self.assertEqual(ov1.error, ERROR_IO_INCOMPLETE)
54 self.assertFalse(ov2.pending)
55 self.assertIn(ov2.error, {0, _winapi.ERROR_IO_PENDING})
56 self.assertEqual(ov1.getresult(), b"hello")
57 finally:
58 _winapi.CloseHandle(h1)
59 _winapi.CloseHandle(h2)
60
61 def test_pipe_handle(self):
62 h, _ = windows_utils.pipe(overlapped=(True, True))
63 _winapi.CloseHandle(_)
64 p = windows_utils.PipeHandle(h)
65 self.assertEqual(p.fileno(), h)
66 self.assertEqual(p.handle, h)
67
68 # check garbage collection of p closes handle
69 with warnings.catch_warnings():
70 warnings.filterwarnings("ignore", "", ResourceWarning)
71 del p
72 support.gc_collect()
73 try:
74 _winapi.CloseHandle(h)
75 except OSError as e:
76 self.assertEqual(e.winerror, 6) # ERROR_INVALID_HANDLE
77 else:
78 raise RuntimeError('expected ERROR_INVALID_HANDLE')
79
80 def test_pipe_handle_close_after_external_close(self):
81 # gh-149388: PipeHandle.close() must clear ``_handle`` before calling
82 # CloseHandle so that if CloseHandle raises on a stale handle the
83 # PipeHandle is still marked closed and __del__ / subsequent close()
84 # calls are silent no-ops.
85 h1, h2 = windows_utils.pipe(overlapped=(False, False))
86 try:
87 p = windows_utils.PipeHandle(h1)
88 # Simulate an external close of the underlying handle (e.g.
89 # a finalizer race or a concurrent close on the same object).
90 _winapi.CloseHandle(p.handle)
91 # First close() still propagates the OSError from CloseHandle,
92 # but must clear ``_handle`` first.
93 with self.assertRaises(OSError):
94 p.close()
95 self.assertIsNone(p.handle)
96 # Second close() is a no-op.
97 p.close()
98 # __del__ through GC is also a silent no-op — no unraisable.
99 del p
100 support.gc_collect()
101 finally:
102 _winapi.CloseHandle(h2)
103
104
105 class PopenTests(unittest.TestCase):
106
107 def test_popen(self):
108 command = r"""if 1:
109 import sys
110 s = sys.stdin.readline()
111 sys.stdout.write(s.upper())
112 sys.stderr.write('stderr')
113 """
114 msg = b"blah\n"
115
116 p = windows_utils.Popen([sys.executable, '-c', command],
117 stdin=windows_utils.PIPE,
118 stdout=windows_utils.PIPE,
119 stderr=windows_utils.PIPE)
120
121 for f in [p.stdin, p.stdout, p.stderr]:
122 self.assertIsInstance(f, windows_utils.PipeHandle)
123
124 ovin = _overlapped.Overlapped()
125 ovout = _overlapped.Overlapped()
126 overr = _overlapped.Overlapped()
127
128 ovin.WriteFile(p.stdin.handle, msg)
129 ovout.ReadFile(p.stdout.handle, 100)
130 overr.ReadFile(p.stderr.handle, 100)
131
132 events = [ovin.event, ovout.event, overr.event]
133 # Super-long timeout for slow buildbots.
134 res = _winapi.WaitForMultipleObjects(events, True,
135 int(support.SHORT_TIMEOUT * 1000))
136 self.assertEqual(res, _winapi.WAIT_OBJECT_0)
137 self.assertFalse(ovout.pending)
138 self.assertFalse(overr.pending)
139 self.assertFalse(ovin.pending)
140
141 self.assertEqual(ovin.getresult(), len(msg))
142 out = ovout.getresult().rstrip()
143 err = overr.getresult().rstrip()
144
145 self.assertGreater(len(out), 0)
146 self.assertGreater(len(err), 0)
147 # allow for partial reads...
148 self.assertStartsWith(msg.upper().rstrip(), out)
149 self.assertStartsWith(b"stderr", err)
150
151 # The context manager calls wait() and closes resources
152 with p:
153 pass
154
155
156 class OverlappedRefleakTests(unittest.TestCase):
157
158 def test_wsasendto_failure(self):
159 ov = _overlapped.Overlapped()
160 buf = bytearray(4096)
161 with self.assertRaises(OSError):
162 ov.WSASendTo(0x1234, buf, 0, ("127.0.0.1", 1))
163
164 def test_wsarecvfrom_failure(self):
165 ov = _overlapped.Overlapped()
166 with self.assertRaises(OSError):
167 ov.WSARecvFrom(0x1234, 1024, 0)
168
169 def test_wsarecvfrominto_failure(self):
170 ov = _overlapped.Overlapped()
171 buf = bytearray(4096)
172 with self.assertRaises(OSError):
173 ov.WSARecvFromInto(0x1234, buf, len(buf), 0)
174
175
176 if __name__ == '__main__':
177 unittest.main()