| 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() |