diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index b194aa423..3cf159519 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -128,8 +128,79 @@ jobs:
name: dist-wheels-${{ matrix.os }}-${{ matrix.python }}-${{ matrix.cibw_arch }}
path: wheelhouse/*.whl
+ build-windows-wheels:
+ needs: validate-release-request
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ include:
+ - os: windows-latest
+ arch: AMD64
+ build: "cp38-* cp39-* cp310-* cp311-* cp312-* cp313-* cp314-* cp314t-*"
+ constraint: ""
+ - os: windows-11-arm
+ arch: ARM64
+ build: "cp311-* cp312-* cp313-* cp314-* cp314t-*"
+ constraint: PIP_CONSTRAINT=${{ github.workspace }}\constraints-windows-arm64.txt
+
+ env:
+ PIP_DISABLE_PIP_VERSION_CHECK: 1
+
+ steps:
+ - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+ with:
+ fetch-depth: 50
+ submodules: true
+
+ - uses: pypa/cibuildwheel@7c619efba910c04005a835b110b057fc28fd6e93 # v3.2.0
+ env:
+ CIBW_BUILD_VERBOSITY: 1
+ CIBW_BUILD: ${{ matrix.build }}
+ CIBW_ARCHS: ${{ matrix.arch }}
+ CIBW_ENVIRONMENT: ${{ matrix.constraint }}
+
+ - name: Verify Windows ARM64 wheels
+ if: matrix.arch == 'ARM64'
+ shell: pwsh
+ run: |
+ Add-Type -AssemblyName System.IO.Compression.FileSystem
+ Get-ChildItem wheelhouse/*.whl | ForEach-Object {
+ $archive = [System.IO.Compression.ZipFile]::OpenRead($_.FullName)
+ try {
+ $nativeEntry = $archive.Entries |
+ Where-Object FullName -Like 'uvloop/*.pyd' |
+ Select-Object -First 1
+ if (-not $nativeEntry) {
+ throw "Missing native extension in $($_.Name)"
+ }
+
+ $reader = [System.IO.BinaryReader]::new($nativeEntry.Open())
+ try {
+ $bytes = $reader.ReadBytes([int]$nativeEntry.Length)
+ } finally {
+ $reader.Dispose()
+ }
+ $peOffset = [BitConverter]::ToInt32($bytes, 0x3c)
+ $machine = [BitConverter]::ToUInt16($bytes, $peOffset + 4)
+ if ($machine -ne 0xAA64) {
+ throw ('Expected ARM64 PE machine 0xAA64 in {0}, found 0x{1:X4}' -f $_.Name, $machine)
+ }
+ } finally {
+ $archive.Dispose()
+ }
+ }
+
+ - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+ with:
+ name: dist-wheels-windows-${{ matrix.arch }}
+ path: wheelhouse/*.whl
+
publish:
- needs: [build-sdist, build-wheels]
+ needs:
+ - build-sdist
+ - build-wheels
+ - build-windows-wheels
runs-on: ubuntu-latest
steps:
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 1a77628cf..5be56acda 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -24,8 +24,18 @@ jobs:
- "3.13"
- "3.14"
- "3.14t"
- # TODO: (Vizonex) windows-11-arm
os: [ubuntu-latest, macos-latest, windows-latest]
+ include:
+ - os: windows-11-arm
+ python-version: "3.11.9"
+ - os: windows-11-arm
+ python-version: "3.12.10"
+ - os: windows-11-arm
+ python-version: "3.13.15"
+ - os: windows-11-arm
+ python-version: "3.14.7"
+ - os: windows-11-arm
+ python-version: "3.14t"
env:
PIP_DISABLE_PIP_VERSION_CHECK: 1
@@ -58,6 +68,11 @@ jobs:
run: |
brew install gnu-sed libtool autoconf automake
+ - name: Install Windows ARM64 test prerequisite
+ if: matrix.os == 'windows-11-arm' && steps.release.outputs.version == 0
+ run: |
+ pip install --only-binary cryptography --constraint constraints-windows-arm64.txt cryptography
+
- name: Install Python Deps
if: steps.release.outputs.version == 0
run: |
diff --git a/Makefile b/Makefile
index d5336fd72..442d29cad 100644
--- a/Makefile
+++ b/Makefile
@@ -3,6 +3,10 @@
PYTHON ?= python
ROOT = $(dir $(realpath $(firstword $(MAKEFILE_LIST))))
+DEBUG_BUILD = --debug
+ifeq ($(OS),Windows_NT)
+DEBUG_BUILD =
+endif
_default: compile
@@ -34,14 +38,12 @@ setup-build:
compile: clean setup-build
-# NOTE: --debug will not work on windows since it asks for a non-existant _d.lib file.
-# TODO: Fix workflows for missing debug binaries in the future.
debug: clean
- $(PYTHON) setup.py build_ext --inplace \
+ $(PYTHON) setup.py build_ext --inplace $(DEBUG_BUILD) \
--cython-always \
--cython-annotate \
--cython-directives="linetrace=True" \
- --define UVLOOP_DEBUG --define CYTHON_TRACE --define CYTHON_TRACE_NOGIL
+ --define UVLOOP_DEBUG,CYTHON_TRACE,CYTHON_TRACE_NOGIL
docs:
diff --git a/constraints-windows-arm64.txt b/constraints-windows-arm64.txt
new file mode 100644
index 000000000..7637ae07b
--- /dev/null
+++ b/constraints-windows-arm64.txt
@@ -0,0 +1 @@
+cryptography==46.0.3
diff --git a/setup.py b/setup.py
index c88735280..f9d1c0739 100644
--- a/setup.py
+++ b/setup.py
@@ -4,10 +4,6 @@
if vi < (3, 8):
raise RuntimeError('uvloop requires Python 3.8 or greater')
-# TODO: Remove Completely because Winloop Author is mergeing his project to uvloop.
-# if sys.platform in ('win32', 'cygwin', 'cli'):
-# raise RuntimeError('uvloop does not support Windows at the moment')
-
import os
import os.path
import pathlib
@@ -30,10 +26,6 @@
LIBUV_DIR = str(_ROOT / 'vendor' / 'libuv')
LIBUV_BUILD_DIR = str(_ROOT / 'build' / 'libuv-{}'.format(MACHINE))
-# NOTE: Mingw was added by another contributor in the winloop project.
-MINGW = bool(os.environ.get("MINGW_PREFIX", ""))
-
-
def _libuv_build_env():
env = os.environ.copy()
@@ -88,9 +80,7 @@ class uvloop_build_ext(build_ext):
def initialize_options(self):
super().initialize_options()
- # Use mingw if prefix was given for it otherwise it
- # will always be false.
- self.use_system_libuv = MINGW
+ self.use_system_libuv = False
self.cython_always = False
self.cython_annotate = None
self.cython_directives = None
@@ -125,21 +115,17 @@ def finalize_options(self):
import Cython
except ImportError:
raise RuntimeError(
- "please install {} to compile uvloop from source".format(
- CYTHON_DEPENDENCY
- )
- )
+ 'please install {} to compile uvloop from source'.format(
+ CYTHON_DEPENDENCY))
cython_dep = Requirement(CYTHON_DEPENDENCY)
if not cython_dep.specifier.contains(Cython.__version__):
raise RuntimeError(
- "uvloop requires {}, got Cython=={}".format(
+ 'uvloop requires {}, got Cython=={}'.format(
CYTHON_DEPENDENCY, Cython.__version__
- )
- )
+ ))
from Cython.Build import cythonize
-
directives = {}
if self.cython_directives:
@@ -201,7 +187,7 @@ def build_libuv(self):
cwd=LIBUV_BUILD_DIR, env=env, check=True)
def build_extensions(self):
- if sys.platform == "win32" and not MINGW:
+ if sys.platform == "win32":
path = pathlib.Path("vendor", "libuv", "src")
c_files = [p.as_posix() for p in path.iterdir() if p.suffix == ".c"]
c_files += [
@@ -249,41 +235,26 @@ def build_extensions(self):
raise RuntimeError(
'unable to read the version from uvloop/_version.py')
-if sys.platform == "win32":
- from Cython.Build import cythonize
- from Cython.Compiler.Main import default_options
-
- default_options["compile_time_env"] = dict(DEFAULT_FREELIST_SIZE=250)
- ext = cythonize(
- [
- Extension(
- "uvloop.loop",
- sources=["uvloop/loop.pyx"],
- include_dirs=[]
- if MINGW
- else [
- "vendor/libuv/src",
- "vendor/libuv/src/win",
- "vendor/libuv/include",
- ],
- # subset of libuv Windows libraries:
- extra_link_args=[
- (f"-l{lib}" if MINGW else f"{lib}.lib")
- for lib in (
- "Shell32",
- "Ws2_32",
- "Advapi32",
- "iphlpapi",
- "Userenv",
- "User32",
- "Dbghelp",
- "Ole32",
- )
- ],
- define_macros=[("WIN32_LEAN_AND_MEAN", 1), ("_WIN32_WINNT", "0x0602")],
- ),
- ]
- )
+if sys.platform == 'win32':
+ ext = [
+ Extension(
+ 'uvloop.loop',
+ sources=['uvloop/loop.pyx'],
+ include_dirs=[
+ 'vendor/libuv/src',
+ 'vendor/libuv/src/win',
+ 'vendor/libuv/include',
+ ],
+ libraries=[
+ 'Shell32', 'Ws2_32', 'Advapi32', 'iphlpapi',
+ 'Userenv', 'User32', 'Dbghelp', 'Ole32',
+ ],
+ define_macros=[
+ ('WIN32_LEAN_AND_MEAN', 1),
+ ('_WIN32_WINNT', '0x0602'),
+ ],
+ ),
+ ]
else:
ext = [
Extension(
@@ -297,14 +268,17 @@ def build_extensions(self):
setup_requires = []
-if not (_ROOT / "uvloop" / "loop.c").exists() or "--cython-always" in sys.argv:
+if not (_ROOT / 'uvloop' / 'loop.c').exists() or '--cython-always' in sys.argv:
# No Cython output, require Cython to build.
setup_requires.append(CYTHON_DEPENDENCY)
-
+
setup(
version=VERSION,
- cmdclass={"sdist": uvloop_sdist, "build_ext": uvloop_build_ext},
+ cmdclass={
+ 'sdist': uvloop_sdist,
+ 'build_ext': uvloop_build_ext
+ },
ext_modules=ext,
setup_requires=setup_requires,
)
diff --git a/tests/__main__.py b/tests/__main__.py
index d64b09158..9db8f5015 100644
--- a/tests/__main__.py
+++ b/tests/__main__.py
@@ -10,7 +10,7 @@ def suite():
return test_suite
-if __name__ == "__main__":
+if __name__ == '__main__':
runner = unittest.runner.TextTestRunner()
result = runner.run(suite())
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_aiohttp.py b/tests/test_aiohttp.py
index 1de644202..514d01778 100644
--- a/tests/test_aiohttp.py
+++ b/tests/test_aiohttp.py
@@ -18,18 +18,18 @@ class _TestAioHTTP:
def test_aiohttp_basic_1(self):
- PAYLOAD = "It Works!
" * 10000
+ PAYLOAD = 'It Works!
' * 10000
async def on_request(request):
return aiohttp.web.Response(text=PAYLOAD)
asyncio.set_event_loop(self.loop)
app = aiohttp.web.Application()
- app.router.add_get("/", on_request)
+ app.router.add_get('/', on_request)
runner = aiohttp.web.AppRunner(app)
self.loop.run_until_complete(runner.setup())
- site = aiohttp.web.TCPSite(runner, "0.0.0.0", "0")
+ site = aiohttp.web.TCPSite(runner, '0.0.0.0', '0')
self.loop.run_until_complete(site.start())
port = site._server.sockets[0].getsockname()[1]
@@ -37,9 +37,10 @@ async def test():
# Make sure we're using the correct event loop.
self.assertIs(asyncio.get_event_loop(), self.loop)
- for addr in (("localhost", port), ("127.0.0.1", port)):
+ for addr in (('localhost', port),
+ ('127.0.0.1', port)):
async with aiohttp.ClientSession() as client:
- async with client.get("http://{}:{}".format(*addr)) as r:
+ async with client.get('http://{}:{}'.format(*addr)) as r:
self.assertEqual(r.status, 200)
result = await r.text()
self.assertEqual(result, PAYLOAD)
@@ -48,43 +49,42 @@ async def test():
self.loop.run_until_complete(runner.cleanup())
def test_aiohttp_graceful_shutdown(self):
- if self.implementation == "asyncio" and sys.version_info >= (3, 12, 0):
+ if self.implementation == 'asyncio' and sys.version_info >= (3, 12, 0):
# In Python 3.12.0, asyncio.Server.wait_closed() waits for all
# existing connections to complete, before aiohttp sends
# on_shutdown signals.
# https://github.com/aio-libs/aiohttp/issues/7675#issuecomment-1752143748
# https://github.com/python/cpython/pull/98582
- raise unittest.SkipTest("bug in aiohttp: #7675")
+ raise unittest.SkipTest('bug in aiohttp: #7675')
async def websocket_handler(request):
ws = aiohttp.web.WebSocketResponse()
await ws.prepare(request)
- request.app["websockets"].add(ws)
+ request.app['websockets'].add(ws)
try:
async for msg in ws:
await ws.send_str(msg.data)
finally:
- request.app["websockets"].discard(ws)
+ request.app['websockets'].discard(ws)
return ws
async def on_shutdown(app):
- for ws in set(app["websockets"]):
+ for ws in set(app['websockets']):
await ws.close(
code=aiohttp.WSCloseCode.GOING_AWAY,
- message="Server shutdown",
- )
+ message='Server shutdown')
asyncio.set_event_loop(self.loop)
app = aiohttp.web.Application()
- app.router.add_get("/", websocket_handler)
+ app.router.add_get('/', websocket_handler)
app.on_shutdown.append(on_shutdown)
- app["websockets"] = weakref.WeakSet()
+ app['websockets'] = weakref.WeakSet()
runner = aiohttp.web.AppRunner(app)
self.loop.run_until_complete(runner.setup())
site = aiohttp.web.TCPSite(
runner,
- "0.0.0.0",
+ '0.0.0.0',
0,
# https://github.com/aio-libs/aiohttp/pull/7188
shutdown_timeout=0.1,
@@ -95,8 +95,7 @@ async def on_shutdown(app):
async def client():
async with aiohttp.ClientSession() as client:
async with client.ws_connect(
- "http://127.0.0.1:{}".format(port)
- ) as ws:
+ 'http://127.0.0.1:{}'.format(port)) as ws:
await ws.send_str("hello")
async for msg in ws:
assert msg.data == "hello"
diff --git a/tests/test_base.py b/tests/test_base.py
index 4112a08ab..69970cb8c 100644
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -38,7 +38,7 @@ def test_close(self):
def test_handle_weakref(self):
wd = weakref.WeakValueDictionary()
h = self.loop.call_soon(lambda: None)
- wd["h"] = h # Would fail without __weakref__ slot.
+ wd['h'] = h # Would fail without __weakref__ slot.
def test_call_soon_1(self):
calls = []
@@ -50,9 +50,9 @@ def cb(inc):
self.loop.call_soon(cb, 10)
h = self.loop.call_soon(cb, 100)
- self.assertIn(".cb", repr(h))
+ self.assertIn('.cb', repr(h))
h.cancel()
- self.assertIn("cancelled", repr(h))
+ self.assertIn('cancelled', repr(h))
self.loop.call_soon(cb, 1)
@@ -105,32 +105,29 @@ def cb():
self.assertIsNone(context)
self.loop.run_until_complete(asyncio.sleep(0.05))
- self.assertIs(type(context["exception"]), ZeroDivisionError)
- self.assertTrue(
- context["message"].startswith("Exception in callback")
- )
+ self.assertIs(type(context['exception']), ZeroDivisionError)
+ self.assertTrue(context['message'].startswith(
+ 'Exception in callback'))
if debug:
- tb = context["source_traceback"]
- self.assertEqual(tb[-1 + stack_adj].name, "run_test")
+ tb = context['source_traceback']
+ self.assertEqual(tb[-1 + stack_adj].name, 'run_test')
else:
- self.assertFalse("source_traceback" in context)
+ self.assertFalse('source_traceback' in context)
del context
for debug in (True, False):
for meth_name, meth, stack_adj in (
- ("call_soon", self.loop.call_soon, 0),
- (
- "call_later", # `-1` accounts for lambda
- lambda *args: self.loop.call_later(0.01, *args),
- -1,
- ),
+ ('call_soon',
+ self.loop.call_soon, 0),
+ ('call_later', # `-1` accounts for lambda
+ lambda *args: self.loop.call_later(0.01, *args), -1)
):
with self.subTest(debug=debug, meth_name=meth_name):
run_test(debug, meth, stack_adj)
- @unittest.skip("asyncio has rounding errors.")
+ @unittest.skipIf(sys.platform == 'win32', 'asyncio rounding errors')
def test_now_update(self):
async def run():
st = self.loop.time()
@@ -153,9 +150,9 @@ def cb(inc=10, stop=False):
# canceled right away
h = self.loop.call_later(0.05, cb, 100, True)
- self.assertIn(".cb", repr(h))
+ self.assertIn('.cb', repr(h))
h.cancel()
- self.assertIn("cancelled", repr(h))
+ self.assertIn('cancelled', repr(h))
self.loop.call_later(0.05, cb, 1, True)
self.loop.call_later(1000, cb, 1000) # shouldn't be called
@@ -176,10 +173,6 @@ def cb(inc=10, stop=False):
else:
self.assertGreater(finished - started, 0.04)
- # @unittest.skipIf(
- # (sys.version_info >= (3, 8)) and (sys.platform == "win32"),
- # "rounding errors are still present in 3.8+",
- # )
def test_call_later_2(self):
# Test that loop.call_later triggers an update of
# libuv cached time.
@@ -192,7 +185,7 @@ async def main():
started = time.monotonic()
self.loop.run_until_complete(main())
delta = time.monotonic() - started
- self.assertGreater(delta, 0.011)
+ self.assertGreater(delta, 0.019)
def test_call_later_3(self):
# a memory leak regression test
@@ -219,11 +212,11 @@ def cb(arg):
calls.append(arg)
self.loop.stop()
- self.loop.call_later(-1, cb, "a")
+ self.loop.call_later(-1, cb, 'a')
self.loop.run_forever()
- self.assertEqual(calls, ["a"])
+ self.assertEqual(calls, ['a'])
- @unittest.skip("uvloop works fine but asyncio doesn't")
+ @unittest.skipIf(sys.platform == 'win32', 'asyncio rounding errors')
def test_call_later_rounding(self):
# Refs #233, call_later() and call_at() shouldn't call cb early
@@ -238,11 +231,10 @@ def cb():
self.assertGreaterEqual(finished - started, 69)
def test_call_at(self):
- if os.environ.get("TRAVIS_OS_NAME") or os.environ.get(
- "GITHUB_WORKFLOW"
- ):
+ if (os.environ.get('TRAVIS_OS_NAME')
+ or os.environ.get('GITHUB_WORKFLOW')):
# Time seems to be really unpredictable on Travis.
- raise unittest.SkipTest("time is not monotonic on CI")
+ raise unittest.SkipTest('time is not monotonic on CI')
i = 0
@@ -272,10 +264,8 @@ def cb():
loop.set_debug(debug)
if debug:
- msg = (
- "Non-thread-safe operation invoked on an "
- "event loop other than the current one"
- )
+ msg = ("Non-thread-safe operation invoked on an "
+ "event loop other than the current one")
with self.assertRaisesRegex(RuntimeError, msg):
loop.call_soon(cb)
with self.assertRaisesRegex(RuntimeError, msg):
@@ -337,11 +327,11 @@ def cb(arg):
called.append(arg)
async def runner():
- await self.loop.run_in_executor(None, cb, "a")
+ await self.loop.run_in_executor(None, cb, 'a')
self.loop.run_until_complete(runner())
- self.assertEqual(called, ["a"])
+ self.assertEqual(called, ['a'])
def test_set_debug(self):
self.loop.set_debug(True)
@@ -350,19 +340,20 @@ def test_set_debug(self):
self.assertFalse(self.loop.get_debug())
def test_run_until_complete_type_error(self):
- self.assertRaises(TypeError, self.loop.run_until_complete, "blah")
+ self.assertRaises(
+ TypeError, self.loop.run_until_complete, 'blah')
def test_run_until_complete_loop(self):
task = asyncio.Future()
other_loop = self.new_loop()
self.addCleanup(other_loop.close)
- self.assertRaises(ValueError, other_loop.run_until_complete, task)
+ self.assertRaises(
+ ValueError, other_loop.run_until_complete, task)
def test_run_until_complete_error(self):
async def foo():
- raise ValueError("aaa")
-
- with self.assertRaisesRegex(ValueError, "aaa"):
+ raise ValueError('aaa')
+ with self.assertRaisesRegex(ValueError, 'aaa'):
self.loop.run_until_complete(foo())
def test_run_until_complete_loop_orphan_future_close_loop(self):
@@ -403,54 +394,54 @@ def func():
self.assertTrue(func.called)
def test_debug_slow_callbacks(self):
- logger = logging.getLogger("asyncio")
+ logger = logging.getLogger('asyncio')
self.loop.set_debug(True)
self.loop.slow_callback_duration = 0.2
self.loop.call_soon(lambda: time.sleep(0.3))
- with mock.patch.object(logger, "warning") as log:
+ with mock.patch.object(logger, 'warning') as log:
self.loop.run_until_complete(asyncio.sleep(0))
self.assertEqual(log.call_count, 1)
# format message
msg = log.call_args[0][0] % log.call_args[0][1:]
- self.assertIn("Executing = (3, 12):
- raise unittest.SkipTest("This is having problems on 3.12+")
- if self.implementation == "asyncio" and sys.version_info >= (3, 11, 0):
+ raise unittest.SkipTest('This is having problems on 3.12+')
+ if self.implementation == 'asyncio' and sys.version_info >= (3, 11, 0):
# TODO(fantix): fix for 3.11
- raise unittest.SkipTest("should pass on 3.11")
+ raise unittest.SkipTest('should pass on 3.11')
async def test(proto, cvar, ssl_sock, **_):
def close():
- cvar.set("closing")
+ cvar.set('closing')
proto.transport.close()
inner = await proto.connection_made_fut
self.assertEqual(inner, "inner")
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
self.loop.call_soon(close)
else:
# asyncio doesn't have the flushing phase
@@ -493,7 +475,8 @@ def close():
# put the incoming data on-hold
proto.transport.pause_reading()
# send data
- await self.loop.run_in_executor(None, ssl_sock.send, b"hello")
+ await self.loop.run_in_executor(None,
+ ssl_sock.send, b'hello')
# After gh-105836 run_in_executor may resolve without
# yielding. This is very noticeable when PYTHONASYNCIODEBUG
# is set. Hence, we yield explicitly so that the sent data
@@ -513,21 +496,12 @@ def close():
self.assertEqual(proto.connection_lost_ctx, "inner")
self.assertFalse(proto.data_received_fut.done())
- self._run_server_test(test, use_ssl="yes")
+ self._run_server_test(test, use_ssl='yes')
- @unittest.skipIf(sys.platform == "win32", "skip for now, Its a todo.")
+ @unittest.skipIf(sys.platform == 'win32', 'not supported on Windows')
def test_create_connection_protocol(self):
- async def test(
- cvar,
- proto,
- addr,
- sslctx,
- client_sslctx,
- family,
- use_sock,
- use_ssl,
- use_tcp,
- ):
+ async def test(cvar, proto, addr, sslctx, client_sslctx, family,
+ use_sock, use_ssl, use_tcp):
ss = socket.socket(family)
ss.bind(addr)
ss.listen(1)
@@ -541,52 +515,44 @@ def accept():
async def write_over():
cvar.set("write_over")
count = 0
- if use_ssl:
- proto.transport.set_write_buffer_limits(high=256, low=128)
- while not proto.transport.get_write_buffer_size():
- proto.transport.write(b"q" * 16384)
- count += 1
- else:
- proto.transport.write(b"q" * 16384)
- proto.transport.set_write_buffer_limits(high=256, low=128)
+ proto.transport.set_write_buffer_limits(high=256, low=128)
+ while not proto.transport.get_write_buffer_size():
+ proto.transport.write(b'q' * 16384)
count += 1
return count
s = self.loop.run_in_executor(None, accept)
try:
- method = (
- "create_connection"
- if use_tcp
- else "create_unix_connection"
- )
+ method = ('create_connection' if use_tcp
+ else 'create_unix_connection')
params = {}
if use_sock:
cs = socket.socket(family)
cs.connect(addr)
- params["sock"] = cs
+ params['sock'] = cs
if use_ssl:
- params["server_hostname"] = "127.0.0.1"
+ params['server_hostname'] = '127.0.0.1'
elif use_tcp:
- params["host"] = addr[0]
- params["port"] = addr[1]
+ params['host'] = addr[0]
+ params['port'] = addr[1]
else:
- params["path"] = addr
+ params['path'] = addr
if use_ssl:
- params["server_hostname"] = "127.0.0.1"
+ params['server_hostname'] = '127.0.0.1'
if use_ssl:
- params["ssl"] = client_sslctx
+ params['ssl'] = client_sslctx
await getattr(self.loop, method)(lambda: proto, **params)
s = await s
inner = await proto.connection_made_fut
self.assertEqual(inner, "inner")
- await self.loop.run_in_executor(None, s.send, b"data")
+ await self.loop.run_in_executor(None, s.send, b'data')
inner = await proto.data_received_fut
self.assertEqual(inner, "inner")
- if self.implementation != "asyncio":
+ if self.implementation != 'asyncio':
# asyncio bug
count = await self.loop.create_task(write_over())
inner = await proto.pause_writing_fut
@@ -597,7 +563,7 @@ async def write_over():
inner = await proto.resume_writing_fut
self.assertEqual(inner, "inner")
- if use_ssl and self.implementation != "asyncio":
+ if use_ssl and self.implementation != 'asyncio':
await self.loop.run_in_executor(None, s.unwrap)
else:
s.shutdown(socket.SHUT_WR)
@@ -611,23 +577,14 @@ async def write_over():
ss.close()
proto.transport.close()
- self._run_test(test, use_sock="both", use_ssl="both")
+ self._run_test(test, use_sock='both', use_ssl='both')
def test_start_tls(self):
- if self.implementation == "asyncio":
- raise unittest.SkipTest("this seems to be a bug in asyncio")
-
- async def test(
- cvar,
- proto,
- addr,
- sslctx,
- client_sslctx,
- family,
- ssl_over_ssl,
- use_tcp,
- **_,
- ):
+ if self.implementation == 'asyncio':
+ raise unittest.SkipTest('this seems to be a bug in asyncio')
+
+ async def test(cvar, proto, addr, sslctx, client_sslctx, family,
+ ssl_over_ssl, use_tcp, **_):
ss = socket.socket(family)
ss.bind(addr)
ss.listen(1)
@@ -650,26 +607,22 @@ def accept():
inner = await proto.connection_made_fut
self.assertEqual(inner, "inner")
- cvar.set("start_tls")
+ cvar.set('start_tls')
transport = await self.loop.start_tls(
- proto.transport,
- proto,
- client_sslctx,
- server_hostname="127.0.0.1",
+ proto.transport, proto, client_sslctx,
+ server_hostname='127.0.0.1',
)
if ssl_over_ssl:
- cvar.set("start_tls_over_tls")
+ cvar.set('start_tls_over_tls')
transport = await self.loop.start_tls(
- transport,
- proto,
- client_sslctx,
- server_hostname="127.0.0.1",
+ transport, proto, client_sslctx,
+ server_hostname='127.0.0.1',
)
s = await s
- await self.loop.run_in_executor(None, s.send, b"data")
+ await self.loop.run_in_executor(None, s.send, b'data')
inner = await proto.data_received_fut
self.assertEqual(inner, "inner")
@@ -685,12 +638,14 @@ def accept():
if transport:
transport.close()
- self._run_test(test, use_ssl="yes", ssl_over_ssl="both")
+ self._run_test(test, use_ssl='yes', ssl_over_ssl='both')
+ @unittest.skipIf(
+ sys.platform == 'win32' and sys.version_info < (3, 11),
+ 'not supported before Python 3.11 on Windows')
def test_connect_accepted_socket(self):
- async def test(
- proto, addr, family, sslctx, client_sslctx, use_ssl, **_
- ):
+ async def test(proto, addr, family, sslctx, client_sslctx,
+ use_ssl, **_):
ss = socket.socket(family)
ss.bind(addr)
ss.listen(1)
@@ -702,11 +657,9 @@ async def test(
try:
if use_ssl:
cs = self.loop.run_in_executor(
- None, client_sslctx.wrap_socket, cs
- )
- await self.loop.connect_accepted_socket(
- lambda: proto, s, ssl=sslctx
- )
+ None, client_sslctx.wrap_socket, cs)
+ await self.loop.connect_accepted_socket(lambda: proto, s,
+ ssl=sslctx)
cs = await cs
else:
await self.loop.connect_accepted_socket(lambda: proto, s)
@@ -714,14 +667,13 @@ async def test(
inner = await proto.connection_made_fut
self.assertEqual(inner, "inner")
- await self.loop.run_in_executor(None, cs.send, b"data")
+ await self.loop.run_in_executor(None, cs.send, b'data')
inner = await proto.data_received_fut
self.assertEqual(inner, "inner")
- # uvloop comment: no asyncio problem on latest Windows
if use_ssl and (
- (sys.platform == "win32" and sys.version_info >= (3, 11))
- or self.implementation != "asyncio"
+ self.implementation != 'asyncio' or
+ sys.platform == 'win32'
):
await self.loop.run_in_executor(None, cs.unwrap)
else:
@@ -736,54 +688,27 @@ async def test(
proto.transport.close()
ss.close()
- # uvloop comment: switch to Selector loop on Windows
- if sys.platform == "win32" and sys.version_info < (3, 11):
- super().tearDown()
- from types import MethodType
+ self._run_test(test, use_ssl='both')
- policy = self.new_policy
-
- def tmp_policy(self):
- return asyncio.WindowsSelectorEventLoopPolicy()
-
- self.new_policy = MethodType(tmp_policy, tb.BaseTestCase)
- super().setUp()
- self._run_test(test, use_ssl="both")
- if sys.platform == "win32" and sys.version_info < (3, 11):
- super().tearDown()
- self.new_policy = policy
- super().setUp()
-
- @unittest.skipIf(sys.platform == "win32", "todo w.r.t. UnixTransports")
+ @unittest.skipIf(sys.platform == 'win32', 'requires Unix transports')
def test_subprocess_protocol(self):
- cvar = contextvars.ContextVar("cvar", default="outer")
+ cvar = contextvars.ContextVar('cvar', default='outer')
proto = _SubprocessProtocol(cvar, loop=self.loop)
async def test():
- self.assertEqual(cvar.get(), "outer")
- cvar.set("inner")
+ self.assertEqual(cvar.get(), 'outer')
+ cvar.set('inner')
await self.loop.subprocess_exec(
- lambda: proto,
- sys.executable,
- b"-c",
- b";".join(
- (
- b"import sys",
- b"data = sys.stdin.buffer.read()",
- b"sys.stdout.buffer.write(data)",
- )
- ),
- )
+ lambda: proto, sys.executable, b'-c',
+ b';'.join((b'import sys',
+ b'data = sys.stdin.buffer.read()',
+ b'sys.stdout.buffer.write(data)')))
try:
inner = await proto.connection_made_fut
self.assertEqual(inner, "inner")
- # uvloop comment: test fails at next line with:
- # ; the handler is closed
- # Reconsider use of (Read/Write)UnixTransport for uvloop
- # as these rely on Unix sockets.
- proto.transport.get_pipe_transport(0).write(b"data")
+ proto.transport.get_pipe_transport(0).write(b'data')
proto.transport.get_pipe_transport(0).write_eof()
inner = await proto.data_received_fut
self.assertEqual(inner, "inner")
@@ -792,12 +717,12 @@ async def test():
self.assertEqual(inner, "inner")
inner = await proto.process_exited_fut
- if self.implementation != "asyncio":
+ if self.implementation != 'asyncio':
# bug in asyncio
self.assertEqual(inner, "inner")
await proto.done
- if self.implementation != "asyncio":
+ if self.implementation != 'asyncio':
# bug in asyncio
self.assertEqual(proto.connection_lost_ctx, "inner")
finally:
@@ -806,35 +731,34 @@ async def test():
self.loop.run_until_complete(test())
def test_datagram_protocol(self):
- cvar = contextvars.ContextVar("cvar", default="outer")
+ cvar = contextvars.ContextVar('cvar', default='outer')
proto = _DatagramProtocol(cvar, loop=self.loop)
- server_addr = ("127.0.0.1", 8888)
- client_addr = ("127.0.0.1", 0)
+ server_addr = ('127.0.0.1', 8888)
+ client_addr = ('127.0.0.1', 0)
async def run():
- self.assertEqual(cvar.get(), "outer")
- cvar.set("inner")
+ self.assertEqual(cvar.get(), 'outer')
+ cvar.set('inner')
def close():
- cvar.set("closing")
+ cvar.set('closing')
proto.transport.close()
try:
await self.loop.create_datagram_endpoint(
- lambda: proto, local_addr=server_addr
- )
+ lambda: proto, local_addr=server_addr)
inner = await proto.connection_made_fut
self.assertEqual(inner, "inner")
s = socket.socket(socket.AF_INET, type=socket.SOCK_DGRAM)
s.bind(client_addr)
- s.sendto(b"data", server_addr)
+ s.sendto(b'data', server_addr)
inner = await proto.data_received_fut
self.assertEqual(inner, "inner")
self.loop.call_soon(close)
await proto.done
- if self.implementation != "asyncio":
+ if self.implementation != 'asyncio':
# bug in asyncio
self.assertEqual(proto.connection_lost_ctx, "inner")
finally:
diff --git a/tests/test_cython.py b/tests/test_cython.py
index ac85a9ace..5292fba73 100644
--- a/tests/test_cython.py
+++ b/tests/test_cython.py
@@ -13,11 +13,11 @@ def test_cython_coro_is_coroutine(self):
coro_fmt = _format_coroutine(coro)
self.assertTrue(
- coro_fmt.startswith("_test_coroutine_1() done")
- or coro_fmt.startswith("_test_coroutine_1() running")
+ coro_fmt.startswith('_test_coroutine_1() done')
+ or coro_fmt.startswith('_test_coroutine_1() running')
)
- self.assertEqual(_test_coroutine_1.__qualname__, "_test_coroutine_1")
- self.assertEqual(_test_coroutine_1.__name__, "_test_coroutine_1")
+ self.assertEqual(_test_coroutine_1.__qualname__, '_test_coroutine_1')
+ self.assertEqual(_test_coroutine_1.__name__, '_test_coroutine_1')
self.assertTrue(asyncio.iscoroutine(coro))
fut = asyncio.ensure_future(coro)
self.assertTrue(isinstance(fut, asyncio.Future))
diff --git a/tests/test_dealloc.py b/tests/test_dealloc.py
index f70e9b22d..66500a18c 100644
--- a/tests/test_dealloc.py
+++ b/tests/test_dealloc.py
@@ -28,7 +28,7 @@ def test_dealloc_1(self):
# any unwanted output.
async def test():
- prog = """\
+ prog = '''\
import uvloop
async def foo():
@@ -42,18 +42,13 @@ def main():
if __name__ == '__main__':
main()
- """
+ '''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
- cmd,
- b"-W",
- b"ignore",
- b"-c",
- prog,
+ cmd, b'-W', b'ignore', b'-c', prog,
stdout=subprocess.PIPE,
- stderr=subprocess.PIPE,
- )
+ stderr=subprocess.PIPE)
await proc.wait()
out = await proc.stdout.read()
@@ -62,5 +57,5 @@ def main():
return out, err
out, err = self.loop.run_until_complete(test())
- self.assertEqual(out, b"", "stdout is not empty")
- self.assertEqual(err, b"", "stderr is not empty")
+ self.assertEqual(out, b'', 'stdout is not empty')
+ self.assertEqual(err, b'', 'stderr is not empty')
diff --git a/tests/test_dns.py b/tests/test_dns.py
index 5826e6ccc..7e0a5f0f8 100644
--- a/tests/test_dns.py
+++ b/tests/test_dns.py
@@ -12,18 +12,19 @@ def patched_getaddrinfo(*args, **kwargs):
rv = []
result = socket.getaddrinfo(*args, **kwargs)
for af, sk, proto, canon_name, addr in result:
- if kwargs.get("flags", 0) & socket.AI_CANONNAME:
+ if kwargs.get('flags', 0) & socket.AI_CANONNAME:
if not canon_name:
canon_name = args[0]
if not isinstance(canon_name, str):
- canon_name = canon_name.decode("ascii")
+ canon_name = canon_name.decode('ascii')
elif canon_name:
- canon_name = ""
+ canon_name = ''
rv.append((af, sk, proto, canon_name, addr))
return rv
class BaseTestDNS:
+
def _test_getaddrinfo(self, *args, _patch=False, **kwargs):
err = None
try:
@@ -62,8 +63,7 @@ def _test_getnameinfo(self, *args, **kwargs):
try:
a2 = self.loop.run_until_complete(
- self.loop.getnameinfo(*args, **kwargs)
- )
+ self.loop.getnameinfo(*args, **kwargs))
except Exception as ex:
if err is not None:
if ex.__class__ is not err.__class__:
@@ -78,37 +78,32 @@ def _test_getnameinfo(self, *args, **kwargs):
self.assertEqual(a1, a2)
- @unittest.skip("Needs patches")
def test_getaddrinfo_1(self):
- self._test_getaddrinfo("example.com", 80)
- self._test_getaddrinfo("example.com", 80, type=socket.SOCK_STREAM)
+ self._test_getaddrinfo('example.com', 80)
+ self._test_getaddrinfo('example.com', 80, type=socket.SOCK_STREAM)
- @unittest.skip("Lists appear to differ.")
def test_getaddrinfo_2(self):
- self._test_getaddrinfo("example.com", 80, flags=socket.AI_CANONNAME)
+ self._test_getaddrinfo('example.com', 80, flags=socket.AI_CANONNAME)
def test_getaddrinfo_3(self):
- self._test_getaddrinfo("a" + "1" * 50 + ".wat", 800)
+ self._test_getaddrinfo('a' + '1' * 50 + '.wat', 800)
def test_getaddrinfo_4(self):
if sys.platform == "darwin":
raise unittest.SkipTest(
"randomly freezes for some strange reason."
)
- self._test_getaddrinfo("example.com", 80, family=-1)
- self._test_getaddrinfo(
- "example.com", 80, type=socket.SOCK_STREAM, family=-1
- )
+ self._test_getaddrinfo('example.com', 80, family=-1)
+ self._test_getaddrinfo('example.com', 80, type=socket.SOCK_STREAM,
+ family=-1)
- @unittest.skip("104.18.27.120 != 104.18.26.120")
def test_getaddrinfo_5(self):
- self._test_getaddrinfo("example.com", "80")
- self._test_getaddrinfo("example.com", "80", type=socket.SOCK_STREAM)
+ self._test_getaddrinfo('example.com', '80')
+ self._test_getaddrinfo('example.com', '80', type=socket.SOCK_STREAM)
- @unittest.skip("104.18.27.120 != 104.18.26.120")
def test_getaddrinfo_6(self):
- self._test_getaddrinfo(b"example.com", b"80")
- self._test_getaddrinfo(b"example.com", b"80", type=socket.SOCK_STREAM)
+ self._test_getaddrinfo(b'example.com', b'80')
+ self._test_getaddrinfo(b'example.com', b'80', type=socket.SOCK_STREAM)
def test_getaddrinfo_7(self):
self._test_getaddrinfo(None, 0)
@@ -140,78 +135,58 @@ def test_getaddrinfo_10(self):
self._test_getaddrinfo(None, None)
self._test_getaddrinfo(None, None, type=socket.SOCK_STREAM)
- @unittest.skip("104.18.27.120 != 104.18.26.120")
def test_getaddrinfo_11(self):
- self._test_getaddrinfo(b"example.com", "80")
- self._test_getaddrinfo(b"example.com", "80", type=socket.SOCK_STREAM)
+ self._test_getaddrinfo(b'example.com', '80')
+ self._test_getaddrinfo(b'example.com', '80', type=socket.SOCK_STREAM)
def test_getaddrinfo_12(self):
# musl always returns ai_canonname but we don't
- patch = self.implementation != "asyncio"
-
- self._test_getaddrinfo("127.0.0.1", "80")
- self._test_getaddrinfo(
- "127.0.0.1",
- "80",
- type=socket.SOCK_STREAM,
- # Winloop comment: we set proto=6 for TCP
- # on Windows to make socket.getaddrinfo()
- # return proto=6 as uvlib/loop does
- # We do so below, in eight places in total.
- proto=6 if sys.platform == "win32" else 0,
- _patch=patch,
- )
+ patch = self.implementation != 'asyncio'
+
+ self._test_getaddrinfo('127.0.0.1', '80')
+ self._test_getaddrinfo('127.0.0.1', '80', type=socket.SOCK_STREAM,
+ # Windows resolves TCP with protocol 6.
+ proto=6 if sys.platform == "win32" else 0,
+ _patch=patch)
def test_getaddrinfo_13(self):
# musl always returns ai_canonname but we don't
- patch = self.implementation != "asyncio"
+ patch = self.implementation != 'asyncio'
- self._test_getaddrinfo(b"127.0.0.1", b"80")
- self._test_getaddrinfo(
- b"127.0.0.1",
- b"80",
- type=socket.SOCK_STREAM,
- proto=6 if sys.platform == "win32" else 0,
- _patch=patch,
- )
+ self._test_getaddrinfo(b'127.0.0.1', b'80')
+ self._test_getaddrinfo(b'127.0.0.1', b'80', type=socket.SOCK_STREAM,
+ proto=6 if sys.platform == "win32" else 0,
+ _patch=patch)
def test_getaddrinfo_14(self):
# musl always returns ai_canonname but we don't
- patch = self.implementation != "asyncio"
+ patch = self.implementation != 'asyncio'
- self._test_getaddrinfo(b"127.0.0.1", b"http")
- self._test_getaddrinfo(
- b"127.0.0.1",
- b"http",
- type=socket.SOCK_STREAM,
- proto=6 if sys.platform == "win32" else 0,
- _patch=patch,
- )
+ self._test_getaddrinfo(b'127.0.0.1', b'http')
+ self._test_getaddrinfo(b'127.0.0.1', b'http', type=socket.SOCK_STREAM,
+ proto=6 if sys.platform == "win32" else 0,
+ _patch=patch)
def test_getaddrinfo_15(self):
# musl always returns ai_canonname but we don't
- patch = self.implementation != "asyncio"
+ patch = self.implementation != 'asyncio'
- self._test_getaddrinfo("127.0.0.1", "http")
- self._test_getaddrinfo(
- "127.0.0.1",
- "http",
- type=socket.SOCK_STREAM,
- proto=6 if sys.platform == "win32" else 0,
- _patch=patch,
- )
+ self._test_getaddrinfo('127.0.0.1', 'http')
+ self._test_getaddrinfo('127.0.0.1', 'http', type=socket.SOCK_STREAM,
+ proto=6 if sys.platform == "win32" else 0,
+ _patch=patch)
def test_getaddrinfo_16(self):
- self._test_getaddrinfo("localhost", "http")
- self._test_getaddrinfo("localhost", "http", type=socket.SOCK_STREAM)
+ self._test_getaddrinfo('localhost', 'http')
+ self._test_getaddrinfo('localhost', 'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_17(self):
- self._test_getaddrinfo(b"localhost", "http")
- self._test_getaddrinfo(b"localhost", "http", type=socket.SOCK_STREAM)
+ self._test_getaddrinfo(b'localhost', 'http')
+ self._test_getaddrinfo(b'localhost', 'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_18(self):
- self._test_getaddrinfo("localhost", b"http")
- self._test_getaddrinfo("localhost", b"http", type=socket.SOCK_STREAM)
+ self._test_getaddrinfo('localhost', b'http')
+ self._test_getaddrinfo('localhost', b'http', type=socket.SOCK_STREAM)
# Winloop comment: see comment in __static_getaddrinfo_pyaddr() in dns.pyx
# TODO: add Windows to that analysis handling two failing tests below.
@@ -219,97 +194,78 @@ def test_getaddrinfo_19(self):
# musl always returns ai_canonname while macOS never return for IPs,
# but we strictly follow the docs to use the AI_CANONNAME flag in a
# shortcut __static_getaddrinfo_pyaddr()
- patch = self.implementation != "asyncio"
-
- self._test_getaddrinfo("::1", 80)
- self._test_getaddrinfo(
- "::1",
- 80,
- type=socket.SOCK_STREAM,
- proto=6 if sys.platform == "win32" else 0,
- _patch=patch,
- )
+ patch = self.implementation != 'asyncio'
+
+ self._test_getaddrinfo('::1', 80)
+ self._test_getaddrinfo('::1', 80, type=socket.SOCK_STREAM,
+ proto=6 if sys.platform == "win32" else 0,
+ _patch=patch)
# Winloop comment: next one fails with '[::1]:80' vs '::1'
if sys.platform != "win32":
- self._test_getaddrinfo(
- "::1",
- 80,
- type=socket.SOCK_STREAM,
- proto=6 if sys.platform == "win32" else 0,
- flags=socket.AI_CANONNAME,
- _patch=patch,
- )
+ self._test_getaddrinfo('::1', 80, type=socket.SOCK_STREAM,
+ flags=socket.AI_CANONNAME, _patch=patch)
def test_getaddrinfo_20(self):
# musl always returns ai_canonname while macOS never return for IPs,
# but we strictly follow the docs to use the AI_CANONNAME flag in a
# shortcut __static_getaddrinfo_pyaddr()
- patch = self.implementation != "asyncio"
-
- self._test_getaddrinfo("127.0.0.1", 80)
- self._test_getaddrinfo(
- "127.0.0.1",
- 80,
- type=socket.SOCK_STREAM,
- proto=6 if sys.platform == "win32" else 0,
- _patch=patch,
- )
+ patch = self.implementation != 'asyncio'
+
+ self._test_getaddrinfo('127.0.0.1', 80)
+ self._test_getaddrinfo('127.0.0.1', 80, type=socket.SOCK_STREAM,
+ proto=6 if sys.platform == "win32" else 0,
+ _patch=patch)
# Winloop comment: next one fails with '127.0.0.1:80' vs '127.0.0.1'
if sys.platform != "win32":
- self._test_getaddrinfo(
- "127.0.0.1",
- 80,
- type=socket.SOCK_STREAM,
- proto=6 if sys.platform == "win32" else 0,
- flags=socket.AI_CANONNAME,
- _patch=patch,
- )
+ self._test_getaddrinfo('127.0.0.1', 80,
+ type=socket.SOCK_STREAM,
+ flags=socket.AI_CANONNAME, _patch=patch)
# https://github.com/libuv/libuv/security/advisories/GHSA-f74f-cvh7-c6q6
# See also: https://github.com/MagicStack/uvloop/pull/600
def test_getaddrinfo_21(self):
- payload = f"0x{'0' * 246}7f000001.example.com".encode("ascii")
+ payload = f'0x{"0" * 246}7f000001.example.com'.encode('ascii')
self._test_getaddrinfo(payload, 80)
self._test_getaddrinfo(payload, 80, type=socket.SOCK_STREAM)
def test_getaddrinfo_22(self):
- payload = f"0x{'0' * 246}7f000001.example.com"
+ payload = f'0x{"0" * 246}7f000001.example.com'
self._test_getaddrinfo(payload, 80)
self._test_getaddrinfo(payload, 80, type=socket.SOCK_STREAM)
######
def test_getnameinfo_1(self):
- self._test_getnameinfo(("127.0.0.1", 80), 0)
+ self._test_getnameinfo(('127.0.0.1', 80), 0)
def test_getnameinfo_2(self):
- self._test_getnameinfo(("127.0.0.1", 80, 1231231231213), 0)
+ self._test_getnameinfo(('127.0.0.1', 80, 1231231231213), 0)
def test_getnameinfo_3(self):
- self._test_getnameinfo(("127.0.0.1", 80, 0, 0), 0)
+ self._test_getnameinfo(('127.0.0.1', 80, 0, 0), 0)
def test_getnameinfo_4(self):
- self._test_getnameinfo(("::1", 80), 0)
+ self._test_getnameinfo(('::1', 80), 0)
def test_getnameinfo_5(self):
- self._test_getnameinfo(("localhost", 8080), 0)
+ self._test_getnameinfo(('localhost', 8080), 0)
class Test_UV_DNS(BaseTestDNS, tb.UVTestCase):
+
def test_getaddrinfo_close_loop(self):
# Test that we can close the loop with a running
# DNS query.
try:
# Check that we have internet connection
- socket.getaddrinfo("example.com", 80)
+ socket.getaddrinfo('example.com', 80)
except socket.error:
raise unittest.SkipTest
async def run():
fut = self.loop.create_task(
- self.loop.getaddrinfo("example.com", 80)
- )
+ self.loop.getaddrinfo('example.com', 80))
await asyncio.sleep(0)
fut.cancel()
self.loop.stop()
diff --git a/tests/test_executors.py b/tests/test_executors.py
index 597c38cdd..c793bb90b 100644
--- a/tests/test_executors.py
+++ b/tests/test_executors.py
@@ -29,9 +29,8 @@ async def run():
self.loop.run_until_complete(run())
@unittest.skipIf(
- multiprocessing.get_start_method(False) == "spawn",
- "no need to test on macOS where spawn is used instead of fork",
- )
+ multiprocessing.get_start_method(False) == 'spawn',
+ 'no need to test on macOS where spawn is used instead of fork')
def test_executors_process_pool_01(self):
self.run_pool_test(concurrent.futures.ProcessPoolExecutor)
diff --git a/tests/test_fs_event.py b/tests/test_fs_event.py
index a09768c0a..eaabfaa68 100644
--- a/tests/test_fs_event.py
+++ b/tests/test_fs_event.py
@@ -28,11 +28,11 @@ def test_fs_event_change(self):
path = os.path.join(self.tmp_dir, filename)
q = asyncio.Queue()
- with open(path, "wt") as f:
+ with open(path, 'wt') as f:
async def file_writer():
while True:
- f.write("hello uvloop\n")
+ f.write('hello uvloop\n')
f.flush()
x = await q.get()
if x is None:
@@ -60,6 +60,7 @@ def event_cb(ev_fname: bytes, evt: FileSystemEvent):
self.assertEqual(change_event_count, 4)
+ @unittest.skipIf(sys.platform == "win32", "broken")
def test_fs_event_rename(self):
orig_name = "hello_fs_event.txt"
new_name = "hello_fs_event_rename.txt"
@@ -67,10 +68,8 @@ def test_fs_event_rename(self):
event = asyncio.Event()
async def file_renamer():
- os.rename(
- os.path.join(self.tmp_dir, orig_name),
- os.path.join(self.tmp_dir, new_name),
- )
+ os.rename(os.path.join(self.tmp_dir, orig_name),
+ os.path.join(self.tmp_dir, new_name))
await event.wait()
def event_cb(ev_fname: bytes, evt: FileSystemEvent):
@@ -80,8 +79,8 @@ def event_cb(ev_fname: bytes, evt: FileSystemEvent):
if len(changed_set) == 0:
event.set()
- with open(os.path.join(self.tmp_dir, orig_name), "wt") as f:
- f.write("hello!")
+ with open(os.path.join(self.tmp_dir, orig_name), 'wt') as f:
+ f.write('hello!')
h = self.loop._monitor_fs(self.tmp_dir, event_cb)
self.loop.run_until_complete(asyncio.sleep(0.5)) # let monitor start
self.assertFalse(h.cancelled())
diff --git a/tests/test_pipes.py b/tests/test_pipes.py
index bb4e92bf6..7c43428ec 100644
--- a/tests/test_pipes.py
+++ b/tests/test_pipes.py
@@ -7,6 +7,7 @@
from uvloop import _testbase as tb
+
# All tests are copied from asyncio (mostly as-is)
@@ -14,7 +15,7 @@ class MyReadPipeProto(asyncio.Protocol):
done = None
def __init__(self, loop=None):
- self.state = ["INITIAL"]
+ self.state = ['INITIAL']
self.nbytes = 0
self.transport = None
if loop is not None:
@@ -22,22 +23,22 @@ def __init__(self, loop=None):
def connection_made(self, transport):
self.transport = transport
- assert self.state == ["INITIAL"], self.state
- self.state.append("CONNECTED")
+ assert self.state == ['INITIAL'], self.state
+ self.state.append('CONNECTED')
def data_received(self, data):
- assert self.state == ["INITIAL", "CONNECTED"], self.state
+ assert self.state == ['INITIAL', 'CONNECTED'], self.state
self.nbytes += len(data)
def eof_received(self):
- assert self.state == ["INITIAL", "CONNECTED"], self.state
- self.state.append("EOF")
+ assert self.state == ['INITIAL', 'CONNECTED'], self.state
+ self.state.append('EOF')
def connection_lost(self, exc):
- if "EOF" not in self.state:
- self.state.append("EOF") # It is okay if EOF is missed.
- assert self.state == ["INITIAL", "CONNECTED", "EOF"], self.state
- self.state.append("CLOSED")
+ if 'EOF' not in self.state:
+ self.state.append('EOF') # It is okay if EOF is missed.
+ assert self.state == ['INITIAL', 'CONNECTED', 'EOF'], self.state
+ self.state.append('CLOSED')
if self.done:
self.done.set_result(None)
@@ -47,19 +48,19 @@ class MyWritePipeProto(asyncio.BaseProtocol):
paused = False
def __init__(self, loop=None):
- self.state = "INITIAL"
+ self.state = 'INITIAL'
self.transport = None
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
- assert self.state == "INITIAL", self.state
- self.state = "CONNECTED"
+ assert self.state == 'INITIAL', self.state
+ self.state = 'CONNECTED'
def connection_lost(self, exc):
- assert self.state == "CONNECTED", self.state
- self.state = "CLOSED"
+ assert self.state == 'CONNECTED', self.state
+ self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
@@ -70,13 +71,6 @@ def resume_writing(self):
self.paused = False
-# Winloop comment: on Windows the asyncio event loop does not support pipes.
-# For instance, running in ..\Lib\test\test_asyncio the unit test
-# test_events.ProactorEventLoopTests.test_unclosed_pipe_transport
-# gives: ... skipped "Don't support pipes for Windows"
-# See also: https://github.com/python/cpython/issues/71019 from that:
-# "On Windows, sockets and named pipes are supported, on Linux fifo, sockets,
-# pipes and character devices are supported, no idea about macOS."
class _BasePipeTest:
def test_read_pipe(self):
if sys.platform == "win32" and self.is_asyncio_loop():
@@ -85,59 +79,58 @@ def test_read_pipe(self):
proto = MyReadPipeProto(loop=self.loop)
rpipe, wpipe = os.pipe()
- pipeobj = io.open(rpipe, "rb", 1024)
+ pipeobj = io.open(rpipe, 'rb', 1024)
async def connect():
- t, p = await self.loop.connect_read_pipe(lambda: proto, pipeobj)
+ t, p = await self.loop.connect_read_pipe(
+ lambda: proto, pipeobj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
- self.assertEqual(["INITIAL", "CONNECTED"], proto.state)
+ self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
- os.write(wpipe, b"1")
+ os.write(wpipe, b'1')
tb.run_until(self.loop, lambda: proto.nbytes >= 1)
self.assertEqual(1, proto.nbytes)
- os.write(wpipe, b"2345")
+ os.write(wpipe, b'2345')
tb.run_until(self.loop, lambda: proto.nbytes >= 5)
- self.assertEqual(["INITIAL", "CONNECTED"], proto.state)
+ self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
os.close(wpipe)
self.loop.run_until_complete(proto.done)
self.assertEqual(
- ["INITIAL", "CONNECTED", "EOF", "CLOSED"], proto.state
- )
+ ['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
- self.assertIsNotNone(proto.transport.get_extra_info("pipe"))
+ self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
@unittest.skipIf(sys.platform == "win32", "no os.openpty on Windows")
def test_read_pty_output(self):
proto = MyReadPipeProto(loop=self.loop)
master, slave = os.openpty()
- master_read_obj = io.open(master, "rb", 0)
+ master_read_obj = io.open(master, 'rb', 0)
async def connect():
t, p = await self.loop.connect_read_pipe(
- lambda: proto, master_read_obj
- )
+ lambda: proto, master_read_obj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
- self.assertEqual(["INITIAL", "CONNECTED"], proto.state)
+ self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
- os.write(slave, b"1")
+ os.write(slave, b'1')
tb.run_until(self.loop, lambda: proto.nbytes)
self.assertEqual(1, proto.nbytes)
- os.write(slave, b"2345")
+ os.write(slave, b'2345')
tb.run_until(self.loop, lambda: proto.nbytes >= 5)
- self.assertEqual(["INITIAL", "CONNECTED"], proto.state)
+ self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
# On Linux, transport raises EIO when slave is closed --
@@ -148,10 +141,10 @@ async def connect():
self.loop.run_until_complete(proto.done)
self.assertEqual(
- ["INITIAL", "CONNECTED", "EOF", "CLOSED"], proto.state
+ ['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state
)
# extra info is available
- self.assertIsNotNone(proto.transport.get_extra_info("pipe"))
+ self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
def test_write_pipe(self):
if sys.platform == "win32" and self.is_asyncio_loop():
@@ -162,16 +155,16 @@ def test_write_pipe(self):
rpipe, wpipe = os.pipe()
os.set_blocking(rpipe, False)
- pipeobj = io.open(wpipe, "wb", 1024)
+ pipeobj = io.open(wpipe, 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
- self.assertEqual("CONNECTED", proto.state)
+ self.assertEqual('CONNECTED', proto.state)
- transport.write(b"1")
+ transport.write(b'1')
data = bytearray()
@@ -184,61 +177,61 @@ def reader(data):
return len(data)
tb.run_until(self.loop, lambda: reader(data) >= 1)
- self.assertEqual(b"1", data)
+ self.assertEqual(b'1', data)
- transport.write(b"2345")
+ transport.write(b'2345')
tb.run_until(self.loop, lambda: reader(data) >= 5)
- self.assertEqual(b"12345", data)
- self.assertEqual("CONNECTED", proto.state)
+ self.assertEqual(b'12345', data)
+ self.assertEqual('CONNECTED', proto.state)
os.close(rpipe)
# extra info is available
- self.assertIsNotNone(proto.transport.get_extra_info("pipe"))
+ self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
- self.assertEqual("CLOSED", proto.state)
+ self.assertEqual('CLOSED', proto.state)
@unittest.skipIf(sys.platform == "win32", "no Unix sockets on Windows")
def test_write_pipe_disconnect_on_close(self):
rsock, wsock = socket.socketpair()
rsock.setblocking(False)
- pipeobj = io.open(wsock.detach(), "wb", 1024)
+ pipeobj = io.open(wsock.detach(), 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
- self.assertEqual("CONNECTED", proto.state)
+ self.assertEqual('CONNECTED', proto.state)
- transport.write(b"1")
+ transport.write(b'1')
data = self.loop.run_until_complete(self.loop.sock_recv(rsock, 1024))
- self.assertEqual(b"1", data)
+ self.assertEqual(b'1', data)
rsock.close()
self.loop.run_until_complete(proto.done)
- self.assertEqual("CLOSED", proto.state)
+ self.assertEqual('CLOSED', proto.state)
@unittest.skipIf(sys.platform == "win32", "no os.openpty on Windows")
def test_write_pty(self):
master, slave = os.openpty()
os.set_blocking(master, False)
- slave_write_obj = io.open(slave, "wb", 0)
+ slave_write_obj = io.open(slave, 'wb', 0)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
- self.assertEqual("CONNECTED", proto.state)
+ self.assertEqual('CONNECTED', proto.state)
- transport.write(b"1")
+ transport.write(b'1')
data = bytearray()
@@ -251,48 +244,48 @@ def reader(data):
return len(data)
tb.run_until(self.loop, lambda: reader(data) >= 1, timeout=10)
- self.assertEqual(b"1", data)
+ self.assertEqual(b'1', data)
- transport.write(b"2345")
+ transport.write(b'2345')
tb.run_until(self.loop, lambda: reader(data) >= 5, timeout=10)
- self.assertEqual(b"12345", data)
- self.assertEqual("CONNECTED", proto.state)
+ self.assertEqual(b'12345', data)
+ self.assertEqual('CONNECTED', proto.state)
os.close(master)
# extra info is available
- self.assertIsNotNone(proto.transport.get_extra_info("pipe"))
+ self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
- self.assertEqual("CLOSED", proto.state)
+ self.assertEqual('CLOSED', proto.state)
@unittest.skipIf(
sys.platform == "win32", "do not support pipes for Windows"
)
def test_write_buffer_full(self):
rpipe, wpipe = os.pipe()
- pipeobj = io.open(wpipe, "wb", 1024)
+ pipeobj = io.open(wpipe, 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
- self.assertEqual("CONNECTED", proto.state)
+ self.assertEqual('CONNECTED', proto.state)
for i in range(32):
- transport.write(b"x" * 32768)
+ transport.write(b'x' * 32768)
if proto.paused:
- transport.write(b"x" * 32768)
+ transport.write(b'x' * 32768)
break
else:
self.fail("Didn't reach a full buffer")
os.close(rpipe)
self.loop.run_until_complete(asyncio.wait_for(proto.done, 1))
- self.assertEqual("CLOSED", proto.state)
+ self.assertEqual('CLOSED', proto.state)
class Test_UV_Pipes(_BasePipeTest, tb.UVTestCase):
diff --git a/tests/test_process.py b/tests/test_process.py
index 5a67c4b5c..1053dc841 100644
--- a/tests/test_process.py
+++ b/tests/test_process.py
@@ -11,12 +11,7 @@
import time
import unittest
-try:
- import psutil
-
- SKIP_PSUTIL = False
-except ModuleNotFoundError:
- SKIP_PSUTIL = True
+import psutil
from uvloop import _testbase as tb
@@ -39,25 +34,23 @@ def __exit__(self, exc_type, exc_val, exc_tb):
class _TestProcess:
def get_num_fds(self):
- # Winloop comment: use num_handles() as a meaningful
- # substitute for num_fds() on Windows.
+ process = psutil.Process(os.getpid())
if sys.platform == "win32":
- # psutil.Process().num_handles only available on Windows
- return psutil.Process(os.getpid()).num_handles()
- else:
- # psutil.Process().num_fds only available on Unix
- return psutil.Process(os.getpid()).num_fds()
+ return process.num_handles()
+ return process.num_fds()
def test_process_env_1(self):
async def test():
if sys.platform != "win32":
- cmd = "echo $FOO$BAR"
+ cmd = 'echo $FOO$BAR'
else:
cmd = "echo %FOO%%BAR%"
- env = {"FOO": "sp", "BAR": "am"}
+ env = {'FOO': 'sp', 'BAR': 'am'}
proc = await asyncio.create_subprocess_shell(
- cmd, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE
- )
+ cmd,
+ env=env,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
out, _ = await proc.communicate()
self.assertEqual(out, b"spam" + NL)
@@ -68,21 +61,23 @@ async def test():
@unittest.skipIf(sys.platform == "win32", "no empty env on Windows really")
def test_process_env_2(self):
async def test():
- cmd = "env"
+ cmd = 'env'
env = {} # empty environment
proc = await asyncio.create_subprocess_exec(
- cmd, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE
- )
+ cmd,
+ env=env,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
out, _ = await proc.communicate()
- self.assertEqual(out, b"")
+ self.assertEqual(out, b'')
self.assertEqual(proc.returncode, 0)
self.loop.run_until_complete(test())
def test_process_cwd_1(self):
async def test():
- cmd = "pwd" if sys.platform != "win32" else "cd"
+ cmd = 'pwd' if sys.platform != "win32" else "cd"
if sys.platform == "win32" and sys.version_info < (3, 11, 0):
# Winloop comment: empty env={} gives
# "hp, ht, pid, tid = _winapi.CreateProcess(executable, args,
@@ -91,7 +86,7 @@ async def test():
env = None
else:
env = {}
- cwd = "/"
+ cwd = '/'
proc = await asyncio.create_subprocess_shell(
cmd,
cwd=cwd,
@@ -102,17 +97,17 @@ async def test():
out, _ = await proc.communicate()
if sys.platform != "win32":
- self.assertEqual(out, b"/\n")
+ self.assertEqual(out, b'/\n')
else:
self.assertIn(b"\\\r\n", out) # also contains drive label
self.assertEqual(proc.returncode, 0)
self.loop.run_until_complete(test())
- @unittest.skipUnless(hasattr(os, "fspath"), "no os.fspath()")
+ @unittest.skipUnless(hasattr(os, 'fspath'), 'no os.fspath()')
def test_process_cwd_2(self):
async def test():
- cmd = "pwd" if sys.platform != "win32" else "cd"
+ cmd = 'pwd' if sys.platform != "win32" else "cd"
if sys.platform == "win32" and sys.version_info < (3, 11, 0):
# Winloop comment: empty env={} gives
# "hp, ht, pid, tid = _winapi.CreateProcess(executable, args,
@@ -121,7 +116,7 @@ async def test():
env = None
else:
env = {}
- cwd = pathlib.Path("/")
+ cwd = pathlib.Path('/')
proc = await asyncio.create_subprocess_shell(
cmd,
cwd=cwd,
@@ -132,7 +127,7 @@ async def test():
out, _ = await proc.communicate()
if sys.platform != "win32":
- self.assertEqual(out, b"/\n")
+ self.assertEqual(out, b'/\n')
else:
self.assertIn(b"\\\r\n", out) # also contains drive label
self.assertEqual(proc.returncode, 0)
@@ -149,17 +144,13 @@ def test_process_preexec_fn_1(self):
async def test():
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
- cmd,
- b"-W",
- b"ignore",
- "-c",
+ cmd, b'-W', b'ignore', '-c',
'import os,sys;sys.stdout.write(os.getenv("FRUIT"))',
stdout=subprocess.PIPE,
- preexec_fn=lambda: os.putenv("FRUIT", "apple"),
- )
+ preexec_fn=lambda: os.putenv("FRUIT", "apple"))
out, _ = await proc.communicate()
- self.assertEqual(out, b"apple")
+ self.assertEqual(out, b'apple')
self.assertEqual(proc.returncode, 0)
self.loop.run_until_complete(test())
@@ -174,13 +165,8 @@ def raise_it():
async def test():
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
- cmd,
- b"-W",
- b"ignore",
- "-c",
- "import time; time.sleep(10)",
- preexec_fn=raise_it,
- )
+ cmd, b'-W', b'ignore', '-c', 'import time; time.sleep(10)',
+ preexec_fn=raise_it)
await proc.communicate()
@@ -188,26 +174,26 @@ async def test():
try:
self.loop.run_until_complete(test())
except subprocess.SubprocessError as ex:
- self.assertIn("preexec_fn", ex.args[0])
+ self.assertIn('preexec_fn', ex.args[0])
if ex.__cause__ is not None:
# uvloop will set __cause__
self.assertIs(type(ex.__cause__), ValueError)
- self.assertEqual(ex.__cause__.args[0], "spam")
+ self.assertEqual(ex.__cause__.args[0], 'spam')
else:
self.fail(
- "exception in preexec_fn did not propagate to the parent"
+ 'exception in preexec_fn did not propagate to the parent'
)
if time.time() - started > 5:
- self.fail("exception in preexec_fn did not kill the child process")
+ self.fail('exception in preexec_fn did not kill the child process')
def test_process_executable_1(self):
async def test():
proc = await asyncio.create_subprocess_exec(
- b"doesnotexist",
- b"-W",
- b"ignore",
- b"-c",
+ b'doesnotexist',
+ b'-W',
+ b'ignore',
+ b'-c',
b'print("spam")',
executable=sys.executable,
stdout=subprocess.PIPE,
@@ -222,9 +208,9 @@ def test_process_executable_2(self):
async def test():
proc = await asyncio.create_subprocess_exec(
pathlib.Path(sys.executable),
- b"-W",
- b"ignore",
- b"-c",
+ b'-W',
+ b'ignore',
+ b'-c',
b'print("spam")',
stdout=subprocess.PIPE,
)
@@ -234,20 +220,20 @@ async def test():
self.loop.run_until_complete(test())
- @unittest.skip("Currently having strange problems...")
+ @unittest.skipIf(sys.platform == 'win32', 'child PID differs on Windows')
def test_process_pid_1(self):
async def test():
- prog = """\
+ prog = '''\
import os
print(os.getpid())
- """
+ '''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd,
- b"-W",
- b"ignore",
- b"-c",
+ b'-W',
+ b'ignore',
+ b'-c',
prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
@@ -282,17 +268,13 @@ def handler(signum, frame):
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
- cmd,
- b"-W",
- b"ignore",
- b"-c",
- prog,
+ cmd, b'-W', b'ignore', b'-c', prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
- proc.stdin.write(b"HELLO\n")
+ proc.stdin.write(b'HELLO\n')
await proc.stdin.drain()
self.assertEqual(await proc.stdout.readline(), b"HELLO" + NL)
@@ -300,11 +282,11 @@ def handler(signum, frame):
if sys.platform != "win32":
proc.send_signal(signal.SIGUSR1)
- proc.stdin.write(b"!\n")
+ proc.stdin.write(b'!\n')
await proc.stdin.drain()
if sys.platform != "win32":
- self.assertEqual(await proc.stdout.readline(), b"WORLD\n")
+ self.assertEqual(await proc.stdout.readline(), b'WORLD\n')
self.assertEqual(await proc.stdout.readline(), b"!" + NL)
self.assertEqual(await proc.wait(), 11)
@@ -312,7 +294,7 @@ def handler(signum, frame):
def test_process_streams_basic_1(self):
async def test():
- prog = """\
+ prog = '''\
import sys
while True:
a = input()
@@ -322,14 +304,14 @@ async def test():
print('OUCH', file=sys.stderr)
else:
print('>' + a + '<')
- """
+ '''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd,
- b"-W",
- b"ignore",
- b"-c",
+ b'-W',
+ b'ignore',
+ b'-c',
prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
@@ -345,19 +327,19 @@ async def test():
transp.get_pipe_transport(0).pause_reading()
with self.assertRaises((NotImplementedError, AttributeError)):
# stdout is ReadTransport
- transp.get_pipe_transport(1).write(b"wat")
+ transp.get_pipe_transport(1).write(b'wat')
- proc.stdin.write(b"foobar\n")
+ proc.stdin.write(b'foobar\n')
await proc.stdin.drain()
out = await proc.stdout.readline()
self.assertEqual(out, b">foobar<" + NL)
- proc.stdin.write(b"stderr\n")
+ proc.stdin.write(b'stderr\n')
await proc.stdin.drain()
out = await proc.stderr.readline()
self.assertEqual(out, b"OUCH" + NL)
- proc.stdin.write(b"stop\n")
+ proc.stdin.write(b'stop\n')
await proc.stdin.drain()
exitcode = await proc.wait()
@@ -367,17 +349,17 @@ async def test():
def test_process_streams_stderr_to_stdout(self):
async def test():
- prog = """\
+ prog = '''\
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
- """
+ '''
proc = await asyncio.create_subprocess_exec(
sys.executable,
- b"-W",
- b"ignore",
- b"-c",
+ b'-W',
+ b'ignore',
+ b'-c',
prog,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
@@ -391,22 +373,17 @@ async def test():
def test_process_streams_devnull(self):
async def test():
- prog = """\
+ prog = '''\
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
- """
+ '''
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- prog,
+ sys.executable, b'-W', b'ignore', b'-c', prog,
stdin=subprocess.DEVNULL,
stdout=subprocess.DEVNULL,
- stderr=subprocess.DEVNULL,
- )
+ stderr=subprocess.DEVNULL)
out, err = await proc.communicate()
self.assertIsNone(err)
@@ -422,7 +399,7 @@ def test_process_streams_pass_fds(self):
raise unittest.SkipTest("pass_fds not supported on Windows")
async def test():
- prog = """\
+ prog = '''\
import sys, os
assert sys.argv[1] == '--'
inherited = int(sys.argv[2])
@@ -438,16 +415,16 @@ async def test():
raise RuntimeError()
print("OK")
- """
+ '''
tf = tempfile.TemporaryFile
with tf() as inherited, tf() as non_inherited:
proc = await asyncio.create_subprocess_exec(
sys.executable,
- b"-W",
- b"ignore",
- b"-c",
+ b'-W',
+ b'ignore',
+ b'-c',
prog,
- "--",
+ '--',
str(inherited.fileno()),
str(non_inherited.fileno()),
stdout=subprocess.PIPE,
@@ -456,21 +433,19 @@ async def test():
)
out, err = await proc.communicate()
- self.assertEqual(err, b"")
+ self.assertEqual(err, b'')
self.assertEqual(out, b"OK" + NL)
self.loop.run_until_complete(test())
- @unittest.skipIf(SKIP_PSUTIL, "We don't have PSUTIL")
def test_subprocess_fd_leak_1(self):
async def main(n):
for i in range(n):
try:
await asyncio.create_subprocess_exec(
- "nonexistant",
+ 'nonexistant',
stdout=subprocess.DEVNULL,
- stderr=subprocess.DEVNULL,
- )
+ stderr=subprocess.DEVNULL)
except FileNotFoundError:
pass
await asyncio.sleep(0)
@@ -482,13 +457,15 @@ async def main(n):
self.assertEqual(num_fd_1, num_fd_2)
- @unittest.skipIf(SKIP_PSUTIL, "We don't have PSUTIL")
def test_subprocess_fd_leak_2(self):
+ if sys.platform == "win32" and self.is_asyncio_loop():
+ self.skipTest("process-wide handle count is unstable on Windows")
+
async def main(n):
for i in range(n):
try:
p = await asyncio.create_subprocess_exec(
- "ls" if sys.platform != "win32" else "help",
+ 'ls' if sys.platform != "win32" else "help",
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
@@ -501,7 +478,10 @@ async def main(n):
self.loop.run_until_complete(main(10))
num_fd_2 = self.get_num_fds()
- self.assertEqual(num_fd_1, num_fd_2)
+ if sys.platform == 'win32':
+ self.assertLessEqual(num_fd_2, num_fd_1)
+ else:
+ self.assertEqual(num_fd_1, num_fd_2)
def test_subprocess_invalid_stdin(self):
fd = None
@@ -514,17 +494,23 @@ def test_subprocess_invalid_stdin(self):
else:
os.close(tryfd)
else:
- self.fail("could not find a free FD")
+ self.fail('could not find a free FD')
async def main():
with self.assertRaises(OSError):
- await asyncio.create_subprocess_exec("ls", stdin=fd)
+ await asyncio.create_subprocess_exec(
+ 'ls',
+ stdin=fd)
with self.assertRaises(OSError):
- await asyncio.create_subprocess_exec("ls", stdout=fd)
+ await asyncio.create_subprocess_exec(
+ 'ls',
+ stdout=fd)
with self.assertRaises(OSError):
- await asyncio.create_subprocess_exec("ls", stderr=fd)
+ await asyncio.create_subprocess_exec(
+ 'ls',
+ stderr=fd)
self.loop.run_until_complete(main())
@@ -534,15 +520,14 @@ async def main():
)
def test_process_streams_redirect(self):
async def test():
- prog = Rb"""
+ prog = bR'''
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
- """
+ '''
proc = await asyncio.create_subprocess_exec(
- sys.executable, b"-W", b"ignore", b"-c", prog
- )
+ sys.executable, b'-W', b'ignore', b'-c', prog)
out, err = await proc.communicate()
self.assertIsNone(out)
@@ -561,8 +546,8 @@ async def test():
else:
opener = None
- with tempfile.NamedTemporaryFile("w") as stdout:
- with tempfile.NamedTemporaryFile("w") as stderr:
+ with tempfile.NamedTemporaryFile('w') as stdout:
+ with tempfile.NamedTemporaryFile('w') as stderr:
with _RedirectFD(sys.stdout, stdout):
with _RedirectFD(sys.stderr, stderr):
self.loop.run_until_complete(test())
@@ -570,60 +555,46 @@ async def test():
stdout.flush()
stderr.flush()
- with open(stdout.name, "rb", opener=opener) as so:
+ with open(stdout.name, 'rb', opener=opener) as so:
self.assertEqual(so.read(), b"out" + NL)
- with open(stderr.name, "rb", opener=opener) as se:
+ with open(stderr.name, 'rb', opener=opener) as se:
self.assertEqual(se.read(), b"err" + NL)
class _AsyncioTests:
# Program blocking
- PROGRAM_BLOCKED = [
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- b"import time; time.sleep(3600)",
- ]
+ PROGRAM_BLOCKED = [sys.executable, b'-W', b'ignore',
+ b'-c', b'import time; time.sleep(3600)']
# Program copying input to output
PROGRAM_CAT = [
- sys.executable,
- b"-c",
- b";".join(
- (
- b"import sys",
- b"data = sys.stdin.buffer.read()",
- b"sys.stdout.buffer.write(data)",
- )
- ),
- ]
+ sys.executable, b'-c',
+ b';'.join((b'import sys',
+ b'data = sys.stdin.buffer.read()',
+ b'sys.stdout.buffer.write(data)'))]
- PROGRAM_ERROR = [sys.executable, b"-W", b"ignore", b"-c", b"1/0"]
+ PROGRAM_ERROR = [
+ sys.executable, b'-W', b'ignore', b'-c', b'1/0'
+ ]
def test_stdin_not_inheritable(self):
# asyncio issue #209: stdin must not be inheritable, otherwise
# the Process.communicate() hangs
async def len_message(message):
- code = "import sys; data = sys.stdin.read(); print(len(data))"
+ code = 'import sys; data = sys.stdin.read(); print(len(data))'
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- code,
+ sys.executable, b'-W', b'ignore', b'-c', code,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
- close_fds=False,
- )
+ close_fds=False)
stdout, stderr = await proc.communicate(message)
exitcode = await proc.wait()
return (stdout, exitcode)
- output, exitcode = self.loop.run_until_complete(len_message(b"abc"))
- self.assertEqual(output.rstrip(), b"3")
+ output, exitcode = self.loop.run_until_complete(len_message(b'abc'))
+ self.assertEqual(output.rstrip(), b'3')
self.assertEqual(exitcode, 0)
def test_stdin_stdout_pipe(self):
@@ -631,8 +602,9 @@ def test_stdin_stdout_pipe(self):
async def run(data):
proc = await asyncio.create_subprocess_exec(
- *args, stdin=subprocess.PIPE, stdout=subprocess.PIPE
- )
+ *args,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE)
# feed data
proc.stdin.write(data)
@@ -644,19 +616,20 @@ async def run(data):
exitcode = await proc.wait()
return (exitcode, data)
- task = run(b"some data")
+ task = run(b'some data')
task = asyncio.wait_for(task, 60.0)
exitcode, stdout = self.loop.run_until_complete(task)
self.assertEqual(exitcode, 0)
- self.assertEqual(stdout, b"some data")
+ self.assertEqual(stdout, b'some data')
def test_stdin_stdout_file(self):
args = self.PROGRAM_CAT
async def run(data, stdout):
proc = await asyncio.create_subprocess_exec(
- *args, stdin=subprocess.PIPE, stdout=stdout
- )
+ *args,
+ stdin=subprocess.PIPE,
+ stdout=stdout)
# feed data
proc.stdin.write(data)
@@ -666,62 +639,63 @@ async def run(data, stdout):
exitcode = await proc.wait()
return exitcode
- with tempfile.TemporaryFile("w+b") as new_stdout:
- task = run(b"some data", new_stdout)
+ with tempfile.TemporaryFile('w+b') as new_stdout:
+ task = run(b'some data', new_stdout)
task = asyncio.wait_for(task, 60.0)
exitcode = self.loop.run_until_complete(task)
self.assertEqual(exitcode, 0)
new_stdout.seek(0)
- self.assertEqual(new_stdout.read(), b"some data")
+ self.assertEqual(new_stdout.read(), b'some data')
def test_stdin_stderr_file(self):
args = self.PROGRAM_ERROR
async def run(stderr):
proc = await asyncio.create_subprocess_exec(
- *args, stdin=subprocess.PIPE, stderr=stderr
- )
+ *args,
+ stdin=subprocess.PIPE,
+ stderr=stderr)
exitcode = await proc.wait()
return exitcode
- with tempfile.TemporaryFile("w+b") as new_stderr:
+ with tempfile.TemporaryFile('w+b') as new_stderr:
task = run(new_stderr)
task = asyncio.wait_for(task, 60.0)
exitcode = self.loop.run_until_complete(task)
self.assertEqual(exitcode, 1)
new_stderr.seek(0)
- self.assertIn(b"ZeroDivisionError", new_stderr.read())
+ self.assertIn(b'ZeroDivisionError', new_stderr.read())
def test_communicate(self):
args = self.PROGRAM_CAT
async def run(data):
proc = await asyncio.create_subprocess_exec(
- *args, stdin=subprocess.PIPE, stdout=subprocess.PIPE
- )
+ *args,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE)
stdout, stderr = await proc.communicate(data)
return proc.returncode, stdout
- task = run(b"some data")
+ task = run(b'some data')
task = asyncio.wait_for(task, 60.0)
exitcode, stdout = self.loop.run_until_complete(task)
self.assertEqual(exitcode, 0)
- self.assertEqual(stdout, b"some data")
+ self.assertEqual(stdout, b'some data')
def test_start_new_session(self):
# start the new process in a new session
- create = asyncio.create_subprocess_shell(
- "exit 8", start_new_session=True
- )
+ create = asyncio.create_subprocess_shell('exit 8',
+ start_new_session=True)
proc = self.loop.run_until_complete(create)
exitcode = self.loop.run_until_complete(proc.wait())
self.assertEqual(exitcode, 8)
def test_shell(self):
- create = asyncio.create_subprocess_shell("exit 7")
+ create = asyncio.create_subprocess_shell('exit 7')
proc = self.loop.run_until_complete(create)
exitcode = self.loop.run_until_complete(proc.wait())
self.assertEqual(exitcode, 7)
@@ -754,7 +728,7 @@ def test_terminate(self):
@unittest.skipIf(sys.platform == "win32", "no SIGHUP on Windows")
def test_send_signal(self):
code = 'import time; print("sleeping", flush=True); time.sleep(3600)'
- args = [sys.executable, b"-W", b"ignore", b"-c", code]
+ args = [sys.executable, b'-W', b'ignore', b'-c', code]
create = asyncio.create_subprocess_exec(*args, stdout=subprocess.PIPE)
proc = self.loop.run_until_complete(create)
@@ -774,7 +748,8 @@ def test_cancel_process_wait(self):
# Issue #23140: cancel Process.wait()
async def cancel_wait():
- proc = await asyncio.create_subprocess_exec(*self.PROGRAM_BLOCKED)
+ proc = await asyncio.create_subprocess_exec(
+ *self.PROGRAM_BLOCKED)
# Create an internal future waiting on the process exit
task = self.loop.create_task(proc.wait())
@@ -818,9 +793,8 @@ def test_cancel_post_init(self):
raise unittest.SkipTest("problems on 3.13+ currently")
async def cancel_make_transport():
- coro = self.loop.subprocess_exec(
- asyncio.SubprocessProtocol, *self.PROGRAM_BLOCKED
- )
+ coro = self.loop.subprocess_exec(asyncio.SubprocessProtocol,
+ *self.PROGRAM_BLOCKED)
task = self.loop.create_task(coro)
self.loop.call_soon(task.cancel)
@@ -843,6 +817,7 @@ def test_close_gets_process_closed(self):
loop = self.loop
class Protocol(asyncio.SubprocessProtocol):
+
def __init__(self):
self.closed = loop.create_future()
@@ -884,13 +859,9 @@ async def copy_stdin_to_stdout(stdin):
# See https://github.com/MagicStack/uvloop/issues/363
# A program that copies stdin to stdout character by character
code = "import sys, shutil\n"
- code += "shutil.copyfileobj(sys.stdin, sys.stdout, 1)"
+ code += 'shutil.copyfileobj(sys.stdin, sys.stdout, 1)'
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- code,
+ sys.executable, b'-W', b'ignore', b'-c', code,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
@@ -900,28 +871,24 @@ async def copy_stdin_to_stdout(stdin):
)
return stdout
- stdin = b"x" * size
+ stdin = b'x' * size
stdout = self.loop.run_until_complete(copy_stdin_to_stdout(stdin))
self.assertEqual(stdout, stdin)
- @unittest.skip("Works on uvloop broken on python-asyncio")
def test_write_huge_stdin_8192(self):
self._test_write_huge_stdin(8192)
- @unittest.skip("Works on uvloop broken on python-asyncio")
def test_write_huge_stdin_8193(self):
self._test_write_huge_stdin(8193)
- @unittest.skip("Works on uvloop broken on python-asyncio")
def test_write_huge_stdin_219263(self):
self._test_write_huge_stdin(219263)
- @unittest.skip("Works on uvloop broken on python-asyncio")
def test_write_huge_stdin_219264(self):
self._test_write_huge_stdin(219264)
def _test_write_huge_stdin(self, buf_size):
- code = """
+ code = '''
import sys
n = 0
while True:
@@ -932,9 +899,9 @@ def _test_write_huge_stdin(self, buf_size):
if line == "END\\n":
break
n+=1
-print(n)"""
+print(n)'''
num_lines = buf_size - len(b"END\n")
- args = [sys.executable, b"-W", b"ignore", b"-c", code]
+ args = [sys.executable, b'-W', b'ignore', b'-c', code]
async def test():
proc = await asyncio.create_subprocess_exec(
@@ -1011,7 +978,7 @@ async def test():
mock.call(stdin),
]
""")
- subprocess.run([sys.executable, "-c", script], check=True)
+ subprocess.run([sys.executable, '-c', script], check=True)
class Test_AIO_Process(_TestProcess, tb.AIOTestCase):
@@ -1027,33 +994,35 @@ class TestAsyncio_AIO_Process(_AsyncioTests, tb.AIOTestCase):
class Test_UV_Process_Delayed(tb.UVTestCase):
+
class TestProto:
def __init__(self):
self.lost = 0
self.stages = []
def connection_made(self, transport):
- self.stages.append(("CM", transport))
+ self.stages.append(('CM', transport))
def pipe_data_received(self, fd, data):
if fd == 1:
- self.stages.append(("STDOUT", data))
+ self.stages.append(('STDOUT', data))
def pipe_connection_lost(self, fd, exc):
if fd == 1:
- self.stages.append(("STDOUT", "LOST"))
+ self.stages.append(('STDOUT', 'LOST'))
def process_exited(self):
- self.stages.append("PROC_EXIT")
+ self.stages.append('PROC_EXIT')
def connection_lost(self, exc):
- self.stages.append(("CL", self.lost, exc))
+ self.stages.append(('CL', self.lost, exc))
self.lost += 1
async def run_sub(self, **kwargs):
return await self.loop.subprocess_shell(
- lambda: self.TestProto(), "echo 1", **kwargs
- )
+ lambda: self.TestProto(),
+ 'echo 1',
+ **kwargs)
def test_process_delayed_stdio__paused__stdin_pipe(self):
transport, proto = self.loop.run_until_complete(
@@ -1069,14 +1038,14 @@ def test_process_delayed_stdio__paused__stdin_pipe(self):
self.assertEqual(
set(proto.stages),
{
- ("CM", transport),
- "PROC_EXIT",
- ("STDOUT", b"1" + NL),
- ("STDOUT", "LOST"),
+ ('CM', transport),
+ 'PROC_EXIT',
+ ('STDOUT', b"1" + NL),
+ ('STDOUT', 'LOST'),
}.union(
# Winloop comment: connection lost is not called because of
# issues with stdin pipe. See process.__socketpair().
- {("CL", 0, None)}
+ {('CL', 0, None)}
if sys.platform != "win32"
else {}
),
@@ -1096,19 +1065,19 @@ def test_process_delayed_stdio__paused__no_stdin(self):
self.assertEqual(
set(proto.stages),
{
- ("CM", transport),
- "PROC_EXIT",
- ("STDOUT", b"1" + NL),
- ("STDOUT", "LOST"),
- ("CL", 0, None),
+ ('CM', transport),
+ 'PROC_EXIT',
+ ('STDOUT', b"1" + NL),
+ ('STDOUT', 'LOST'),
+ ('CL', 0, None),
},
)
def test_process_delayed_stdio__not_paused__no_stdin(self):
if (
- os.environ.get("TRAVIS_OS_NAME")
- or os.environ.get("GITHUB_WORKFLOW")
- ) and sys.platform == "darwin":
+ os.environ.get('TRAVIS_OS_NAME')
+ or os.environ.get('GITHUB_WORKFLOW')
+ ) and sys.platform == 'darwin':
# Randomly crashes on Travis, can't reproduce locally.
raise unittest.SkipTest()
@@ -1123,10 +1092,10 @@ def test_process_delayed_stdio__not_paused__no_stdin(self):
self.assertEqual(
set(proto.stages),
{
- ("CM", transport),
- "PROC_EXIT",
- ("STDOUT", b"1" + NL),
- ("STDOUT", "LOST"),
- ("CL", 0, None),
+ ('CM', transport),
+ 'PROC_EXIT',
+ ('STDOUT', b"1" + NL),
+ ('STDOUT', 'LOST'),
+ ('CL', 0, None),
},
)
diff --git a/tests/test_process_spawning.py b/tests/test_process_spawning.py
index 27c199cf0..45f5f4e8a 100644
--- a/tests/test_process_spawning.py
+++ b/tests/test_process_spawning.py
@@ -17,19 +17,15 @@ def test_spawning_external_process(self):
async def run(loop):
event = asyncio.Event()
- dummy_workers = [
- simulate_loop_activity(loop, event) for _ in range(5)
- ]
+ dummy_workers = [simulate_loop_activity(loop, event)
+ for _ in range(5)]
spawn_worker = spawn_external_process(loop, event)
- done, pending = await asyncio.wait(
- [
- asyncio.ensure_future(fut)
- for fut in ([spawn_worker] + dummy_workers)
- ]
- )
- exceptions = [
- result.exception() for result in done if result.exception()
- ]
+ done, pending = await asyncio.wait([
+ asyncio.ensure_future(fut)
+ for fut in ([spawn_worker] + dummy_workers)
+ ])
+ exceptions = [result.exception()
+ for result in done if result.exception()]
if exceptions:
raise exceptions[0]
@@ -60,7 +56,7 @@ async def spawn_external_process(loop, event):
BufferType = ctypes.c_char * (BUFFER_LENGTH - 1)
def run_echo(popen, fread, pclose):
- fd = popen("echo test".encode("ASCII"), "r".encode("ASCII"))
+ fd = popen('echo test'.encode('ASCII'), 'r'.encode('ASCII'))
try:
while True:
buffer = BufferType()
@@ -71,7 +67,7 @@ def run_echo(popen, fread, pclose):
if not read:
break
except Exception:
- logging.getLogger().exception("read error")
+ logging.getLogger().exception('read error')
raise
finally:
pclose(fd)
@@ -82,11 +78,8 @@ def spawn_process():
# WINLOOP comment: use 'msvcrt' instead of 'c', and
# attrbs '_popen' and '_plocse' instead of 'popen' and 'pclose'.
# NB: this test turns out to take close to 10x longer on Windows?!
- stdio = ctypes.CDLL(
- ctypes.util.find_library(
- "msvcrt" if sys.platform == "win32" else "c"
- )
- )
+ stdio = ctypes.CDLL(ctypes.util.find_library(
+ "msvcrt" if sys.platform == "win32" else 'c'))
# popen system call
popen = stdio._popen if sys.platform == "win32" else stdio.popen
@@ -100,23 +93,19 @@ def spawn_process():
# fread system call
fread = stdio.fread
- fread.argtypes = (
- ctypes.c_void_p,
- ctypes.c_size_t,
- ctypes.c_size_t,
- ctypes.c_void_p,
- )
+ fread.argtypes = (ctypes.c_void_p, ctypes.c_size_t,
+ ctypes.c_size_t, ctypes.c_void_p)
fread.restype = ctypes.c_size_t
for iteration in range(1000):
- t = Thread(
- target=run_echo, args=(popen, fread, pclose), daemon=True
- )
+ t = Thread(target=run_echo,
+ args=(popen, fread, pclose),
+ daemon=True)
t.start()
t.join(timeout=10.0)
if t.is_alive():
raise Exception(
- "process freeze detected at {}".format(iteration)
+ 'process freeze detected at {}'.format(iteration)
)
return True
diff --git a/tests/test_regr1.py b/tests/test_regr1.py
index 35b1db415..c502457ec 100644
--- a/tests/test_regr1.py
+++ b/tests/test_regr1.py
@@ -13,7 +13,7 @@
class EchoServerProtocol(asyncio.Protocol):
def connection_made(self, transport):
- transport.write(b"z")
+ transport.write(b'z')
class EchoClientProtocol(asyncio.Protocol):
@@ -42,7 +42,7 @@ def server_thread():
nonlocal server_loop
loop = server_loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)
- coro = loop.create_server(EchoServerProtocol, "127.0.0.1", 0)
+ coro = loop.create_server(EchoServerProtocol, '127.0.0.1', 0)
server = loop.run_until_complete(coro)
addr = server.sockets[0].getsockname()
qout.put(addr)
@@ -53,7 +53,7 @@ def server_thread():
loop.close()
except Exception as exc:
print(exc)
- qout.put("stopped")
+ qout.put('stopped')
thread = threading.Thread(target=server_thread, daemon=True)
thread.start()
@@ -79,14 +79,16 @@ def run_test(self):
if threaded:
qin, qout = queue.Queue(), queue.Queue()
threading.Thread(
- target=run_server, args=(qin, qout), daemon=True
- ).start()
+ target=run_server,
+ args=(qin, qout),
+ daemon=True).start()
else:
qin = multiprocessing.Queue()
qout = multiprocessing.Queue()
multiprocessing.Process(
- target=run_server, args=(qin, qout), daemon=True
- ).start()
+ target=run_server,
+ args=(qin, qout),
+ daemon=True).start()
addr = qout.get()
loop = self.new_loop()
@@ -94,19 +96,15 @@ def run_test(self):
loop.create_task(
loop.create_connection(
lambda: EchoClientProtocol(loop),
- host=addr[0],
- port=addr[1],
- )
- )
+ host=addr[0], port=addr[1]))
loop.run_forever()
loop.close()
- qin.put("stop")
+ qin.put('stop')
qout.get()
@unittest.skipIf(
- multiprocessing.get_start_method(False) == "spawn",
- "no need to test on macOS where spawn is used instead of fork",
- )
+ multiprocessing.get_start_method(False) == 'spawn',
+ 'no need to test on macOS where spawn is used instead of fork')
def test_issue39_regression(self):
signal.signal(signal.SIGALRM, self.on_alarm)
signal.alarm(5)
@@ -115,7 +113,7 @@ def test_issue39_regression(self):
self.running = True
self.run_test()
except FailedTestError:
- self.fail("deadlocked in libuv")
+ self.fail('deadlocked in libuv')
finally:
self.running = False
signal.signal(signal.SIGALRM, signal.SIG_IGN)
diff --git a/tests/test_runner.py b/tests/test_runner.py
index 60109f05d..cb672cecc 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -17,11 +17,11 @@ async def main():
self.assertTrue(isinstance(loop, uvloop.Loop))
self.assertTrue(loop.get_debug())
- return "done"
+ return 'done'
result = uvloop.run(main(), debug=True)
- self.assertEqual(result, "done")
+ self.assertEqual(result, 'done')
self.assertEqual(CNT, 1)
def test_uvloop_run_2(self):
@@ -30,7 +30,7 @@ async def main():
pass
coro = main()
- with self.assertRaisesRegex(TypeError, " a non-uvloop event loop"):
+ with self.assertRaisesRegex(TypeError, ' a non-uvloop event loop'):
uvloop.run(
coro,
loop_factory=asyncio.DefaultEventLoopPolicy().new_event_loop,
diff --git a/tests/test_signals.py b/tests/test_signals.py
index 88aeb8b16..bf4951424 100644
--- a/tests/test_signals.py
+++ b/tests/test_signals.py
@@ -17,8 +17,7 @@ class _TestSignal:
@tb.silence_long_exec_warning()
def test_signals_sigint_pycode_stop(self):
async def runner():
- PROG = (
- R"""\
+ PROG = R"""\
import asyncio
import uvloop
import time
@@ -31,9 +30,7 @@ async def worker():
@tb.silence_long_exec_warning()
def run():
- loop = """
- + self.NEW_LOOP
- + """
+ loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(worker())
@@ -42,41 +39,31 @@ def run():
run()
"""
- )
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- PROG,
+ sys.executable, b'-W', b'ignore', b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
await proc.stdout.readline()
time.sleep(DELAY)
- if (
- sys.platform == "win32"
- and self.NEW_LOOP == "asyncio.new_event_loop()"
- ):
- proc.send_signal(signal.SIGTERM) # alt: proc.terminate()
- else:
- proc.send_signal(signal.SIGINT)
+ proc.send_signal(
+ signal.SIGTERM if sys.platform == "win32" and
+ self.NEW_LOOP == "asyncio.new_event_loop()" else signal.SIGINT)
out, err = await proc.communicate()
if sys.platform == "win32":
self.assertEqual(err, b"")
else:
- self.assertIn(b"KeyboardInterrupt", err)
- self.assertEqual(out, b"")
+ self.assertIn(b'KeyboardInterrupt', err)
+ self.assertEqual(out, b'')
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_pycode_continue(self):
async def runner():
- PROG = (
- R"""\
+ PROG = R"""\
import asyncio
import uvloop
import time
@@ -94,9 +81,7 @@ async def worker():
@tb.silence_long_exec_warning()
def run():
- loop = """
- + self.NEW_LOOP
- + """
+ loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(worker())
@@ -105,41 +90,31 @@ def run():
run()
"""
- )
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- PROG,
+ sys.executable, b'-W', b'ignore', b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
await proc.stdout.readline()
time.sleep(DELAY)
- if (
- sys.platform == "win32"
- and self.NEW_LOOP == "asyncio.new_event_loop()"
- ):
- proc.send_signal(signal.SIGTERM) # alt: proc.terminate()
- else:
- proc.send_signal(signal.SIGINT)
+ proc.send_signal(
+ signal.SIGTERM if sys.platform == "win32" and
+ self.NEW_LOOP == "asyncio.new_event_loop()" else signal.SIGINT)
out, err = await proc.communicate()
- self.assertEqual(err, b"")
+ self.assertEqual(err, b'')
if sys.platform == "win32":
self.assertEqual(out, b"")
else:
- self.assertEqual(out, b"oups\ndone\n")
+ self.assertEqual(out, b'oups\ndone\n')
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_uvcode(self):
async def runner():
- PROG = (
- R"""\
+ PROG = R"""\
import asyncio
import uvloop
@@ -151,9 +126,7 @@ async def worker():
srv = await asyncio.start_server(cb, '127.0.0.1', 0)
print('READY', flush=True)
-loop = """
- + self.NEW_LOOP
- + """
+loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
loop.create_task(worker())
try:
@@ -163,40 +136,30 @@ async def worker():
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
- )
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- PROG,
+ sys.executable, b'-W', b'ignore', b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
await proc.stdout.readline()
time.sleep(DELAY)
- if (
- sys.platform == "win32"
- and self.NEW_LOOP == "asyncio.new_event_loop()"
- ):
- proc.send_signal(signal.SIGTERM) # alt: proc.terminate()
- else:
- proc.send_signal(signal.SIGINT)
+ proc.send_signal(
+ signal.SIGTERM if sys.platform == "win32" and
+ self.NEW_LOOP == "asyncio.new_event_loop()" else signal.SIGINT)
out, err = await proc.communicate()
if sys.platform == "win32":
self.assertEqual(err, b"")
else:
- self.assertIn(b"KeyboardInterrupt", err)
+ self.assertIn(b'KeyboardInterrupt', err)
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_uvcode_two_loop_runs(self):
async def runner():
- PROG = (
- R"""\
+ PROG = R"""\
import asyncio
import uvloop
@@ -207,9 +170,7 @@ async def worker():
cb = lambda *args: None
srv = await asyncio.start_server(cb, '127.0.0.1', 0)
-loop = """
- + self.NEW_LOOP
- + """
+loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
loop.run_until_complete(worker())
print('READY', flush=True)
@@ -220,32 +181,23 @@ async def worker():
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
- )
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- PROG,
+ sys.executable, b'-W', b'ignore', b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
await proc.stdout.readline()
time.sleep(DELAY)
- if (
- sys.platform == "win32"
- and self.NEW_LOOP == "asyncio.new_event_loop()"
- ):
- proc.send_signal(signal.SIGTERM) # alt: proc.terminate()
- else:
- proc.send_signal(signal.SIGINT)
+ proc.send_signal(
+ signal.SIGTERM if sys.platform == "win32" and
+ self.NEW_LOOP == "asyncio.new_event_loop()" else signal.SIGINT)
out, err = await proc.communicate()
if sys.platform == "win32":
self.assertEqual(err, b"")
else:
- self.assertIn(b"KeyboardInterrupt", err)
+ self.assertIn(b'KeyboardInterrupt', err)
self.loop.run_until_complete(runner())
@@ -256,8 +208,7 @@ async def worker():
@tb.silence_long_exec_warning()
def test_signals_sigint_and_custom_handler(self):
async def runner():
- PROG = (
- R"""\
+ PROG = R"""\
import asyncio
import signal
import uvloop
@@ -277,9 +228,7 @@ def handler_sig(say):
def handler_hup(say):
print(say, flush=True)
-loop = """
- + self.NEW_LOOP
- + """
+loop = """ + self.NEW_LOOP + """
loop.add_signal_handler(signal.SIGINT, handler_sig, '!s-int!')
loop.add_signal_handler(signal.SIGHUP, handler_hup, '!s-hup!')
asyncio.set_event_loop(loop)
@@ -291,17 +240,11 @@ def handler_hup(say):
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
- )
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- PROG,
+ sys.executable, b'-W', b'ignore', b'-c', PROG,
stdout=subprocess.PIPE,
- stderr=subprocess.PIPE,
- )
+ stderr=subprocess.PIPE)
await proc.stdout.readline()
time.sleep(DELAY)
@@ -309,9 +252,9 @@ def handler_hup(say):
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
- self.assertEqual(err, b"")
- self.assertIn(b"!s-hup!", out)
- self.assertIn(b"!s-int!", out)
+ self.assertEqual(err, b'')
+ self.assertIn(b'!s-hup!', out)
+ self.assertIn(b'!s-int!', out)
self.loop.run_until_complete(runner())
@@ -319,8 +262,7 @@ def handler_hup(say):
@tb.silence_long_exec_warning()
def test_signals_and_custom_handler_1(self):
async def runner():
- PROG = (
- R"""\
+ PROG = R"""\
import asyncio
import signal
import uvloop
@@ -343,9 +285,7 @@ def handler2():
def handler_hup():
exit()
-loop = """
- + self.NEW_LOOP
- + """
+loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
loop.add_signal_handler(signal.SIGUSR1, handler1)
loop.add_signal_handler(signal.SIGUSR2, handler2)
@@ -359,17 +299,11 @@ def handler_hup():
loop.close()
"""
- )
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- PROG,
+ sys.executable, b'-W', b'ignore', b'-c', PROG,
stdout=subprocess.PIPE,
- stderr=subprocess.PIPE,
- )
+ stderr=subprocess.PIPE)
await proc.stdout.readline()
@@ -387,16 +321,17 @@ def handler_hup():
proc.send_signal(signal.SIGHUP)
out, err = await proc.communicate()
- self.assertEqual(err, b"")
- self.assertEqual(b"GOTIT\nGOTIT\nREMOVED\n", out)
+ self.assertEqual(err, b'')
+ self.assertEqual(b'GOTIT\nGOTIT\nREMOVED\n', out)
self.loop.run_until_complete(runner())
@unittest.skipIf(sys.platform == "win32", "no SIGKILL on Windows")
def test_signals_invalid_signal(self):
- with self.assertRaisesRegex(
- RuntimeError, "sig {} cannot be caught".format(signal.SIGKILL)
- ):
+ with self.assertRaisesRegex(RuntimeError,
+ 'sig {} cannot be caught'.format(
+ signal.SIGKILL)):
+
self.loop.add_signal_handler(signal.SIGKILL, lambda *a: None)
def test_signals_coro_callback(self):
@@ -410,8 +345,7 @@ def test_signals_coro_callback(self):
async def coro():
pass
-
- with self.assertRaisesRegex(TypeError, "coroutines cannot be used"):
+ with self.assertRaisesRegex(TypeError, 'coroutines cannot be used'):
if sys.platform == "win32":
# uvloop comment: use (arbitrary) signal defined on Windows
self.loop.add_signal_handler(signal.SIGILL, coro)
@@ -423,8 +357,7 @@ def test_signals_wakeup_fd_unchanged(self):
# to pass this test on Windows; also works with Linux,
# but need to double check this.
async def runner():
- PROG = (
- R"""\
+ PROG = R"""\
import uvloop
import signal
import asyncio
@@ -437,9 +370,7 @@ def get_wakeup_fd():
async def f(): pass
-loop = """
- + self.NEW_LOOP
- + """
+loop = """ + self.NEW_LOOP + """
fd0 = get_wakeup_fd()
try:
asyncio.set_event_loop(loop)
@@ -451,21 +382,16 @@ async def f(): pass
print(fd0 == fd1, flush=True)
"""
- )
proc = await asyncio.create_subprocess_exec(
- sys.executable,
- b"-W",
- b"ignore",
- b"-c",
- PROG,
+ sys.executable, b'-W', b'ignore', b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
out, err = await proc.communicate()
- self.assertEqual(err, b"")
- self.assertIn(b"True", out)
+ self.assertEqual(err, b'')
+ self.assertIn(b'True', out)
self.loop.run_until_complete(runner())
@@ -487,8 +413,7 @@ def test_signals_fork_in_thread(self):
# operations failed thread ID checks because we didn't update
# MAIN_THREAD_ID after fork. It's now a lazy value set when needed and
# cleared after fork.
- PROG = (
- R"""\
+ PROG = R"""\
import asyncio
import multiprocessing
import signal
@@ -496,18 +421,12 @@ def test_signals_fork_in_thread(self):
import threading
import uvloop
-#multiprocessing.set_start_method('fork')
-
def subprocess():
- loop = """
- + self.NEW_LOOP
- + """
+ loop = """ + self.NEW_LOOP + """
loop.add_signal_handler(signal.SIGINT, lambda *a: None)
def run():
- loop = """
- + self.NEW_LOOP
- + """
+ loop = """ + self.NEW_LOOP + """
loop.add_signal_handler(signal.SIGINT, lambda *a: None)
p = multiprocessing.Process(target=subprocess)
t = threading.Thread(target=p.start)
@@ -519,7 +438,6 @@ def run():
if __name__ == "__main__":
run()
"""
- )
# uvloop comment: in PROG above we use default setting
# for start_method: on Linux 'fork' and on Windows 'spawn'.
@@ -528,9 +446,9 @@ def run():
subprocess.check_call(
[
sys.executable,
- b"-W",
- b"ignore",
- b"-c",
+ b'-W',
+ b'ignore',
+ b'-c',
PROG,
]
)
@@ -550,15 +468,15 @@ def run():
class Test_UV_Signals(_TestSignal, tb.UVTestCase):
- NEW_LOOP = "uvloop.new_event_loop()"
+ NEW_LOOP = 'uvloop.new_event_loop()'
@unittest.skipIf(sys.platform == "win32", "no SIGCHLD on Windows")
def test_signals_no_SIGCHLD(self):
- with self.assertRaisesRegex(
- RuntimeError, r"cannot add.*handler.*SIGCHLD"
- ):
+ with self.assertRaisesRegex(RuntimeError,
+ r"cannot add.*handler.*SIGCHLD"):
+
self.loop.add_signal_handler(signal.SIGCHLD, lambda *a: None)
class Test_AIO_Signals(_TestSignal, tb.AIOTestCase):
- NEW_LOOP = "asyncio.new_event_loop()"
+ NEW_LOOP = 'asyncio.new_event_loop()'
diff --git a/tests/test_sockets.py b/tests/test_sockets.py
index 9a69beb11..ca3075682 100644
--- a/tests/test_sockets.py
+++ b/tests/test_sockets.py
@@ -8,12 +8,14 @@
from uvloop import _testbase as tb
+
_SIZE = 1024 * 1024
class _TestSockets:
+
async def recv_all(self, sock, nbytes):
- buf = b""
+ buf = b''
while len(buf) < nbytes:
buf += await self.loop.sock_recv(sock, nbytes - len(buf))
return buf
@@ -24,18 +26,17 @@ async def server():
sock.setblocking(False)
with sock:
- sock.bind(("127.0.0.1", 0))
+ sock.bind(('127.0.0.1', 0))
sock.listen()
- fut = self.loop.run_in_executor(
- None, client, sock.getsockname()
- )
+ fut = self.loop.run_in_executor(None, client,
+ sock.getsockname())
client_sock, _ = await self.loop.sock_accept(sock)
with client_sock:
data = await self.recv_all(client_sock, _SIZE)
- self.assertEqual(data, b"a" * _SIZE)
+ self.assertEqual(data, b'a' * _SIZE)
await fut
@@ -43,14 +44,14 @@ def client(addr):
sock = socket.socket()
with sock:
sock.connect(addr)
- sock.sendall(b"a" * _SIZE)
+ sock.sendall(b'a' * _SIZE)
self.loop.run_until_complete(server())
def test_socket_failed_connect(self):
sock = socket.socket()
with sock:
- sock.bind(("127.0.0.1", 0))
+ sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
async def run():
@@ -62,11 +63,11 @@ async def run():
self.loop.run_until_complete(run())
- @unittest.skipUnless(tb.has_IPv6, "no IPv6")
+ @unittest.skipUnless(tb.has_IPv6, 'no IPv6')
def test_socket_ipv6_addr(self):
server_sock = socket.socket(socket.AF_INET6)
with server_sock:
- server_sock.bind(("::1", 0))
+ server_sock.bind(('::1', 0))
addr = server_sock.getsockname() # tuple of 4 elements for IPv6
@@ -90,7 +91,7 @@ async def run():
sock = socket.socket(socket.AF_INET)
with sock:
sock.setblocking(False)
- await self.loop.sock_connect(sock, ("localhost", 0))
+ await self.loop.sock_connect(sock, ('localhost', 0))
with self.assertRaises(OSError):
# Regression test: sock_connect(sock) wasn't calling
@@ -106,19 +107,21 @@ def test_socket_blocking_error(self):
sock = socket.socket()
with sock:
- with self.assertRaisesRegex(ValueError, "must be non-blocking"):
- self.loop.run_until_complete(self.loop.sock_recv(sock, 0))
+ with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
+ self.loop.run_until_complete(
+ self.loop.sock_recv(sock, 0))
- with self.assertRaisesRegex(ValueError, "must be non-blocking"):
- self.loop.run_until_complete(self.loop.sock_sendall(sock, b""))
+ with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
+ self.loop.run_until_complete(
+ self.loop.sock_sendall(sock, b''))
- with self.assertRaisesRegex(ValueError, "must be non-blocking"):
- self.loop.run_until_complete(self.loop.sock_accept(sock))
+ with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
+ self.loop.run_until_complete(
+ self.loop.sock_accept(sock))
- with self.assertRaisesRegex(ValueError, "must be non-blocking"):
+ with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
- self.loop.sock_connect(sock, (b"", 0))
- )
+ self.loop.sock_connect(sock, (b'', 0)))
def test_socket_fileno(self):
rsock, wsock = socket.socketpair()
@@ -131,7 +134,7 @@ def reader():
f.set_result(None)
def writer():
- wsock.send(b"abc")
+ wsock.send(b'abc')
self.loop.remove_writer(wsock)
with rsock, wsock:
@@ -146,7 +149,7 @@ def test_socket_sync_remove_and_immediately_close(self):
with sock:
cb = lambda: None
- sock.bind(("127.0.0.1", 0))
+ sock.bind(('127.0.0.1', 0))
sock.listen(0)
fd = sock.fileno()
self.loop.add_reader(fd, cb)
@@ -169,13 +172,13 @@ async def server():
sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_server.setblocking(False)
with sock_server:
- sock_server.bind(("127.0.0.1", 0))
+ sock_server.bind(('127.0.0.1', 0))
sock_server.listen()
- fut = asyncio.ensure_future(client(sock_server.getsockname()))
+ fut = asyncio.ensure_future(
+ client(sock_server.getsockname()))
srv_sock_conn, _ = await self.loop.sock_accept(sock_server)
srv_sock_conn.setsockopt(
- socket.IPPROTO_TCP, socket.TCP_NODELAY, 1
- )
+ socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
with srv_sock_conn:
await fut
@@ -200,8 +203,7 @@ async def send_server_data():
# will add a reader. This will make a race between
# remove- and add-reader.
await asyncio.sleep(0.1)
- await self.loop.sock_sendall(srv_sock_conn, b"1")
-
+ await self.loop.sock_sendall(srv_sock_conn, b'1')
self.loop.create_task(send_server_data())
for rfut in pending_read_futs:
@@ -209,7 +211,7 @@ async def send_server_data():
data = await self.loop.sock_recv(sock_client, 1)
- self.assertEqual(data, b"1")
+ self.assertEqual(data, b'1')
self.loop.run_until_complete(server())
@@ -226,9 +228,10 @@ async def server():
sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_server.setblocking(False)
with sock_server:
- sock_server.bind(("127.0.0.1", 0))
+ sock_server.bind(('127.0.0.1', 0))
sock_server.listen()
- fut = asyncio.ensure_future(client(sock_server.getsockname()))
+ fut = asyncio.ensure_future(
+ client(sock_server.getsockname()))
srv_sock_conn, _ = await self.loop.sock_accept(sock_server)
with srv_sock_conn:
await fut
@@ -250,7 +253,7 @@ async def client(addr):
# server can send the data in a random time, even before
# the previous result future has cancelled.
- await self.loop.sock_sendall(srv_sock_conn, b"1")
+ await self.loop.sock_sendall(srv_sock_conn, b'1')
for rfut in pending_read_futs:
rfut.cancel()
@@ -267,13 +270,14 @@ async def client(addr):
data = await self.loop.sock_recv(sock_client, 1)
- self.assertEqual(data, b"1")
+ self.assertEqual(data, b'1')
self.loop.run_until_complete(server())
class TestUVSockets(_TestSockets, tb.UVTestCase):
- @unittest.skipUnless(hasattr(select, "epoll"), "Linux only test")
+
+ @unittest.skipUnless(hasattr(select, 'epoll'), 'Linux only test')
def test_socket_sync_remove(self):
# See https://github.com/MagicStack/uvloop/issues/61 for details
@@ -283,7 +287,7 @@ def test_socket_sync_remove(self):
try:
cb = lambda: None
- sock.bind(("127.0.0.1", 0))
+ sock.bind(('127.0.0.1', 0))
sock.listen(0)
fd = sock.fileno()
self.loop.add_reader(fd, cb)
@@ -300,17 +304,16 @@ def test_socket_sync_remove(self):
def test_add_reader_or_writer_transport_fd(self):
def assert_raises():
return self.assertRaisesRegex(
- RuntimeError, r"File descriptor .* is used by transport"
- )
+ RuntimeError,
+ r'File descriptor .* is used by transport')
async def runner():
tr, pr = await self.loop.create_connection(
- lambda: asyncio.Protocol(), sock=rsock
- )
+ lambda: asyncio.Protocol(), sock=rsock)
try:
cb = lambda: None
- sock = tr.get_extra_info("socket")
+ sock = tr.get_extra_info('socket')
with assert_raises():
self.loop.add_reader(sock, cb)
@@ -346,56 +349,37 @@ async def runner():
def test_pseudosocket(self):
def assert_raises():
return self.assertRaisesRegex(
- RuntimeError, r"File descriptor .* is used by transport"
- )
+ RuntimeError,
+ r'File descriptor .* is used by transport')
def test_pseudo(real_sock, pseudo_sock, *, is_dup=False):
- self.assertIn("AF_UNIX", repr(pseudo_sock))
+ self.assertIn('AF_UNIX', repr(pseudo_sock))
self.assertEqual(pseudo_sock.family, real_sock.family)
self.assertEqual(pseudo_sock.proto, real_sock.proto)
# Guard against SOCK_NONBLOCK bit in socket.type on Linux.
- self.assertEqual(pseudo_sock.type & 0xF, real_sock.type & 0xF)
+ self.assertEqual(pseudo_sock.type & 0xf, real_sock.type & 0xf)
with self.assertRaises(TypeError):
pickle.dumps(pseudo_sock)
na_meths = {
- "accept",
- "connect",
- "connect_ex",
- "bind",
- "listen",
- "makefile",
- "sendfile",
- "close",
- "detach",
- "shutdown",
- "sendmsg_afalg",
- "sendmsg",
- "sendto",
- "send",
- "sendall",
- "recv_into",
- "recvfrom_into",
- "recvmsg_into",
- "recvmsg",
- "recvfrom",
- "recv",
+ 'accept', 'connect', 'connect_ex', 'bind', 'listen',
+ 'makefile', 'sendfile', 'close', 'detach', 'shutdown',
+ 'sendmsg_afalg', 'sendmsg', 'sendto', 'send', 'sendall',
+ 'recv_into', 'recvfrom_into', 'recvmsg_into', 'recvmsg',
+ 'recvfrom', 'recv'
}
for methname in na_meths:
meth = getattr(pseudo_sock, methname)
with self.assertRaisesRegex(
- TypeError, r".*not support " + methname + r"\(\) method"
- ):
+ TypeError,
+ r'.*not support ' + methname + r'\(\) method'):
meth()
eq_meths = {
- "getsockname",
- "getpeername",
- "get_inheritable",
- "gettimeout",
+ 'getsockname', 'getpeername', 'get_inheritable', 'gettimeout'
}
for methname in eq_meths:
pmeth = getattr(pseudo_sock, methname)
@@ -406,8 +390,8 @@ def test_pseudo(real_sock, pseudo_sock, *, is_dup=False):
self.assertEqual(pmeth(), rmeth())
self.assertEqual(
- pseudo_sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR), 0
- )
+ pseudo_sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR),
+ 0)
if not is_dup:
self.assertEqual(pseudo_sock.fileno(), real_sock.fileno())
@@ -422,11 +406,10 @@ def test_pseudo(real_sock, pseudo_sock, *, is_dup=False):
async def runner():
tr, pr = await self.loop.create_connection(
- lambda: asyncio.Protocol(), sock=rsock
- )
+ lambda: asyncio.Protocol(), sock=rsock)
try:
- sock = tr.get_extra_info("socket")
+ sock = tr.get_extra_info('socket')
test_pseudo(rsock, sock)
finally:
tr.close()
@@ -440,27 +423,27 @@ async def runner():
def test_socket_connect_and_close(self):
def srv_gen(sock):
- sock.send(b"helo")
+ sock.send(b'helo')
async def client(sock, addr):
- f = asyncio.ensure_future(
- self.loop.sock_connect(sock, addr), loop=self.loop
- )
+ f = asyncio.ensure_future(self.loop.sock_connect(sock, addr),
+ loop=self.loop)
self.loop.call_soon(sock.close)
await f
- return "ok"
+ return 'ok'
with self.tcp_server(srv_gen) as srv:
+
sock = socket.socket()
with sock:
sock.setblocking(False)
r = self.loop.run_until_complete(client(sock, srv.addr))
- self.assertEqual(r, "ok")
+ self.assertEqual(r, 'ok')
def test_socket_recv_and_close(self):
def srv_gen(sock):
time.sleep(1.2)
- sock.send(b"helo")
+ sock.send(b'helo')
async def kill(sock):
await asyncio.sleep(0.2)
@@ -469,27 +452,27 @@ async def kill(sock):
async def client(sock, addr):
await self.loop.sock_connect(sock, addr)
- f = asyncio.ensure_future(
- self.loop.sock_recv(sock, 10), loop=self.loop
- )
+ f = asyncio.ensure_future(self.loop.sock_recv(sock, 10),
+ loop=self.loop)
self.loop.create_task(kill(sock))
res = await f
self.assertEqual(sock.fileno(), -1)
return res
with self.tcp_server(srv_gen) as srv:
+
sock = socket.socket()
with sock:
sock.setblocking(False)
c = client(sock, srv.addr)
w = asyncio.wait_for(c, timeout=5.0)
r = self.loop.run_until_complete(w)
- self.assertEqual(r, b"helo")
+ self.assertEqual(r, b'helo')
def test_socket_recv_into_and_close(self):
def srv_gen(sock):
time.sleep(1.2)
- sock.send(b"helo")
+ sock.send(b'helo')
async def kill(sock):
await asyncio.sleep(0.2)
@@ -500,9 +483,8 @@ async def client(sock, addr):
data = bytearray(10)
with memoryview(data) as buf:
- f = asyncio.ensure_future(
- self.loop.sock_recv_into(sock, buf), loop=self.loop
- )
+ f = asyncio.ensure_future(self.loop.sock_recv_into(sock, buf),
+ loop=self.loop)
self.loop.create_task(kill(sock))
rcvd = await f
data = data[:rcvd]
@@ -510,13 +492,14 @@ async def client(sock, addr):
return bytes(data)
with self.tcp_server(srv_gen) as srv:
+
sock = socket.socket()
with sock:
sock.setblocking(False)
c = client(sock, srv.addr)
w = asyncio.wait_for(c, timeout=5.0)
r = self.loop.run_until_complete(w)
- self.assertEqual(r, b"helo")
+ self.assertEqual(r, b'helo')
def test_socket_send_and_close(self):
ok = False
@@ -524,29 +507,29 @@ def test_socket_send_and_close(self):
def srv_gen(sock):
nonlocal ok
b = sock.recv_all(2)
- if b == b"hi":
+ if b == b'hi':
ok = True
- sock.send(b"ii")
+ sock.send(b'ii')
async def client(sock, addr):
await self.loop.sock_connect(sock, addr)
s2 = sock.dup() # Don't let it drop connection until `f` is done
with s2:
- f = asyncio.ensure_future(
- self.loop.sock_sendall(sock, b"hi"), loop=self.loop
- )
+ f = asyncio.ensure_future(self.loop.sock_sendall(sock, b'hi'),
+ loop=self.loop)
self.loop.call_soon(sock.close)
await f
return await self.loop.sock_recv(s2, 2)
with self.tcp_server(srv_gen) as srv:
+
sock = socket.socket()
with sock:
sock.setblocking(False)
r = self.loop.run_until_complete(client(sock, srv.addr))
- self.assertEqual(r, b"ii")
+ self.assertEqual(r, b'ii')
self.assertTrue(ok)
@@ -560,13 +543,13 @@ def srv_gen(sock):
async def client(sock, addr):
await self.loop.sock_connect(sock, addr)
- asyncio.ensure_future(
- self.loop.sock_recv(sock, 10), loop=self.loop
- )
+ asyncio.ensure_future(self.loop.sock_recv(sock, 10),
+ loop=self.loop)
await asyncio.sleep(0.2)
raise Abort
with self.tcp_server(srv_gen) as srv:
+
sock = socket.socket()
with sock:
sock.setblocking(False)
@@ -627,7 +610,7 @@ def test_socket_close_remove_writer(self):
def test_socket_cancel_sock_recv_1(self):
def srv_gen(sock):
time.sleep(1.2)
- sock.send(b"helo")
+ sock.send(b'helo')
async def kill(fut):
await asyncio.sleep(0.2)
@@ -636,9 +619,8 @@ async def kill(fut):
async def client(sock, addr):
await self.loop.sock_connect(sock, addr)
- f = asyncio.ensure_future(
- self.loop.sock_recv(sock, 10), loop=self.loop
- )
+ f = asyncio.ensure_future(self.loop.sock_recv(sock, 10),
+ loop=self.loop)
self.loop.create_task(kill(f))
with self.assertRaises(asyncio.CancelledError):
await f
@@ -646,6 +628,7 @@ async def client(sock, addr):
self.assertEqual(sock.fileno(), -1)
with self.tcp_server(srv_gen) as srv:
+
sock = socket.socket()
with sock:
sock.setblocking(False)
@@ -656,7 +639,7 @@ async def client(sock, addr):
def test_socket_cancel_sock_recv_2(self):
def srv_gen(sock):
time.sleep(1.2)
- sock.send(b"helo")
+ sock.send(b'helo')
async def kill(fut):
await asyncio.sleep(0.5)
@@ -685,6 +668,7 @@ async def client(sock, addr):
self.assertEqual(sock.fileno(), -1)
with self.tcp_server(srv_gen) as srv:
+
sock = socket.socket()
with sock:
sock.setblocking(False)
@@ -712,7 +696,7 @@ async def client(sock, addr):
# early in kill(f).
C = 25 if sys.platform == "win32" else 1
f = asyncio.ensure_future(
- self.loop.sock_sendall(sock, b"helo" * (1024 * 1024 * 50 * C)),
+ self.loop.sock_sendall(sock, b'helo' * (1024 * 1024 * 50 * C)),
loop=self.loop,
)
self.loop.create_task(kill(f))
diff --git a/tests/test_sourcecode.py b/tests/test_sourcecode.py
index 8ed668898..370ec6ff4 100644
--- a/tests/test_sourcecode.py
+++ b/tests/test_sourcecode.py
@@ -12,62 +12,61 @@ class TestSourceCode(unittest.TestCase):
def test_flake8(self):
edgepath = find_uvloop_root()
- config_path = os.path.join(edgepath, ".flake8")
+ config_path = os.path.join(edgepath, '.flake8')
if not os.path.exists(config_path):
- raise RuntimeError("could not locate .flake8 file")
+ raise RuntimeError('could not locate .flake8 file')
try:
import flake8 # NoQA
except ImportError:
- raise unittest.SkipTest("flake8 module is missing")
+ raise unittest.SkipTest('flake8 module is missing')
- for subdir in ["examples", "uvloop", "tests"]:
+ for subdir in ['examples', 'uvloop', 'tests']:
try:
subprocess.run(
- [sys.executable, "-m", "flake8", "--config", config_path],
+ [sys.executable, '-m', 'flake8', '--config', config_path],
check=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
- cwd=os.path.join(edgepath, subdir),
- )
+ cwd=os.path.join(edgepath, subdir))
except subprocess.CalledProcessError as ex:
output = ex.stdout.decode()
- output += "\n"
+ output += '\n'
output += ex.stderr.decode()
raise AssertionError(
- "flake8 validation failed: {}\n{}".format(ex, output)
+ 'flake8 validation failed: {}\n{}'.format(ex, output)
) from None
def test_mypy(self):
edgepath = find_uvloop_root()
- config_path = os.path.join(edgepath, "mypy.ini")
+ config_path = os.path.join(edgepath, 'mypy.ini')
if not os.path.exists(config_path):
- raise RuntimeError("could not locate mypy.ini file")
+ raise RuntimeError('could not locate mypy.ini file')
try:
import mypy # NoQA
except ImportError:
- raise unittest.SkipTest("mypy module is missing")
+ raise unittest.SkipTest('mypy module is missing')
try:
subprocess.run(
[
sys.executable,
- "-m",
- "mypy",
- "--config-file",
+ '-m',
+ 'mypy',
+ '--config-file',
config_path,
- "uvloop",
+ 'uvloop'
],
check=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
- cwd=edgepath,
+ cwd=edgepath
)
except subprocess.CalledProcessError as ex:
output = ex.stdout.decode()
- output += "\n"
+ output += '\n'
output += ex.stderr.decode()
raise AssertionError(
- "mypy validation failed: {}\n{}".format(ex, output)
+ 'mypy validation failed: {}\n{}'.format(ex, output)
) from None
diff --git a/tests/test_tcp.py b/tests/test_tcp.py
index 8e917dc9d..ba9d7f8fc 100644
--- a/tests/test_tcp.py
+++ b/tests/test_tcp.py
@@ -12,15 +12,11 @@
import unittest.mock
import weakref
-try:
- from OpenSSL import SSL as openssl_ssl
-
- SKIP_OPENSSL = False
-except ModuleNotFoundError:
- SKIP_OPENSSL = True
+from OpenSSL import SSL as openssl_ssl
from uvloop import _testbase as tb
+
SSL_HANDSHAKE_TIMEOUT = 15.0
@@ -30,7 +26,7 @@ class MyBaseProto(asyncio.Protocol):
def __init__(self, loop=None):
self.transport = None
- self.state = "INITIAL"
+ self.state = 'INITIAL'
self.nbytes = 0
if loop is not None:
self.connected = asyncio.Future(loop=loop)
@@ -38,54 +34,53 @@ def __init__(self, loop=None):
def connection_made(self, transport):
self.transport = transport
- assert self.state == "INITIAL", self.state
- self.state = "CONNECTED"
+ assert self.state == 'INITIAL', self.state
+ self.state = 'CONNECTED'
if self.connected:
self.connected.set_result(None)
def data_received(self, data):
- assert self.state == "CONNECTED", self.state
+ assert self.state == 'CONNECTED', self.state
self.nbytes += len(data)
def eof_received(self):
- assert self.state == "CONNECTED", self.state
- self.state = "EOF"
+ assert self.state == 'CONNECTED', self.state
+ self.state = 'EOF'
def connection_lost(self, exc):
- assert self.state in ("CONNECTED", "EOF"), self.state
- self.state = "CLOSED"
+ assert self.state in ('CONNECTED', 'EOF'), self.state
+ self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class _TestTCP:
def test_create_server_1(self):
- CNT = 0 # number of clients that were successful
- TOTAL_CNT = 25 # total number of clients that test will create
- TIMEOUT = 5.0 # timeout for this test
+ CNT = 0 # number of clients that were successful
+ TOTAL_CNT = 25 # total number of clients that test will create
+ TIMEOUT = 5.0 # timeout for this test
- A_DATA = b"A" * 1024 * 1024
- B_DATA = b"B" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
+ B_DATA = b'B' * 1024 * 1024
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
- writer.write(b"OK")
+ writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
- writer.writelines([b"S", b"P"])
- writer.write(bytearray(b"A"))
- writer.write(memoryview(b"M"))
+ writer.writelines([b'S', b'P'])
+ writer.write(bytearray(b'A'))
+ writer.write(memoryview(b'M'))
- if self.implementation == "uvloop":
+ if self.implementation == 'uvloop':
tr = writer.transport
- sock = tr.get_extra_info("socket")
+ sock = tr.get_extra_info('socket')
self.assertTrue(
- sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY)
- )
+ sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY))
await writer.drain()
writer.close()
@@ -100,17 +95,17 @@ async def test_client(addr):
await self.loop.sock_sendall(sock, A_DATA)
- buf = b""
+ buf = b''
while len(buf) != 2:
buf += await self.loop.sock_recv(sock, 1)
- self.assertEqual(buf, b"OK")
+ self.assertEqual(buf, b'OK')
await self.loop.sock_sendall(sock, B_DATA)
- buf = b""
+ buf = b''
while len(buf) != 4:
buf += await self.loop.sock_recv(sock, 1)
- self.assertEqual(buf, b"SPAM")
+ self.assertEqual(buf, b'SPAM')
self.assertEqual(sock.fileno(), -1)
self.assertEqual(sock._io_refs, 0)
@@ -122,10 +117,8 @@ async def start_server():
srv = await asyncio.start_server(
handle_client,
- ("127.0.0.1", "localhost"),
- 0,
- family=socket.AF_INET,
- )
+ ('127.0.0.1', 'localhost'), 0,
+ family=socket.AF_INET)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
@@ -142,10 +135,9 @@ async def start_server():
self.loop.call_soon(srv.close)
await srv.wait_closed()
- if self.implementation == "asyncio" and sys.version_info[:3] >= (
- 3,
- 12,
- 0,
+ if (
+ self.implementation == 'asyncio'
+ and sys.version_info[:3] >= (3, 12, 0)
):
# asyncio regression in 3.12 -- wait_closed()
# doesn't wait for `close()` to actually complete.
@@ -163,12 +155,14 @@ async def start_server_sock():
CNT = 0
sock = socket.socket()
- sock.bind(("127.0.0.1", 0))
+ sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
srv = await asyncio.start_server(
- handle_client, None, None, family=socket.AF_INET, sock=sock
- )
+ handle_client,
+ None, None,
+ family=socket.AF_INET,
+ sock=sock)
self.assertIs(srv.get_loop(), self.loop)
@@ -185,10 +179,9 @@ async def start_server_sock():
srv.close()
await srv.wait_closed()
- if self.implementation == "asyncio" and sys.version_info[:3] >= (
- 3,
- 12,
- 0,
+ if (
+ self.implementation == 'asyncio'
+ and sys.version_info[:3] >= (3, 12, 0)
):
# asyncio regression in 3.12 -- wait_closed()
# doesn't wait for `close()` to actually complete.
@@ -208,20 +201,19 @@ async def start_server_sock():
self.assertEqual(CNT, TOTAL_CNT)
def test_create_server_2(self):
- with self.assertRaisesRegex(ValueError, "nor sock were specified"):
+ with self.assertRaisesRegex(ValueError, 'nor sock were specified'):
self.loop.run_until_complete(self.loop.create_server(object))
def test_create_server_3(self):
"""check ephemeral port can be used"""
async def start_server_ephemeral_ports():
+
for port_sentinel in [0, None]:
srv = await self.loop.create_server(
asyncio.Protocol,
- "127.0.0.1",
- port_sentinel,
- family=socket.AF_INET,
- )
+ '127.0.0.1', port_sentinel,
+ family=socket.AF_INET)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
@@ -233,12 +225,9 @@ async def start_server_ephemeral_ports():
self.loop.call_soon(srv.close)
await srv.wait_closed()
- if self.implementation == "asyncio" and sys.version_info[
- :3
- ] >= (
- 3,
- 12,
- 0,
+ if (
+ self.implementation == 'asyncio'
+ and sys.version_info[:3] >= (3, 12, 0)
):
# asyncio regression in 3.12 -- wait_closed()
# doesn't wait for `close()` to actually complete.
@@ -255,28 +244,27 @@ async def start_server_ephemeral_ports():
def test_create_server_4(self):
sock = socket.socket()
- sock.bind(("127.0.0.1", 0))
+ sock.bind(('127.0.0.1', 0))
with sock:
addr = sock.getsockname()
- # Winloop comment: different asyncio error message on Windows
- # "[Errno 10048] error while attempting to bind on address
- # ('127.0.0.1', 31098): only one usage of each socket address
- # (protocol/network address/port) is normally permitted"
- # NB: Python 3.12.5+ adds "[winerror 10048] " before "only one ..."
- with self.assertRaisesRegex(
- OSError,
- r"error while attempting.*\('127.*:"
- + (
- r"( \[errno \d+\])? address" r"( already)? in use"
- if sys.platform != "win32"
- else r"( \[winerror \d+\])? " r"only one usage of each"
- ),
- ):
+ with self.assertRaises(OSError) as cm:
self.loop.run_until_complete(
self.loop.create_server(object, *addr)
)
+ if sys.platform == "win32":
+ self.assertEqual(
+ getattr(cm.exception, "winerror", None)
+ or cm.exception.errno,
+ 10048,
+ )
+ else:
+ self.assertRegex(
+ str(cm.exception),
+ r"error while attempting.*\('127.*:"
+ r"( \[errno \d+\])? address( already)? in use",
+ )
def test_create_server_5(self):
# Test that create_server sets the TCP_IPV6ONLY flag,
@@ -286,7 +274,9 @@ def test_create_server_5(self):
port = tb.find_free_port()
async def runner():
- srv = await self.loop.create_server(asyncio.Protocol, None, port)
+ srv = await self.loop.create_server(
+ asyncio.Protocol,
+ None, port)
srv.close()
await srv.wait_closed()
@@ -294,19 +284,22 @@ async def runner():
self.loop.run_until_complete(runner())
def test_create_server_6(self):
- if not hasattr(socket, "SO_REUSEPORT"):
- raise unittest.SkipTest("The system does not support SO_REUSEPORT")
+ if not hasattr(socket, 'SO_REUSEPORT'):
+ raise unittest.SkipTest(
+ 'The system does not support SO_REUSEPORT')
port = tb.find_free_port()
async def runner():
srv1 = await self.loop.create_server(
- asyncio.Protocol, None, port, reuse_port=True
- )
+ asyncio.Protocol,
+ None, port,
+ reuse_port=True)
srv2 = await self.loop.create_server(
- asyncio.Protocol, None, port, reuse_port=True
- )
+ asyncio.Protocol,
+ None, port,
+ reuse_port=True)
srv1.close()
srv2.close()
@@ -325,11 +318,11 @@ def test_create_server_7(self):
class Proto(asyncio.Protocol):
def connection_made(self, tr):
self.tr = tr
- self.tr.write(b"hello")
+ self.tr.write(b'hello')
async def test():
port = tb.find_free_port()
- srv = await self.loop.create_server(Proto, "127.0.0.1", port)
+ srv = await self.loop.create_server(Proto, '127.0.0.1', port)
wsrv = weakref.ref(srv)
del srv
@@ -340,9 +333,9 @@ async def test():
s = socket.socket(socket.AF_INET)
with s:
s.setblocking(False)
- await self.loop.sock_connect(s, ("127.0.0.1", port))
+ await self.loop.sock_connect(s, ('127.0.0.1', port))
d = await self.loop.sock_recv(s, 100)
- self.assertEqual(d, b"hello")
+ self.assertEqual(d, b'hello')
srv = wsrv()
srv.close()
@@ -362,16 +355,11 @@ async def test():
def test_create_server_8(self):
with self.assertRaisesRegex(
- ValueError, "ssl_handshake_timeout is only meaningful"
- ):
+ ValueError, 'ssl_handshake_timeout is only meaningful'):
self.loop.run_until_complete(
self.loop.create_server(
- lambda: None,
- host="::",
- port=0,
- ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT,
- )
- )
+ lambda: None, host='::', port=0,
+ ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT))
def test_create_server_9(self):
async def handle_client(reader, writer):
@@ -380,11 +368,9 @@ async def handle_client(reader, writer):
async def start_server():
srv = await asyncio.start_server(
handle_client,
- "127.0.0.1",
- 0,
+ '127.0.0.1', 0,
family=socket.AF_INET,
- start_serving=False,
- )
+ start_serving=False)
await srv.start_serving()
self.assertTrue(srv.is_serving())
@@ -406,11 +392,9 @@ async def handle_client(reader, writer):
async def start_server():
srv = await asyncio.start_server(
handle_client,
- "127.0.0.1",
- 0,
+ '127.0.0.1', 0,
family=socket.AF_INET,
- start_serving=False,
- )
+ start_serving=False)
async with srv:
fut = asyncio.ensure_future(srv.serve_forever())
@@ -428,25 +412,24 @@ def test_create_connection_open_con_addr(self):
async def client(addr):
reader, writer = await asyncio.open_connection(*addr)
- writer.write(b"AAAA")
- self.assertEqual(await reader.readexactly(2), b"OK")
+ writer.write(b'AAAA')
+ self.assertEqual(await reader.readexactly(2), b'OK')
re = (
r"(a bytes-like object)|(must be byte-ish)|(bytes\, "
r"bytearray\, or memoryview object\, not 'str')"
)
with self.assertRaisesRegex(TypeError, re):
- writer.write("AAAA")
+ writer.write('AAAA')
- writer.write(b"BBBB")
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ writer.write(b'BBBB')
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
- if self.implementation == "uvloop":
+ if self.implementation == 'uvloop':
tr = writer.transport
- sock = tr.get_extra_info("socket")
+ sock = tr.get_extra_info('socket')
self.assertTrue(
- sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY)
- )
+ sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY))
writer.close()
await self.wait_closed(writer)
@@ -459,18 +442,17 @@ async def client(addr):
sock.connect(addr)
reader, writer = await asyncio.open_connection(sock=sock)
- writer.write(b"AAAA")
- self.assertEqual(await reader.readexactly(2), b"OK")
+ writer.write(b'AAAA')
+ self.assertEqual(await reader.readexactly(2), b'OK')
- writer.write(b"BBBB")
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ writer.write(b'BBBB')
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
- if self.implementation == "uvloop":
+ if self.implementation == 'uvloop':
tr = writer.transport
- sock = tr.get_extra_info("socket")
+ sock = tr.get_extra_info('socket')
self.assertTrue(
- sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY)
- )
+ sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY))
writer.close()
await self.wait_closed(writer)
@@ -483,12 +465,12 @@ def _test_create_connection_1(self, client):
def server(sock):
data = sock.recv_all(4)
- self.assertEqual(data, b"AAAA")
- sock.send(b"OK")
+ self.assertEqual(data, b'AAAA')
+ sock.send(b'OK')
data = sock.recv_all(4)
- self.assertEqual(data, b"BBBB")
- sock.send(b"SPAM")
+ self.assertEqual(data, b'BBBB')
+ sock.send(b'SPAM')
async def client_wrapper(addr):
await client(addr)
@@ -499,9 +481,9 @@ def run(coro):
nonlocal CNT
CNT = 0
- with self.tcp_server(
- server, max_clients=TOTAL_CNT, backlog=TOTAL_CNT
- ) as srv:
+ with self.tcp_server(server,
+ max_clients=TOTAL_CNT,
+ backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
@@ -515,7 +497,7 @@ def run(coro):
def test_create_connection_2(self):
sock = socket.socket()
with sock:
- sock.bind(("127.0.0.1", 0))
+ sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
async def client():
@@ -535,13 +517,13 @@ def test_create_connection_3(self):
def server(sock):
data = sock.recv_all(4)
- self.assertEqual(data, b"AAAA")
+ self.assertEqual(data, b'AAAA')
sock.close()
async def client(addr):
reader, writer = await asyncio.open_connection(*addr)
- writer.write(b"AAAA")
+ writer.write(b'AAAA')
with self.assertRaises(asyncio.IncompleteReadError):
await reader.readexactly(10)
@@ -556,9 +538,9 @@ def run(coro):
nonlocal CNT
CNT = 0
- with self.tcp_server(
- server, max_clients=TOTAL_CNT, backlog=TOTAL_CNT
- ) as srv:
+ with self.tcp_server(server,
+ max_clients=TOTAL_CNT,
+ backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
@@ -579,14 +561,16 @@ async def client():
await self.wait_closed(writer)
async def runner():
- # Winloop comment: different asyncio error message on Windows
- # "[WinError 10038] An operation was attempted on something
- # that is not a socket"
- with self.assertRaisesRegex(
- OSError,
- ("not a socket" if sys.platform == "win32" else "Bad file"),
- ):
+ with self.assertRaises(OSError) as cm:
await client()
+ if sys.platform == "win32":
+ self.assertEqual(
+ getattr(cm.exception, "winerror", None)
+ or cm.exception.errno,
+ 10038,
+ )
+ else:
+ self.assertRegex(str(cm.exception), "Bad file")
self.loop.run_until_complete(runner())
@@ -596,46 +580,42 @@ def server(sock):
data = sock.recv_all(4)
except ConnectionError:
return
- self.assertEqual(data, b"AAAA")
- sock.send(b"OK")
+ self.assertEqual(data, b'AAAA')
+ sock.send(b'OK')
async def client(addr):
fut = asyncio.ensure_future(
- self.loop.create_connection(asyncio.Protocol, *addr)
- )
+ self.loop.create_connection(asyncio.Protocol, *addr))
await asyncio.sleep(0)
fut.cancel()
with self.assertRaises(asyncio.CancelledError):
await fut
- with self.tcp_server(server, max_clients=1, backlog=1) as srv:
+ with self.tcp_server(server,
+ max_clients=1,
+ backlog=1) as srv:
self.loop.run_until_complete(client(srv.addr))
def test_create_connection_6(self):
with self.assertRaisesRegex(
- ValueError, "ssl_handshake_timeout is only meaningful"
- ):
+ ValueError, 'ssl_handshake_timeout is only meaningful'):
self.loop.run_until_complete(
self.loop.create_connection(
- lambda: None,
- host="::",
- port=0,
- ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT,
- )
- )
+ lambda: None, host='::', port=0,
+ ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT))
def test_transport_shutdown(self):
- CNT = 0 # number of clients that were successful
- TOTAL_CNT = 100 # total number of clients that test will create
- TIMEOUT = 5.0 # timeout for this test
+ CNT = 0 # number of clients that were successful
+ TOTAL_CNT = 100 # total number of clients that test will create
+ TIMEOUT = 5.0 # timeout for this test
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(4)
- self.assertEqual(data, b"AAAA")
+ self.assertEqual(data, b'AAAA')
- writer.write(b"OK")
+ writer.write(b'OK')
writer.write_eof()
writer.write_eof()
@@ -647,9 +627,9 @@ async def handle_client(reader, writer):
async def test_client(addr):
reader, writer = await asyncio.open_connection(*addr)
- writer.write(b"AAAA")
+ writer.write(b'AAAA')
data = await reader.readexactly(2)
- self.assertEqual(data, b"OK")
+ self.assertEqual(data, b'OK')
writer.close()
await self.wait_closed(writer)
@@ -659,8 +639,9 @@ async def start_server():
CNT = 0
srv = await asyncio.start_server(
- handle_client, "127.0.0.1", 0, family=socket.AF_INET
- )
+ handle_client,
+ '127.0.0.1', 0,
+ family=socket.AF_INET)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
@@ -702,17 +683,16 @@ def connection_made(self, tr):
def connection_lost(self, exc):
connection_lost_called.set_result(exc)
- srv = self.loop.run_until_complete(
- asyncio.start_server(server, "127.0.0.1", 0, family=socket.AF_INET)
- )
+ srv = self.loop.run_until_complete(asyncio.start_server(
+ server,
+ '127.0.0.1', 0,
+ family=socket.AF_INET))
async def runner():
tr, pr = await asyncio.wait_for(
self.loop.create_connection(
- Proto, *srv.sockets[0].getsockname()
- ),
- timeout=1.0,
- )
+ Proto, *srv.sockets[0].getsockname()),
+ timeout=1.0)
fut.set_result(None)
tr.close()
@@ -721,7 +701,8 @@ async def runner():
self.loop.run_until_complete(srv.wait_closed())
self.loop.run_until_complete(fut)
- self.assertIsNone(self.loop.run_until_complete(connection_lost_called))
+ self.assertIsNone(
+ self.loop.run_until_complete(connection_lost_called))
def test_resume_writing_write_different_transport(self):
loop = self.loop
@@ -740,7 +721,7 @@ def pause_writing(self):
def resume_writing(self):
self.paused = False
- self.t2.write(b"hello")
+ self.t2.write(b'hello')
s1, s2 = socket.socketpair()
s1.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024)
@@ -752,17 +733,17 @@ async def _test(t1, p1, t2):
# fill s1 up first
t2.pause_reading()
while not p1.paused:
- t1.write(b" " * 1024)
+ t1.write(b' ' * 1024)
# trigger resume_writing() in _exec_queued_writes() with tight loop
t2.resume_reading()
while p1.paused:
- t1.write(b" ")
+ t1.write(b' ')
await asyncio.sleep(0)
# t2.write() in p1.resume_writing() should work fine
data = await asyncio.wait_for(p1.waiter, 5)
- self.assertEqual(data, b"hello")
+ self.assertEqual(data, b'hello')
async def test():
t2, _ = await loop.create_connection(asyncio.Protocol, sock=s2)
@@ -787,8 +768,7 @@ async def client(addr):
await asyncio.sleep(0.01)
task = asyncio.ensure_future(
- self.loop.create_connection(asyncio.Protocol, sock=sock)
- )
+ self.loop.create_connection(asyncio.Protocol, sock=sock))
await asyncio.sleep(0)
task.cancel()
with self.assertRaises(asyncio.CancelledError):
@@ -804,10 +784,11 @@ def _recv_or_abort(sock):
except ConnectionAbortedError:
pass
- with self.tcp_server(_recv_or_abort, max_clients=1, backlog=1) as srv:
+ with self.tcp_server(_recv_or_abort,
+ max_clients=1,
+ backlog=1) as srv:
self.loop.run_until_complete(client(srv.addr))
- @unittest.skip("TODO: Line 878 is the culprit.")
def test_create_connection_sock_cancel_fd_leak(self):
# Regression test for https://github.com/MagicStack/uvloop/issues/645
# and https://github.com/aio-libs/aiohttp/issues/10506
@@ -825,7 +806,7 @@ def test_create_connection_sock_cancel_fd_leak(self):
async def test():
srv = await asyncio.start_server(
- lambda r, w: w.close(), "127.0.0.1", 0, family=socket.AF_INET
+ lambda r, w: w.close(), '127.0.0.1', 0, family=socket.AF_INET
)
addr = srv.sockets[0].getsockname()
@@ -847,7 +828,7 @@ async def test():
victim_tr, _ = await self.loop.create_connection(
asyncio.Protocol, *addr
)
- victim_fd = victim_tr.get_extra_info("socket").fileno()
+ victim_fd = victim_tr.get_extra_info('socket').fileno()
if victim_fd != stale_fd:
victim_tr.close()
sock.close()
@@ -881,16 +862,15 @@ async def test():
except OSError as e:
# Windows has a much different way of taking care
# of these kinds of interactions.
- if sys.platform == "win32":
- if e.errno == errno.EBADF:
- # At this point Windows did it's job at preventing
- # the file descriptor from leaking.
- victim_tr.close()
- srv.close()
- await srv.wait_closed()
- spy_a.close()
- spy_b.close()
- return
+ if sys.platform == "win32" and e.errno == errno.EBADF:
+ # At this point Windows did it's job at preventing
+ # the file descriptor from leaking.
+ victim_tr.close()
+ srv.close()
+ await srv.wait_closed()
+ spy_a.close()
+ spy_b.close()
+ return
# if the OS is not windows or something else
# happened raise the exception given.
raise e
@@ -899,12 +879,12 @@ async def test():
# Victim writes. If victim_broken, writev(stale_fd) goes
# to the spy; otherwise it goes to the real connection.
- victim_tr.write(b"LEAKED")
+ victim_tr.write(b'LEAKED')
try:
leaked = spy_b.recv(4096)
except BlockingIOError:
- leaked = b""
+ leaked = b''
if victim_broken:
os.close(stale_fd)
@@ -915,7 +895,7 @@ async def test():
self.assertEqual(
leaked,
- b"",
+ b'',
f"Data leaked to an unrelated socket: " f"got {leaked!r}",
)
@@ -931,7 +911,7 @@ def test_create_server_buffered_1(self):
class Proto(asyncio.BaseProtocol):
def connection_made(self, tr):
self.tr = tr
- self.recvd = b""
+ self.recvd = b''
self.data = bytearray(50)
self.buf = memoryview(self.data)
@@ -940,8 +920,8 @@ def get_buffer(self, sizehint):
def buffer_updated(self, nbytes):
self.recvd += self.buf[:nbytes]
- if self.recvd == b"a" * SIZE:
- self.tr.write(b"hello")
+ if self.recvd == b'a' * SIZE:
+ self.tr.write(b'hello')
def eof_received(self):
nonlocal eof
@@ -952,15 +932,15 @@ def connection_lost(self, exc):
async def test():
port = tb.find_free_port()
- srv = await self.loop.create_server(Proto, "127.0.0.1", port)
+ srv = await self.loop.create_server(Proto, '127.0.0.1', port)
s = socket.socket(socket.AF_INET)
with s:
s.setblocking(False)
- await self.loop.sock_connect(s, ("127.0.0.1", port))
- await self.loop.sock_sendall(s, b"a" * SIZE)
+ await self.loop.sock_connect(s, ('127.0.0.1', port))
+ await self.loop.sock_sendall(s, b'a' * SIZE)
d = await self.loop.sock_recv(s, 100)
- self.assertEqual(d, b"hello")
+ self.assertEqual(d, b'hello')
srv.close()
await srv.wait_closed()
@@ -1027,7 +1007,7 @@ def get_buffer(self, sizehint):
return memoryview(bytearray(100))
def buffer_updated(self, nbytes):
- raise RuntimeError("oups")
+ raise RuntimeError('oups')
def connection_lost(self, exc):
self._lost_exc = exc
@@ -1039,15 +1019,14 @@ async def test(proto_factory, exc_type, exc_re):
port = tb.find_free_port()
proto = proto_factory()
srv = await self.loop.create_server(
- lambda: proto, "127.0.0.1", port
- )
+ lambda: proto, '127.0.0.1', port)
try:
s = socket.socket(socket.AF_INET)
with s:
s.setblocking(False)
- await self.loop.sock_connect(s, ("127.0.0.1", port))
- await self.loop.sock_sendall(s, b"a")
+ await self.loop.sock_connect(s, ('127.0.0.1', port))
+ await self.loop.sock_sendall(s, b'a')
d = await self.loop.sock_recv(s, 100)
if not d:
raise ConnectionResetError
@@ -1070,20 +1049,16 @@ async def test(proto_factory, exc_type, exc_re):
self.loop.set_exception_handler(lambda loop, ctx: None)
self.loop.run_until_complete(
- test(ProtoExc, RuntimeError, "unhandled error .* get_buffer")
- )
+ test(ProtoExc, RuntimeError, 'unhandled error .* get_buffer'))
self.loop.run_until_complete(
- test(ProtoZeroBuf1, RuntimeError, "unhandled error .* get_buffer")
- )
+ test(ProtoZeroBuf1, RuntimeError, 'unhandled error .* get_buffer'))
self.loop.run_until_complete(
- test(ProtoZeroBuf2, RuntimeError, "unhandled error .* get_buffer")
- )
+ test(ProtoZeroBuf2, RuntimeError, 'unhandled error .* get_buffer'))
self.loop.run_until_complete(
- test(ProtoUpdatedError, RuntimeError, r"^oups$")
- )
+ test(ProtoUpdatedError, RuntimeError, r'^oups$'))
def test_transport_get_extra_info(self):
# This tests is only for uvloop. asyncio should pass it
@@ -1106,10 +1081,9 @@ async def handle_client(reader, writer):
async def test_client(addr):
t, p = await self.loop.create_connection(
- lambda: asyncio.Protocol(), *addr
- )
+ lambda: asyncio.Protocol(), *addr)
- if hasattr(t, "get_protocol"):
+ if hasattr(t, 'get_protocol'):
p2 = asyncio.Protocol()
self.assertIs(t.get_protocol(), p)
t.set_protocol(p2)
@@ -1127,24 +1101,26 @@ async def test_client(addr):
self.assertFalse(t._paused)
self.assertTrue(t.is_reading())
- sock = t.get_extra_info("socket")
- self.assertIs(sock, t.get_extra_info("socket"))
+ sock = t.get_extra_info('socket')
+ self.assertIs(sock, t.get_extra_info('socket'))
sockname = sock.getsockname()
peername = sock.getpeername()
- with self.assertRaisesRegex(RuntimeError, "is used by transport"):
+ with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_writer(sock.fileno(), lambda: None)
- with self.assertRaisesRegex(RuntimeError, "is used by transport"):
+ with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_writer(sock.fileno())
- with self.assertRaisesRegex(RuntimeError, "is used by transport"):
+ with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_reader(sock.fileno(), lambda: None)
- with self.assertRaisesRegex(RuntimeError, "is used by transport"):
+ with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_reader(sock.fileno())
- self.assertEqual(t.get_extra_info("sockname"), sockname)
- self.assertEqual(t.get_extra_info("peername"), peername)
+ self.assertEqual(t.get_extra_info('sockname'),
+ sockname)
+ self.assertEqual(t.get_extra_info('peername'),
+ peername)
- t.write(b"OK") # We want server to fail.
+ t.write(b'OK') # We want server to fail.
self.assertFalse(t._closing)
t.abort()
@@ -1160,13 +1136,16 @@ async def test_client(addr):
# Test that peername and sockname are available after
# the transport is closed.
- self.assertEqual(t.get_extra_info("peername"), peername)
- self.assertEqual(t.get_extra_info("sockname"), sockname)
+ self.assertEqual(t.get_extra_info('peername'),
+ peername)
+ self.assertEqual(t.get_extra_info('sockname'),
+ sockname)
async def start_server():
srv = await asyncio.start_server(
- handle_client, "127.0.0.1", 0, family=socket.AF_INET
- )
+ handle_client,
+ '127.0.0.1', 0,
+ family=socket.AF_INET)
addr = srv.sockets[0].getsockname()
await test_client(addr)
@@ -1181,12 +1160,12 @@ def test_create_server_float_backlog(self):
async def runner(bl):
await self.loop.create_server(
- asyncio.Protocol, None, 0, backlog=bl
- )
+ asyncio.Protocol,
+ None, 0, backlog=bl)
- for bl in (1.1, "1"):
+ for bl in (1.1, '1'):
with self.subTest(backlog=bl):
- with self.assertRaisesRegex(TypeError, "integer"):
+ with self.assertRaisesRegex(TypeError, 'integer'):
self.loop.run_until_complete(runner(bl))
def test_many_small_writes(self):
@@ -1207,13 +1186,14 @@ async def server(reader, writer):
async def run():
srv = await asyncio.start_server(
- server, "127.0.0.1", 0, family=socket.AF_INET
- )
+ server,
+ '127.0.0.1', 0,
+ family=socket.AF_INET)
addr = srv.sockets[0].getsockname()
r, w = await asyncio.open_connection(*addr)
- DATA = b"x" * 102400
+ DATA = b'x' * 102400
# Test _StreamWriteContext with short sequences of writes
w.write(DATA)
@@ -1229,7 +1209,7 @@ async def run():
w.write(DATA)
try:
- w.write("a")
+ w.write('a')
except TypeError:
pass
@@ -1260,23 +1240,22 @@ class Proto(asyncio.Protocol):
def connection_made(self, tr):
tr.abort()
- srv = self.loop.run_until_complete(
- asyncio.start_server(server, "127.0.0.1", 0, family=socket.AF_INET)
- )
+ srv = self.loop.run_until_complete(asyncio.start_server(
+ server,
+ '127.0.0.1', 0,
+ family=socket.AF_INET))
async def runner():
tr, pr = await asyncio.wait_for(
self.loop.create_connection(
- Proto, *srv.sockets[0].getsockname()
- ),
- timeout=1.0,
- )
+ Proto, *srv.sockets[0].getsockname()),
+ timeout=1.0)
# Asyncio would return a closed socket, which we
# can't do: the transport was aborted, hence there
# is no FD to attach a socket to (to make
# get_extra_info() work).
- self.assertIsNone(tr.get_extra_info("socket"))
+ self.assertIsNone(tr.get_extra_info('socket'))
tr.close()
self.loop.run_until_complete(runner())
@@ -1285,14 +1264,13 @@ async def runner():
def test_connect_accepted_socket_ssl_args(self):
with self.assertRaisesRegex(
- ValueError, "ssl_handshake_timeout is only meaningful"
- ):
+ ValueError, 'ssl_handshake_timeout is only meaningful'):
with socket.socket() as s:
self.loop.run_until_complete(
self.loop.connect_accepted_socket(
(lambda: None),
s,
- ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT,
+ ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT
)
)
@@ -1300,6 +1278,7 @@ def test_connect_accepted_socket(self, server_ssl=None, client_ssl=None):
loop = self.loop
class MyProto(MyBaseProto):
+
def connection_lost(self, exc):
super().connection_lost(exc)
loop.call_soon(loop.stop)
@@ -1309,13 +1288,13 @@ def data_received(self, data):
self.transport.write(expected_response)
lsock = socket.socket(socket.AF_INET)
- lsock.bind(("127.0.0.1", 0))
+ lsock.bind(('127.0.0.1', 0))
lsock.listen(1)
addr = lsock.getsockname()
- message = b"test data"
+ message = b'test data'
response = None
- expected_response = b"roger"
+ expected_response = b'roger'
def client():
nonlocal response
@@ -1330,8 +1309,7 @@ def client():
except Exception as exc:
print(
"Failure in client thread in test_connect_accepted_socket",
- exc,
- )
+ exc)
thread = threading.Thread(target=client, daemon=True)
thread.start()
@@ -1346,55 +1324,49 @@ def client():
f = loop.create_task(
loop.connect_accepted_socket(
- (lambda: proto), conn, ssl=server_ssl, **extras
- )
- )
+ (lambda: proto), conn, ssl=server_ssl,
+ **extras))
loop.run_forever()
conn.close()
lsock.close()
thread.join(1)
self.assertFalse(thread.is_alive())
- self.assertEqual(proto.state, "CLOSED")
+ self.assertEqual(proto.state, 'CLOSED')
self.assertEqual(proto.nbytes, len(message))
self.assertEqual(response, expected_response)
tr, _ = f.result()
if server_ssl:
- self.assertIn("SSL", tr.__class__.__name__)
+ self.assertIn('SSL', tr.__class__.__name__)
tr.close()
# let it close
self.loop.run_until_complete(asyncio.sleep(0.1))
- @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "no Unix sockets")
+ @unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'no Unix sockets')
def test_create_connection_wrong_sock(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
with sock:
coro = self.loop.create_connection(MyBaseProto, sock=sock)
- with self.assertRaisesRegex(
- ValueError, "A Stream Socket was expected"
- ):
+ with self.assertRaisesRegex(ValueError,
+ 'A Stream Socket was expected'):
self.loop.run_until_complete(coro)
- @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "no Unix sockets")
+ @unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'no Unix sockets')
def test_create_server_wrong_sock(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
with sock:
coro = self.loop.create_server(MyBaseProto, sock=sock)
- with self.assertRaisesRegex(
- ValueError, "A Stream Socket was expected"
- ):
+ with self.assertRaisesRegex(ValueError,
+ 'A Stream Socket was expected'):
self.loop.run_until_complete(coro)
- @unittest.skipUnless(
- hasattr(socket, "SOCK_NONBLOCK"),
- "no socket.SOCK_NONBLOCK (linux only)",
- )
+ @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
+ 'no socket.SOCK_NONBLOCK (linux only)')
def test_create_server_stream_bittype(self):
sock = socket.socket(
- socket.AF_INET, socket.SOCK_STREAM | socket.SOCK_NONBLOCK
- )
+ socket.AF_INET, socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
with sock:
coro = self.loop.create_server(lambda: None, sock=sock)
srv = self.loop.run_until_complete(coro)
@@ -1416,14 +1388,14 @@ def resume_writing(self):
t, p = await self.loop.create_connection(Protocol, *addr)
- t.write(b"q" * 512)
+ t.write(b'q' * 512)
self.assertEqual(t.get_write_buffer_size(), 512)
t.set_write_buffer_limits(low=16385)
self.assertFalse(paused)
self.assertEqual(t.get_write_buffer_limits(), (16385, 65540))
- with self.assertRaisesRegex(ValueError, "high.*must be >= low"):
+ with self.assertRaisesRegex(ValueError, 'high.*must be >= low'):
t.set_write_buffer_limits(high=0, low=1)
t.set_write_buffer_limits(high=1024, low=128)
@@ -1452,62 +1424,20 @@ def new_policy(self):
class _TestSSL(tb.SSLTestCase):
- ONLYCERT = tb._cert_fullname(__file__, "ssl_cert.pem")
- ONLYKEY = tb._cert_fullname(__file__, "ssl_key.pem")
+
+ ONLYCERT = tb._cert_fullname(__file__, 'ssl_cert.pem')
+ ONLYKEY = tb._cert_fullname(__file__, 'ssl_key.pem')
PAYLOAD_SIZE = 1024 * 100
TIMEOUT = 60
- def test_start_tls_buffer_transfer(self):
- if self.implementation == "asyncio":
- raise unittest.SkipTest()
-
- HELLO_MSG = b"1" * self.PAYLOAD_SIZE
- BUFFERED_MSG = b"buffered data before TLS"
-
- server_context = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
- # flake8 client_context unused.
- _ = self._create_client_ssl_context()
-
- async def handle_client(reader, writer):
- # Send data before TLS upgrade
- writer.write(BUFFERED_MSG)
- await writer.drain()
- await asyncio.sleep(0.2)
-
- # Read pre-TLS data
- data = await reader.readexactly(len(HELLO_MSG))
- self.assertEqual(len(data), len(HELLO_MSG))
-
- # Upgrade to TLS (server side)
- try:
- # We need the wait_for because the broken version hangs here
- await asyncio.wait_for(
- writer.start_tls(server_context), timeout=2
- )
- self.assertIsNotNone(writer.get_extra_info("sslcontext"))
- except asyncio.TimeoutError:
- self.assertIsNotNone(writer.get_extra_info("sslcontext"))
-
- # Send/receive over TLS
- writer.write(b"OK")
- await writer.drain()
-
- data = await reader.readexactly(len(HELLO_MSG))
- self.assertEqual(len(data), len(HELLO_MSG))
-
- writer.close()
- await self.wait_closed(writer)
-
def test_create_server_ssl_1(self):
- CNT = 0 # number of clients that were successful
- TOTAL_CNT = 25 # total number of clients that test will create
- TIMEOUT = 20.0 # timeout for this test
+ CNT = 0 # number of clients that were successful
+ TOTAL_CNT = 25 # total number of clients that test will create
+ TIMEOUT = 20.0 # timeout for this test
- A_DATA = b"A" * 1024 * 1024
- B_DATA = b"B" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
+ B_DATA = b'B' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
@@ -1519,11 +1449,11 @@ async def handle_client(reader, writer):
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
- writer.write(b"OK")
+ writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
- writer.writelines([b"SP", bytearray(b"A"), memoryview(b"M")])
+ writer.writelines([b'SP', bytearray(b'A'), memoryview(b'M')])
await writer.drain()
writer.close()
@@ -1540,11 +1470,11 @@ def prog(sock):
sock.send(A_DATA)
data = sock.recv_all(2)
- self.assertEqual(data, b"OK")
+ self.assertEqual(data, b'OK')
sock.send(B_DATA)
data = sock.recv_all(4)
- self.assertEqual(data, b"SPAM")
+ self.assertEqual(data, b'SPAM')
sock.close()
@@ -1564,12 +1494,10 @@ async def start_server():
srv = await asyncio.start_server(
handle_client,
- "127.0.0.1",
- 0,
+ '127.0.0.1', 0,
family=socket.AF_INET,
ssl=sslctx,
- **extras,
- )
+ **extras)
try:
srv_socks = srv.sockets
@@ -1596,29 +1524,31 @@ async def start_server():
client.stop()
def test_create_connection_ssl_1(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
# Don't crash on asyncio errors
self.loop.set_exception_handler(None)
CNT = 0
TOTAL_CNT = 25
- A_DATA = b"A" * 1024 * 1024
- B_DATA = b"B" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
+ B_DATA = b'B' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
def server(sock):
- sock.starttls(sslctx, server_side=True)
+ sock.starttls(
+ sslctx,
+ server_side=True)
data = sock.recv_all(len(A_DATA))
self.assertEqual(data, A_DATA)
- sock.send(b"OK")
+ sock.send(b'OK')
data = sock.recv_all(len(B_DATA))
self.assertEqual(data, B_DATA)
- sock.send(b"SPAM")
+ sock.send(b'SPAM')
sock.close()
@@ -1626,14 +1556,16 @@ async def client(addr):
extras = dict(ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT)
reader, writer = await asyncio.open_connection(
- *addr, ssl=client_sslctx, server_hostname="", **extras
- )
+ *addr,
+ ssl=client_sslctx,
+ server_hostname='',
+ **extras)
writer.write(A_DATA)
- self.assertEqual(await reader.readexactly(2), b"OK")
+ self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
@@ -1645,14 +1577,15 @@ async def client_sock(addr):
sock = socket.socket()
sock.connect(addr)
reader, writer = await asyncio.open_connection(
- sock=sock, ssl=client_sslctx, server_hostname=""
- )
+ sock=sock,
+ ssl=client_sslctx,
+ server_hostname='')
writer.write(A_DATA)
- self.assertEqual(await reader.readexactly(2), b"OK")
+ self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
@@ -1665,9 +1598,9 @@ def run(coro):
nonlocal CNT
CNT = 0
- with self.tcp_server(
- server, max_clients=TOTAL_CNT, backlog=TOTAL_CNT
- ) as srv:
+ with self.tcp_server(server,
+ max_clients=TOTAL_CNT,
+ backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
@@ -1683,7 +1616,7 @@ def run(coro):
run(client_sock)
def test_create_connection_ssl_slow_handshake(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
client_sslctx = self._create_client_ssl_context()
@@ -1703,20 +1636,23 @@ async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
- server_hostname="",
- ssl_handshake_timeout=1.0,
- )
+ server_hostname='',
+ ssl_handshake_timeout=1.0)
writer.close()
await self.wait_closed(writer)
- with self.tcp_server(server, max_clients=1, backlog=1) as srv:
+ with self.tcp_server(server,
+ max_clients=1,
+ backlog=1) as srv:
+
with self.assertRaisesRegex(
- ConnectionAbortedError, r"SSL handshake.*is taking longer"
- ):
+ ConnectionAbortedError,
+ r'SSL handshake.*is taking longer'):
+
self.loop.run_until_complete(client(srv.addr))
def test_create_connection_ssl_failed_certificate(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
# silence error logger
@@ -1727,7 +1663,9 @@ def test_create_connection_ssl_failed_certificate(self):
def server(sock):
try:
- sock.starttls(sslctx, server_side=True)
+ sock.starttls(
+ sslctx,
+ server_side=True)
sock.connect()
except (ssl.SSLError, OSError):
pass
@@ -1738,34 +1676,35 @@ async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
- server_hostname="",
- ssl_handshake_timeout=1.0,
- )
+ server_hostname='',
+ ssl_handshake_timeout=1.0)
writer.close()
await self.wait_closed(writer)
- with self.tcp_server(server, max_clients=1, backlog=1) as srv:
+ with self.tcp_server(server,
+ max_clients=1,
+ backlog=1) as srv:
+
with self.assertRaises(ssl.SSLCertVerificationError):
self.loop.run_until_complete(client(srv.addr))
def test_start_tls_wrong_args(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
async def main():
- with self.assertRaisesRegex(TypeError, "SSLContext, got"):
+ with self.assertRaisesRegex(TypeError, 'SSLContext, got'):
await self.loop.start_tls(None, None, None)
sslctx = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
- with self.assertRaisesRegex(TypeError, "is not supported"):
+ self.ONLYCERT, self.ONLYKEY)
+ with self.assertRaisesRegex(TypeError, 'is not supported'):
await self.loop.start_tls(None, None, sslctx)
self.loop.run_until_complete(main())
def test_ssl_handshake_timeout(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
# bpo-29970: Check that a connection is aborted if handshake is not
@@ -1793,13 +1732,16 @@ async def client(addr):
asyncio.Protocol,
*addr,
ssl=client_sslctx,
- server_hostname="",
- ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT,
+ server_hostname='',
+ ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT
),
- 0.5,
+ 0.5
)
- with self.tcp_server(server, max_clients=1, backlog=1) as srv:
+ with self.tcp_server(server,
+ max_clients=1,
+ backlog=1) as srv:
+
with self.assertRaises(asyncio.TimeoutError):
self.loop.run_until_complete(client(srv.addr))
@@ -1836,13 +1778,16 @@ def connection_lost(self, exc):
connection_lost_called = True
async def client(addr):
- (
- await self.loop.create_connection(
- ClientProto, *addr, ssl=client_sslctx, server_hostname=""
- ),
- )
+ await self.loop.create_connection(
+ ClientProto,
+ *addr,
+ ssl=client_sslctx,
+ server_hostname=''),
+
+ with self.tcp_server(server,
+ max_clients=1,
+ backlog=1) as srv:
- with self.tcp_server(server, max_clients=1, backlog=1) as srv:
with self.assertRaises(ConnectionResetError):
self.loop.run_until_complete(client(srv.addr))
@@ -1850,40 +1795,37 @@ async def client(addr):
if connection_made_called:
self.fail("unexpected call to connection_lost()")
else:
- self.fail(
- "unexpected call to connection_lost() without"
- "calling connection_made()"
- )
+ self.fail("unexpected call to connection_lost() without"
+ "calling connection_made()")
elif connection_made_called:
self.fail("unexpected call to connection_made()")
def test_ssl_connect_accepted_socket(self):
- if hasattr(ssl, "PROTOCOL_TLS_SERVER"):
+ if hasattr(ssl, 'PROTOCOL_TLS_SERVER'):
server_proto = ssl.PROTOCOL_TLS_SERVER
client_proto = ssl.PROTOCOL_TLS_CLIENT
else:
- if hasattr(ssl, "PROTOCOL_TLS"):
+ if hasattr(ssl, 'PROTOCOL_TLS'):
client_proto = server_proto = ssl.PROTOCOL_TLS
else:
client_proto = server_proto = ssl.PROTOCOL_SSLv23
server_context = ssl.SSLContext(server_proto)
server_context.load_cert_chain(self.ONLYCERT, self.ONLYKEY)
- if hasattr(server_context, "check_hostname"):
+ if hasattr(server_context, 'check_hostname'):
server_context.check_hostname = False
server_context.verify_mode = ssl.CERT_NONE
client_context = ssl.SSLContext(client_proto)
- if hasattr(server_context, "check_hostname"):
+ if hasattr(server_context, 'check_hostname'):
client_context.check_hostname = False
client_context.verify_mode = ssl.CERT_NONE
Test_UV_TCP.test_connect_accepted_socket(
- self, server_context, client_context
- )
+ self, server_context, client_context)
def test_start_tls_client_corrupted_ssl(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
self.loop.set_exception_handler(lambda loop, ctx: None)
@@ -1894,10 +1836,12 @@ def test_start_tls_client_corrupted_ssl(self):
def server(sock):
orig_sock = sock.dup()
try:
- sock.starttls(sslctx, server_side=True)
- sock.sendall(b"A\n")
+ sock.starttls(
+ sslctx,
+ server_side=True)
+ sock.sendall(b'A\n')
sock.recv_all(1)
- orig_sock.send(b"please corrupt the SSL connection")
+ orig_sock.send(b'please corrupt the SSL connection')
except ssl.SSLError:
pass
finally:
@@ -1906,11 +1850,12 @@ def server(sock):
async def client(addr):
reader, writer = await asyncio.open_connection(
- *addr, ssl=client_sslctx, server_hostname=""
- )
+ *addr,
+ ssl=client_sslctx,
+ server_hostname='')
- self.assertEqual(await reader.readline(), b"A\n")
- writer.write(b"B")
+ self.assertEqual(await reader.readline(), b'A\n')
+ writer.write(b'B')
with self.assertRaises(ssl.SSLError):
await reader.readline()
writer.close()
@@ -1918,22 +1863,24 @@ async def client(addr):
await self.wait_closed(writer)
except ssl.SSLError:
pass
- return "OK"
+ return 'OK'
+
+ with self.tcp_server(server,
+ max_clients=1,
+ backlog=1) as srv:
- with self.tcp_server(server, max_clients=1, backlog=1) as srv:
res = self.loop.run_until_complete(client(srv.addr))
- self.assertEqual(res, "OK")
+ self.assertEqual(res, 'OK')
def test_start_tls_client_reg_proto_1(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
- HELLO_MSG = b"1" * self.PAYLOAD_SIZE
+ HELLO_MSG = b'1' * self.PAYLOAD_SIZE
server_context = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
+ self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
def serve(sock):
@@ -1944,7 +1891,7 @@ def serve(sock):
sock.starttls(server_context, server_side=True)
- sock.sendall(b"O")
+ sock.sendall(b'O')
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
@@ -1975,13 +1922,12 @@ async def client(addr):
on_eof = self.loop.create_future()
tr, proto = await self.loop.create_connection(
- lambda: ClientProto(on_data, on_eof), *addr
- )
+ lambda: ClientProto(on_data, on_eof), *addr)
tr.write(HELLO_MSG)
new_tr = await self.loop.start_tls(tr, proto, client_context)
- self.assertEqual(await on_data, b"O")
+ self.assertEqual(await on_data, b'O')
new_tr.write(HELLO_MSG)
await on_eof
@@ -1989,18 +1935,16 @@ async def client(addr):
with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
self.loop.run_until_complete(
- asyncio.wait_for(client(srv.addr), timeout=10)
- )
+ asyncio.wait_for(client(srv.addr), timeout=10))
def test_create_connection_memory_leak(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
- HELLO_MSG = b"1" * self.PAYLOAD_SIZE
+ HELLO_MSG = b'1' * self.PAYLOAD_SIZE
server_context = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
+ self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
def serve(sock):
@@ -2008,7 +1952,7 @@ def serve(sock):
sock.starttls(server_context, server_side=True)
- sock.sendall(b"O")
+ sock.sendall(b'O')
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
@@ -2041,10 +1985,10 @@ async def client(addr):
on_eof = self.loop.create_future()
tr, proto = await self.loop.create_connection(
- lambda: ClientProto(on_data, on_eof), *addr, ssl=client_context
- )
+ lambda: ClientProto(on_data, on_eof), *addr,
+ ssl=client_context)
- self.assertEqual(await on_data, b"O")
+ self.assertEqual(await on_data, b'O')
tr.write(HELLO_MSG)
await on_eof
@@ -2052,8 +1996,7 @@ async def client(addr):
with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
self.loop.run_until_complete(
- asyncio.wait_for(client(srv.addr), timeout=10)
- )
+ asyncio.wait_for(client(srv.addr), timeout=10))
# No garbage is left for SSL client from loop.create_connection, even
# if user stores the SSLTransport in corresponding protocol instance
@@ -2061,14 +2004,13 @@ async def client(addr):
self.assertIsNone(client_context())
def test_start_tls_client_buf_proto_1(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
- HELLO_MSG = b"1" * self.PAYLOAD_SIZE
+ HELLO_MSG = b'1' * self.PAYLOAD_SIZE
server_context = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
+ self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
client_con_made_calls = 0
@@ -2081,11 +2023,11 @@ def serve(sock):
sock.starttls(server_context, server_side=True)
- sock.sendall(b"O")
+ sock.sendall(b'O')
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
- sock.sendall(b"2")
+ sock.sendall(b'2')
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
@@ -2135,17 +2077,16 @@ async def client(addr):
on_eof = self.loop.create_future()
tr, proto = await self.loop.create_connection(
- lambda: ClientProtoFirst(on_data1), *addr
- )
+ lambda: ClientProtoFirst(on_data1), *addr)
tr.write(HELLO_MSG)
new_tr = await self.loop.start_tls(tr, proto, client_context)
- self.assertEqual(await on_data1, b"O")
+ self.assertEqual(await on_data1, b'O')
new_tr.write(HELLO_MSG)
new_tr.set_protocol(ClientProtoSecond(on_data2, on_eof))
- self.assertEqual(await on_data2, b"2")
+ self.assertEqual(await on_data2, b'2')
new_tr.write(HELLO_MSG)
await on_eof
@@ -2158,14 +2099,14 @@ async def client(addr):
with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
self.loop.run_until_complete(
- asyncio.wait_for(client(srv.addr), timeout=self.TIMEOUT)
- )
+ asyncio.wait_for(client(srv.addr),
+ timeout=self.TIMEOUT))
def test_start_tls_slow_client_cancel(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
- HELLO_MSG = b"1" * self.PAYLOAD_SIZE
+ HELLO_MSG = b'1' * self.PAYLOAD_SIZE
client_context = self._create_client_ssl_context()
server_waits_on_handshake = self.loop.create_future()
@@ -2178,8 +2119,7 @@ def serve(sock):
try:
self.loop.call_soon_threadsafe(
- server_waits_on_handshake.set_result, None
- )
+ server_waits_on_handshake.set_result, None)
data = sock.recv_all(1024 * 1024)
except ConnectionAbortedError:
pass
@@ -2210,8 +2150,7 @@ async def client(addr):
on_eof = self.loop.create_future()
tr, proto = await self.loop.create_connection(
- lambda: ClientProto(on_data, on_eof), *addr
- )
+ lambda: ClientProto(on_data, on_eof), *addr)
tr.write(HELLO_MSG)
@@ -2219,23 +2158,21 @@ async def client(addr):
with self.assertRaises(asyncio.TimeoutError):
await asyncio.wait_for(
- self.loop.start_tls(tr, proto, client_context), 0.5
- )
+ self.loop.start_tls(tr, proto, client_context),
+ 0.5)
with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
self.loop.run_until_complete(
- asyncio.wait_for(client(srv.addr), timeout=10)
- )
+ asyncio.wait_for(client(srv.addr), timeout=10))
def test_start_tls_server_1(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
- HELLO_MSG = b"1" * self.PAYLOAD_SIZE
+ HELLO_MSG = b'1' * self.PAYLOAD_SIZE
server_context = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
+ self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
def client(sock, addr):
@@ -2256,7 +2193,7 @@ def __init__(self, on_con, on_eof, on_con_lost):
self.on_con = on_con
self.on_eof = on_eof
self.on_con_lost = on_con_lost
- self.data = b""
+ self.data = b''
def connection_made(self, tr):
self.on_con.set_result(tr)
@@ -2277,15 +2214,12 @@ async def main(proto, on_con, on_eof, on_con_lost):
tr = await on_con
tr.write(HELLO_MSG)
- self.assertEqual(proto.data, b"")
+ self.assertEqual(proto.data, b'')
new_tr = await self.loop.start_tls(
- tr,
- proto,
- server_context,
+ tr, proto, server_context,
server_side=True,
- ssl_handshake_timeout=self.TIMEOUT,
- )
+ ssl_handshake_timeout=self.TIMEOUT)
await on_eof
await on_con_lost
@@ -2299,17 +2233,14 @@ async def run_main():
proto = ServerProto(on_con, on_eof, on_con_lost)
server = await self.loop.create_server(
- lambda: proto, "127.0.0.1", 0
- )
+ lambda: proto, '127.0.0.1', 0)
addr = server.sockets[0].getsockname()
- with self.tcp_client(
- lambda sock: client(sock, addr), timeout=self.TIMEOUT
- ):
+ with self.tcp_client(lambda sock: client(sock, addr),
+ timeout=self.TIMEOUT):
await asyncio.wait_for(
main(proto, on_con, on_eof, on_con_lost),
- timeout=self.TIMEOUT,
- )
+ timeout=self.TIMEOUT)
server.close()
await server.wait_closed()
@@ -2317,8 +2248,8 @@ async def run_main():
self.loop.run_until_complete(run_main())
def test_create_server_ssl_over_ssl(self):
- if self.implementation == "asyncio":
- raise unittest.SkipTest("asyncio does not support SSL over SSL")
+ if self.implementation == 'asyncio':
+ raise unittest.SkipTest('asyncio does not support SSL over SSL')
if hasattr(sys, "_is_gil_enabled") and sys._is_gil_enabled():
if sys.platform == "win32":
# TODO: possibly fix when figured out.
@@ -2326,12 +2257,12 @@ def test_create_server_ssl_over_ssl(self):
"currently decides to GC when in debug mode"
)
- CNT = 0 # number of clients that were successful
- TOTAL_CNT = 25 # total number of clients that test will create
- TIMEOUT = 60.0 # timeout for this test
+ CNT = 0 # number of clients that were successful
+ TOTAL_CNT = 25 # total number of clients that test will create
+ TIMEOUT = 60.0 # timeout for this test
- A_DATA = b"A" * 1024 * 1024
- B_DATA = b"B" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
+ B_DATA = b'B' * 1024 * 1024
sslctx_1 = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx_1 = self._create_client_ssl_context()
@@ -2345,11 +2276,11 @@ async def handle_client(reader, writer):
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
- writer.write(b"OK")
+ writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
- writer.writelines([b"SP", bytearray(b"A"), memoryview(b"M")])
+ writer.writelines([b'SP', bytearray(b'A'), memoryview(b'M')])
await writer.drain()
writer.close()
@@ -2360,11 +2291,8 @@ class ServerProtocol(asyncio.StreamReaderProtocol):
def connection_made(self, transport):
super_ = super()
transport.pause_reading()
- fut = self._loop.create_task(
- self._loop.start_tls(
- transport, self, sslctx_2, server_side=True
- )
- )
+ fut = self._loop.create_task(self._loop.start_tls(
+ transport, self, sslctx_2, server_side=True))
def cb(_):
try:
@@ -2373,7 +2301,6 @@ def cb(_):
super_.connection_lost(ex)
else:
super_.connection_made(tr)
-
fut.add_done_callback(cb)
def server_protocol_factory():
@@ -2412,16 +2339,16 @@ def do(func, *args):
do(sslobj.write, A_DATA)
data = do(sslobj.read, 2)
- self.assertEqual(data, b"OK")
+ self.assertEqual(data, b'OK')
do(sslobj.write, B_DATA)
- data = b""
+ data = b''
while True:
chunk = do(sslobj.read, 4)
if not chunk:
break
data += chunk
- self.assertEqual(data, b"SPAM")
+ self.assertEqual(data, b'SPAM')
do(sslobj.unwrap)
sock.close()
@@ -2443,12 +2370,10 @@ async def start_server():
srv = await self.loop.create_server(
server_protocol_factory,
- "127.0.0.1",
- 0,
+ '127.0.0.1', 0,
family=socket.AF_INET,
ssl=sslctx_1,
- **extras,
- )
+ **extras)
try:
srv_socks = srv.sockets
@@ -2475,21 +2400,14 @@ async def start_server():
client.stop()
def test_renegotiation(self):
- # if self.implementation == "asyncio":
- # raise unittest.SkipTest("asyncio does not support renegotiation")
-
- # # Winloop comment: TODO investigate if/how this can be made to work
- # if sys.platform == "win32":
- # raise unittest.SkipTest("for now skip renegotiation on Windows")
-
CNT = 0
TOTAL_CNT = 25
- A_DATA = b"A" * 1024 * 1024
- B_DATA = b"B" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
+ B_DATA = b'B' * 1024 * 1024
sslctx = openssl_ssl.Context(openssl_ssl.TLSv1_2_METHOD)
- if hasattr(openssl_ssl, "OP_NO_SSLV2"):
+ if hasattr(openssl_ssl, 'OP_NO_SSLV2'):
sslctx.set_options(openssl_ssl.OP_NO_SSLV2)
sslctx.use_privatekey_file(self.ONLYKEY)
sslctx.use_certificate_chain_file(self.ONLYCERT)
@@ -2500,7 +2418,7 @@ def server(sock):
conn = openssl_ssl.Connection(sslctx, sock)
conn.set_accept_state()
- data = b""
+ data = b''
while len(data) < len(A_DATA):
try:
chunk = conn.recv(len(A_DATA) - len(data))
@@ -2512,11 +2430,11 @@ def server(sock):
self.assertEqual(data, A_DATA)
conn.renegotiate()
if conn.renegotiate_pending():
- conn.send(b"OK")
+ conn.send(b'OK')
else:
- conn.send(b"ER")
+ conn.send(b'ER')
- data = b""
+ data = b''
while len(data) < len(B_DATA):
try:
chunk = conn.recv(len(B_DATA) - len(data))
@@ -2527,9 +2445,9 @@ def server(sock):
pass
self.assertEqual(data, B_DATA)
if conn.renegotiate_pending():
- conn.send(b"ERRO")
+ conn.send(b'ERRO')
else:
- conn.send(b"SPAM")
+ conn.send(b'SPAM')
conn.shutdown()
@@ -2537,14 +2455,16 @@ async def client(addr):
extras = dict(ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT)
reader, writer = await asyncio.open_connection(
- *addr, ssl=client_sslctx, server_hostname="", **extras
- )
+ *addr,
+ ssl=client_sslctx,
+ server_hostname='',
+ **extras)
writer.write(A_DATA)
- self.assertEqual(await reader.readexactly(2), b"OK")
+ self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
@@ -2556,14 +2476,15 @@ async def client_sock(addr):
sock = socket.socket()
sock.connect(addr)
reader, writer = await asyncio.open_connection(
- sock=sock, ssl=client_sslctx, server_hostname=""
- )
+ sock=sock,
+ ssl=client_sslctx,
+ server_hostname='')
writer.write(A_DATA)
- self.assertEqual(await reader.readexactly(2), b"OK")
+ self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
@@ -2576,14 +2497,15 @@ def run(coro):
nonlocal CNT
CNT = 0
- with self.tcp_server(
- server, max_clients=TOTAL_CNT, backlog=TOTAL_CNT
- ) as srv:
+ with self.tcp_server(server,
+ max_clients=TOTAL_CNT,
+ backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
- self.loop.run_until_complete(asyncio.gather(*tasks))
+ self.loop.run_until_complete(
+ asyncio.gather(*tasks))
self.assertEqual(CNT, TOTAL_CNT)
@@ -2593,13 +2515,12 @@ def run(coro):
with self._silence_eof_received_warning():
run(client_sock)
- @unittest.skip("AssertionError: 0 != 25")
def test_shutdown_timeout(self):
- CNT = 0 # number of clients that were successful
- TOTAL_CNT = 25 # total number of clients that test will create
- TIMEOUT = 10.0 # timeout for this test
+ CNT = 0 # number of clients that were successful
+ TOTAL_CNT = 25 # total number of clients that test will create
+ TIMEOUT = 10.0 # timeout for this test
- A_DATA = b"A" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
@@ -2611,12 +2532,11 @@ async def handle_client(reader, writer):
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
- writer.write(b"OK")
+ writer.write(b'OK')
await writer.drain()
writer.close()
- with self.assertRaisesRegex(
- asyncio.TimeoutError, "SSL shutdown timed out"
- ):
+ with self.assertRaisesRegex(asyncio.TimeoutError,
+ 'SSL shutdown timed out'):
await reader.read()
CNT += 1
@@ -2630,10 +2550,10 @@ def prog(sock):
sock.send(A_DATA)
data = sock.recv_all(2)
- self.assertEqual(data, b"OK")
+ self.assertEqual(data, b'OK')
data = sock.recv(1024)
- self.assertEqual(data, b"")
+ self.assertEqual(data, b'')
fd = sock.detach()
try:
@@ -2657,18 +2577,16 @@ def prog(sock):
await fut
async def start_server():
- extras = {"ssl_handshake_timeout": SSL_HANDSHAKE_TIMEOUT}
- if self.implementation != "asyncio": # or self.PY38
- extras["ssl_shutdown_timeout"] = 0.5
+ extras = {'ssl_handshake_timeout': SSL_HANDSHAKE_TIMEOUT}
+ if self.implementation != 'asyncio': # or self.PY38
+ extras['ssl_shutdown_timeout'] = 0.5
srv = await asyncio.start_server(
handle_client,
- "127.0.0.1",
- 0,
+ '127.0.0.1', 0,
family=socket.AF_INET,
ssl=sslctx,
- **extras,
- )
+ **extras)
try:
srv_socks = srv.sockets
@@ -2680,7 +2598,9 @@ async def start_server():
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
- await asyncio.wait_for(asyncio.gather(*tasks), TIMEOUT)
+ await asyncio.wait_for(
+ asyncio.gather(*tasks),
+ TIMEOUT)
finally:
self.loop.call_soon(srv.close)
@@ -2695,23 +2615,25 @@ async def start_server():
client.stop()
def test_shutdown_cleanly(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
CNT = 0
TOTAL_CNT = 25
- A_DATA = b"A" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
def server(sock):
- sock.starttls(sslctx, server_side=True)
+ sock.starttls(
+ sslctx,
+ server_side=True)
data = sock.recv_all(len(A_DATA))
self.assertEqual(data, A_DATA)
- sock.send(b"OK")
+ sock.send(b'OK')
sock.unwrap()
@@ -2721,13 +2643,15 @@ async def client(addr):
extras = dict(ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT)
reader, writer = await asyncio.open_connection(
- *addr, ssl=client_sslctx, server_hostname="", **extras
- )
+ *addr,
+ ssl=client_sslctx,
+ server_hostname='',
+ **extras)
writer.write(A_DATA)
- self.assertEqual(await reader.readexactly(2), b"OK")
+ self.assertEqual(await reader.readexactly(2), b'OK')
- self.assertEqual(await reader.read(), b"")
+ self.assertEqual(await reader.read(), b'')
nonlocal CNT
CNT += 1
@@ -2739,14 +2663,15 @@ def run(coro):
nonlocal CNT
CNT = 0
- with self.tcp_server(
- server, max_clients=TOTAL_CNT, backlog=TOTAL_CNT
- ) as srv:
+ with self.tcp_server(server,
+ max_clients=TOTAL_CNT,
+ backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
- self.loop.run_until_complete(asyncio.gather(*tasks))
+ self.loop.run_until_complete(
+ asyncio.gather(*tasks))
self.assertEqual(CNT, TOTAL_CNT)
@@ -2754,7 +2679,7 @@ def run(coro):
run(client)
def test_write_to_closed_transport(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
@@ -2776,10 +2701,10 @@ def unwrap_server(sock):
# Since OpenSSL 1.1.1, it raises "application data after
# close notify"
# Python < 3.8:
- if ex.reason == "KRB5_S_INIT":
+ if ex.reason == 'KRB5_S_INIT':
break
# Python >= 3.8:
- if ex.reason == "APPLICATION_DATA_AFTER_CLOSE_NOTIFY":
+ if ex.reason == 'APPLICATION_DATA_AFTER_CLOSE_NOTIFY':
break
raise ex
except OSError as ex:
@@ -2793,20 +2718,22 @@ async def client(addr):
future = self.loop.create_future()
reader, writer = await asyncio.open_connection(
- *addr, ssl=client_sslctx, server_hostname=""
- )
- writer.write(b"I AM WRITING NOWHERE1" * 100)
+ *addr,
+ ssl=client_sslctx,
+ server_hostname='')
+ writer.write(b'I AM WRITING NOWHERE1' * 100)
try:
data = await reader.read()
- self.assertEqual(data, b"")
+ self.assertEqual(data, b'')
except (ConnectionResetError, BrokenPipeError):
pass
for i in range(25):
- writer.write(b"I AM WRITING NOWHERE2" * 100)
+ writer.write(b'I AM WRITING NOWHERE2' * 100)
- self.assertEqual(writer.transport.get_write_buffer_size(), 0)
+ self.assertEqual(
+ writer.transport.get_write_buffer_size(), 0)
await future
@@ -2821,7 +2748,6 @@ def wrapper(sock):
self.loop.call_soon_threadsafe(future.set_exception, ex)
else:
self.loop.call_soon_threadsafe(future.set_result, None)
-
return wrapper
with self._silence_eof_received_warning():
@@ -2831,9 +2757,8 @@ def wrapper(sock):
with self.tcp_server(run(unwrap_server)) as srv:
self.loop.run_until_complete(client(srv.addr))
- @unittest.skipIf(SKIP_OPENSSL, "We don't have openssl :(")
def test_flush_before_shutdown(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
CHUNK = 1024 * 128
@@ -2841,7 +2766,7 @@ def test_flush_before_shutdown(self):
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
sslctx_openssl = openssl_ssl.Context(openssl_ssl.TLSv1_2_METHOD)
- if hasattr(openssl_ssl, "OP_NO_SSLV2"):
+ if hasattr(openssl_ssl, 'OP_NO_SSLV2'):
sslctx_openssl.set_options(openssl_ssl.OP_NO_SSLV2)
sslctx_openssl.use_privatekey_file(self.ONLYKEY)
sslctx_openssl.use_certificate_chain_file(self.ONLYCERT)
@@ -2852,8 +2777,8 @@ def test_flush_before_shutdown(self):
def server(sock):
sock.starttls(sslctx, server_side=True)
- self.assertEqual(sock.recv_all(4), b"ping")
- sock.send(b"pong")
+ self.assertEqual(sock.recv_all(4), b'ping')
+ sock.send(b'pong')
time.sleep(0.5) # hopefully stuck the TCP buffer
data = sock.recv_all(CHUNK * SIZE)
self.assertEqual(len(data), CHUNK * SIZE)
@@ -2867,23 +2792,23 @@ def wrapper(sock):
self.loop.call_soon_threadsafe(future.set_exception, ex)
else:
self.loop.call_soon_threadsafe(future.set_result, None)
-
return wrapper
async def client(addr):
nonlocal future
future = self.loop.create_future()
reader, writer = await asyncio.open_connection(
- *addr, ssl=client_sslctx, server_hostname=""
- )
- sslprotocol = writer.get_extra_info("uvloop.sslproto")
- writer.write(b"ping")
+ *addr,
+ ssl=client_sslctx,
+ server_hostname='')
+ sslprotocol = writer.get_extra_info('uvloop.sslproto')
+ writer.write(b'ping')
data = await reader.readexactly(4)
- self.assertEqual(data, b"pong")
+ self.assertEqual(data, b'pong')
sslprotocol.pause_writing()
for _ in range(SIZE):
- writer.write(b"x" * CHUNK)
+ writer.write(b'x' * CHUNK)
writer.close()
sslprotocol.resume_writing()
@@ -2891,7 +2816,7 @@ async def client(addr):
await self.wait_closed(writer)
try:
data = await reader.read()
- self.assertEqual(data, b"")
+ self.assertEqual(data, b'')
except ConnectionResetError:
pass
await future
@@ -2900,7 +2825,7 @@ async def client(addr):
self.loop.run_until_complete(client(srv.addr))
def test_remote_shutdown_receives_trailing_data(self):
- if sys.platform == "linux" and sys.version_info < (3, 11):
+ if sys.platform == 'linux' and sys.version_info < (3, 11):
# TODO: started hanging and needs to be diagnosed.
raise unittest.SkipTest()
@@ -2939,8 +2864,8 @@ def server(sock):
else:
break
- self.assertEqual(data, b"ping")
- sslobj.write(b"pong")
+ self.assertEqual(data, b'ping')
+ sslobj.write(b'pong')
sock.send(outgoing.read())
data_len = 0
@@ -2976,7 +2901,7 @@ def server(sock):
self.assertEqual(data_len, CHUNK * count)
- if self.implementation == "uvloop":
+ if self.implementation == 'uvloop':
# Verify that close_notify is received. asyncio is currently
# not guaranteed to send close_notify before dropping off
sslobj.unwrap()
@@ -2990,31 +2915,30 @@ async def client(addr):
with eof_received:
with filled:
reader, writer = await asyncio.open_connection(
- *addr, ssl=client_sslctx, server_hostname=""
- )
- writer.write(b"ping")
+ *addr,
+ ssl=client_sslctx,
+ server_hostname='')
+ writer.write(b'ping')
data = await reader.readexactly(4)
- self.assertEqual(data, b"pong")
+ self.assertEqual(data, b'pong')
count = 0
try:
while True:
- writer.write(b"x" * CHUNK)
+ writer.write(b'x' * CHUNK)
count += 1
await asyncio.wait_for(
- asyncio.ensure_future(writer.drain()), 0.5
- )
+ asyncio.ensure_future(writer.drain()), 0.5)
except asyncio.TimeoutError:
# fill write backlog in a hacky way for uvloop
- if self.implementation == "uvloop":
+ if self.implementation == 'uvloop':
for _ in range(SIZE):
writer.transport._test__append_write_backlog(
- b"x" * CHUNK
- )
+ b'x' * CHUNK)
count += 1
data = await reader.read()
- self.assertEqual(data, b"")
+ self.assertEqual(data, b'')
await future
@@ -3029,7 +2953,6 @@ def wrapper(sock):
self.loop.call_soon_threadsafe(future.set_exception, ex)
else:
self.loop.call_soon_threadsafe(future.set_result, None)
-
return wrapper
with self.tcp_server(run(server)) as srv:
@@ -3037,21 +2960,19 @@ def wrapper(sock):
def test_connect_timeout_warning(self):
s = socket.socket(socket.AF_INET)
- s.bind(("127.0.0.1", 0))
+ s.bind(('127.0.0.1', 0))
addr = s.getsockname()
async def test():
try:
await asyncio.wait_for(
- self.loop.create_connection(
- asyncio.Protocol, *addr, ssl=True
- ),
- 0.1,
- )
+ self.loop.create_connection(asyncio.Protocol,
+ *addr, ssl=True),
+ 0.1)
except (ConnectionRefusedError, asyncio.TimeoutError):
pass
else:
- self.fail("TimeoutError is not raised")
+ self.fail('TimeoutError is not raised')
with s:
try:
@@ -3061,32 +2982,30 @@ async def test():
gc.collect()
gc.collect()
except AssertionError as e:
- self.assertEqual(str(e), "ResourceWarning not triggered")
+ self.assertEqual(str(e), 'ResourceWarning not triggered')
else:
- self.fail("Unexpected ResourceWarning: {}".format(cm.warning))
+ self.fail('Unexpected ResourceWarning: {}'.format(cm.warning))
def test_handshake_timeout_handler_leak(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
# Okay this turns out to be an issue for asyncio.sslproto too
raise unittest.SkipTest()
s = socket.socket(socket.AF_INET)
- s.bind(("127.0.0.1", 0))
+ s.bind(('127.0.0.1', 0))
s.listen(1)
addr = s.getsockname()
async def test(ctx):
try:
await asyncio.wait_for(
- self.loop.create_connection(
- asyncio.Protocol, *addr, ssl=ctx
- ),
- 0.1,
- )
+ self.loop.create_connection(asyncio.Protocol, *addr,
+ ssl=ctx),
+ 0.1)
except (ConnectionRefusedError, asyncio.TimeoutError):
pass
else:
- self.fail("TimeoutError is not raised")
+ self.fail('TimeoutError is not raised')
with s:
ctx = ssl.create_default_context()
@@ -3100,9 +3019,8 @@ def test_shutdown_timeout_handler_leak(self):
loop = self.loop
def server(sock):
- sslctx = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
+ sslctx = self._create_server_ssl_context(self.ONLYCERT,
+ self.ONLYKEY)
sock = sslctx.wrap_socket(sock, server_side=True)
sock.recv(32)
sock.close()
@@ -3124,7 +3042,7 @@ async def client(addr, ctx):
loop.run_until_complete(client(srv.addr, ctx))
ctx = weakref.ref(ctx)
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
# asyncio has no shutdown timeout, but it ends up with a circular
# reference loop - not ideal (introduces gc glitches), but at least
# not leaking
@@ -3136,7 +3054,7 @@ async def client(addr, ctx):
self.assertIsNone(ctx())
def test_shutdown_timeout_handler_not_set(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
# asyncio doesn't call SSL eof_received() so we can't run this test
raise unittest.SkipTest()
@@ -3144,17 +3062,16 @@ def test_shutdown_timeout_handler_not_set(self):
extra = None
def server(sock):
- sslctx = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
+ sslctx = self._create_server_ssl_context(self.ONLYCERT,
+ self.ONLYKEY)
sock = sslctx.wrap_socket(sock, server_side=True)
- sock.send(b"hello")
- assert sock.recv(1024) == b"world"
- sock.send(b"extra bytes")
+ sock.send(b'hello')
+ assert sock.recv(1024) == b'world'
+ sock.send(b'extra bytes')
# sending EOF here
sock.shutdown(socket.SHUT_WR)
# make sure we have enough time to reproduce the issue
- self.assertEqual(sock.recv(1024), b"")
+ self.assertEqual(sock.recv(1024), b'')
sock.close()
class Protocol(asyncio.Protocol):
@@ -3166,8 +3083,8 @@ def connection_made(self, transport):
self.transport = transport
def data_received(self, data):
- if data == b"hello":
- self.transport.write(b"world")
+ if data == b'hello':
+ self.transport.write(b'world')
# pause reading would make incoming data stay in the sslobj
self.transport.pause_reading()
else:
@@ -3195,7 +3112,7 @@ async def client(addr):
loop.run_until_complete(client(srv.addr))
def test_shutdown_while_pause_reading(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
loop = self.loop
@@ -3205,9 +3122,8 @@ def test_shutdown_while_pause_reading(self):
data_recv = False
def server(sock):
- sslctx = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
+ sslctx = self._create_server_ssl_context(self.ONLYCERT,
+ self.ONLYKEY)
incoming = ssl.MemoryBIO()
outgoing = ssl.MemoryBIO()
sslobj = sslctx.wrap_bio(incoming, outgoing, server_side=True)
@@ -3215,7 +3131,7 @@ def server(sock):
while True:
try:
sslobj.do_handshake()
- sslobj.write(b"trailing data")
+ sslobj.write(b'trailing data')
break
except ssl.SSLWantReadError:
if outgoing.pending:
@@ -3226,7 +3142,7 @@ def server(sock):
while True:
try:
- self.assertEqual(sslobj.read(), b"") # close_notify
+ self.assertEqual(sslobj.read(), b'') # close_notify
break
except ssl.SSLWantReadError:
incoming.write(sock.recv(16384))
@@ -3243,7 +3159,7 @@ def server(sock):
sock.send(outgoing.read())
break
- self.assertEqual(sock.recv(16384), b"") # socket closed
+ self.assertEqual(sock.recv(16384), b'') # socket closed
class Protocol(asyncio.Protocol):
def connection_made(self, transport):
@@ -3308,12 +3224,12 @@ def server(sock):
else:
break
- self.assertEqual(data, b"ping")
- sslobj.write(b"pong")
+ self.assertEqual(data, b'ping')
+ sslobj.write(b'pong')
sock.send(outgoing.read())
with close_notify:
- sslobj.write(b"trailing")
+ sslobj.write(b'trailing')
sock.send(outgoing.read())
time.sleep(0.5) # allow time for the client to receive
@@ -3328,22 +3244,21 @@ async def client(addr):
with close_notify:
reader, writer = await asyncio.open_connection(
- *addr, ssl=client_sslctx, server_hostname=""
- )
- writer.write(b"ping")
+ *addr,
+ ssl=client_sslctx,
+ server_hostname='')
+ writer.write(b'ping')
data = await reader.readexactly(4)
- self.assertEqual(data, b"pong")
+ self.assertEqual(data, b'pong')
writer.close()
try:
await self.wait_closed(writer)
except ssl.SSLError as e:
- if (
- self.implementation == "asyncio"
- and "application data after close notify" in str(e)
- ):
- raise unittest.SkipTest("bpo-39951")
+ if self.implementation == 'asyncio' and \
+ 'application data after close notify' in str(e):
+ raise unittest.SkipTest('bpo-39951')
raise
await future
@@ -3355,19 +3270,17 @@ def wrapper(sock):
self.loop.call_soon_threadsafe(future.set_exception, ex)
else:
self.loop.call_soon_threadsafe(future.set_result, None)
-
return wrapper
with self.tcp_server(run(server)) as srv:
self.loop.run_until_complete(client(srv.addr))
def test_first_data_after_wakeup(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
raise unittest.SkipTest()
server_context = self._create_server_ssl_context(
- self.ONLYCERT, self.ONLYKEY
- )
+ self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
loop = self.loop
this = self
@@ -3392,13 +3305,13 @@ def client(sock, addr):
incoming.write(sock.recv(65536))
# Send the first data together with the last handshake payload
- sslobj.write(b"hello")
+ sslobj.write(b'hello')
sock.send(outgoing.read())
while True:
try:
incoming.write(sock.recv(65536))
- self.assertEqual(sslobj.read(1024), b"hello")
+ self.assertEqual(sslobj.read(1024), b'hello')
break
except ssl.SSLWantReadError:
pass
@@ -3416,9 +3329,7 @@ def connection_made(self, tr):
self.tr = tr
# manually run the coroutine, in order to avoid accidental data
coro = loop.start_tls(
- tr,
- self,
- server_context,
+ tr, self, server_context,
server_side=True,
ssl_handshake_timeout=this.TIMEOUT,
)
@@ -3442,13 +3353,11 @@ async def run_main():
proto = EchoProto()
server = await self.loop.create_server(
- lambda: proto, "127.0.0.1", 0
- )
+ lambda: proto, '127.0.0.1', 0)
addr = server.sockets[0].getsockname()
- with self.tcp_client(
- lambda sock: client(sock, addr), timeout=self.TIMEOUT
- ):
+ with self.tcp_client(lambda sock: client(sock, addr),
+ timeout=self.TIMEOUT):
await asyncio.wait_for(fut, timeout=self.TIMEOUT)
proto.tr.close()
diff --git a/tests/test_testbase.py b/tests/test_testbase.py
index 0a8ea9f16..28fd17369 100644
--- a/tests/test_testbase.py
+++ b/tests/test_testbase.py
@@ -6,7 +6,7 @@
class TestBaseTest(unittest.TestCase):
def test_duplicate_methods(self):
- with self.assertRaisesRegex(RuntimeError, "duplicate test Foo.test_a"):
+ with self.assertRaisesRegex(RuntimeError, 'duplicate test Foo.test_a'):
class Foo(tb.BaseTestCase):
def test_a(self):
@@ -23,9 +23,9 @@ class FooBase:
def test_a(self):
pass
- with self.assertRaisesRegex(
- RuntimeError, "duplicate test Foo.test_a.*" "defined in FooBase"
- ):
+ with self.assertRaisesRegex(RuntimeError,
+ 'duplicate test Foo.test_a.*'
+ 'defined in FooBase'):
class Foo(FooBase, tb.BaseTestCase):
def test_b(self):
@@ -39,9 +39,9 @@ class FooBase(tb.BaseTestCase):
def test_a(self):
pass
- with self.assertRaisesRegex(
- RuntimeError, "duplicate test Foo.test_a.*" "defined in FooBase"
- ):
+ with self.assertRaisesRegex(RuntimeError,
+ 'duplicate test Foo.test_a.*'
+ 'defined in FooBase'):
class Foo(FooBase):
def test_b(self):
diff --git a/tests/test_udp.py b/tests/test_udp.py
index 29b84489f..cc8ac7a43 100644
--- a/tests/test_udp.py
+++ b/tests/test_udp.py
@@ -13,32 +13,33 @@ class MyDatagramProto(asyncio.DatagramProtocol):
done = None
def __init__(self, loop=None):
- self.state = "INITIAL"
+ self.state = 'INITIAL'
self.nbytes = 0
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
- assert self.state == "INITIAL", self.state
- self.state = "INITIALIZED"
+ assert self.state == 'INITIAL', self.state
+ self.state = 'INITIALIZED'
def datagram_received(self, data, addr):
- assert self.state == "INITIALIZED", self.state
+ assert self.state == 'INITIALIZED', self.state
self.nbytes += len(data)
def error_received(self, exc):
- assert self.state == "INITIALIZED", self.state
+ assert self.state == 'INITIALIZED', self.state
raise exc
def connection_lost(self, exc):
- assert self.state == "INITIALIZED", self.state
- self.state = "CLOSED"
+ assert self.state == 'INITIALIZED', self.state
+ self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class _TestUDP:
+
def _test_create_datagram_endpoint_addrs(self, family, lc_addr):
class TestMyDatagramProto(MyDatagramProto):
def __init__(inner_self):
@@ -46,38 +47,38 @@ def __init__(inner_self):
def datagram_received(self, data, addr):
super().datagram_received(data, addr)
- self.transport.sendto(b"resp:" + data, addr)
+ self.transport.sendto(b'resp:' + data, addr)
coro = self.loop.create_datagram_endpoint(
- TestMyDatagramProto, local_addr=lc_addr, family=family
- )
+ TestMyDatagramProto,
+ local_addr=lc_addr,
+ family=family)
s_transport, server = self.loop.run_until_complete(coro)
- remote_addr = s_transport.get_extra_info("sockname")
+ remote_addr = s_transport.get_extra_info('sockname')
host, port, *_ = remote_addr
self.assertIsInstance(server, TestMyDatagramProto)
- self.assertEqual("INITIALIZED", server.state)
+ self.assertEqual('INITIALIZED', server.state)
self.assertIs(server.transport, s_transport)
extra = {}
- if hasattr(socket, "SO_REUSEPORT"):
- extra["reuse_port"] = True
+ if hasattr(socket, 'SO_REUSEPORT'):
+ extra['reuse_port'] = True
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
family=family,
remote_addr=(host, port),
- **extra,
- )
+ **extra)
transport, client = self.loop.run_until_complete(coro)
self.assertIsInstance(client, MyDatagramProto)
- self.assertEqual("INITIALIZED", client.state)
+ self.assertEqual('INITIALIZED', client.state)
self.assertIs(client.transport, transport)
- transport.sendto(b"xxx")
+ transport.sendto(b'xxx')
tb.run_until(self.loop, lambda: server.nbytes)
self.assertEqual(3, server.nbytes)
tb.run_until(self.loop, lambda: client.nbytes)
@@ -87,10 +88,9 @@ def datagram_received(self, data, addr):
# https://github.com/MagicStack/uvloop/issues/319
# uvloop should behave the same as asyncio when given remote_addr
- transport.sendto(b"xxx", remote_addr)
+ transport.sendto(b'xxx', remote_addr)
tb.run_until(
- self.loop, lambda: server.nbytes > 3 or client.done.done()
- )
+ self.loop, lambda: server.nbytes > 3 or client.done.done())
self.assertEqual(6, server.nbytes)
tb.run_until(self.loop, lambda: client.nbytes > 8)
@@ -117,27 +117,26 @@ def datagram_received(self, data, addr):
transport.sendto(b"xxx", bad_addr)
# extra info is available
- self.assertIsNotNone(transport.get_extra_info("sockname"))
+ self.assertIsNotNone(transport.get_extra_info('sockname'))
# close connection
transport.close()
self.loop.run_until_complete(client.done)
- self.assertEqual("CLOSED", client.state)
+ self.assertEqual('CLOSED', client.state)
server.transport.close()
self.loop.run_until_complete(server.done)
def test_create_datagram_endpoint_addrs_ipv4(self):
self._test_create_datagram_endpoint_addrs(
- socket.AF_INET, ("127.0.0.1", 0)
- )
+ socket.AF_INET, ('127.0.0.1', 0))
def test_create_datagram_endpoint_addrs_ipv4_nameaddr(self):
self._test_create_datagram_endpoint_addrs(
- socket.AF_INET, ("localhost", 0)
- )
+ socket.AF_INET, ('localhost', 0))
def _test_create_datagram_endpoint_addrs_ipv6(self):
- self._test_create_datagram_endpoint_addrs(socket.AF_INET6, ("::1", 0))
+ self._test_create_datagram_endpoint_addrs(
+ socket.AF_INET6, ('::1', 0))
def test_create_datagram_endpoint_ipv6_family(self):
class TestMyDatagramProto(MyDatagramProto):
@@ -146,11 +145,10 @@ def __init__(inner_self):
def datagram_received(self, data, addr):
super().datagram_received(data, addr)
- self.transport.sendto(b"resp:" + data, addr)
+ self.transport.sendto(b'resp:' + data, addr)
coro = self.loop.create_datagram_endpoint(
- TestMyDatagramProto, local_addr=None, family=socket.AF_INET6
- )
+ TestMyDatagramProto, local_addr=None, family=socket.AF_INET6)
s_transport = None
try:
s_transport, server = self.loop.run_until_complete(coro)
@@ -158,14 +156,15 @@ def datagram_received(self, data, addr):
if s_transport:
s_transport.close()
# let it close
- self.loop.run_until_complete(asyncio.sleep(0.1))
+ self.loop.run_until_complete(
+ asyncio.sleep(0.1))
def test_create_datagram_endpoint_sock(self):
sock = None
- local_address = ("127.0.0.1", 0)
+ local_address = ('127.0.0.1', 0)
infos = self.loop.run_until_complete(
- self.loop.getaddrinfo(*local_address, type=socket.SOCK_DGRAM)
- )
+ self.loop.getaddrinfo(
+ *local_address, type=socket.SOCK_DGRAM))
for family, type, proto, cname, address in infos:
try:
sock = socket.socket(family=family, type=type, proto=proto)
@@ -176,12 +175,11 @@ def test_create_datagram_endpoint_sock(self):
else:
break
else:
- assert False, "Can not create socket."
+ assert False, 'Can not create socket.'
with sock:
f = self.loop.create_datagram_endpoint(
- lambda: MyDatagramProto(loop=self.loop), sock=sock
- )
+ lambda: MyDatagramProto(loop=self.loop), sock=sock)
tr, pr = self.loop.run_until_complete(f)
self.assertIsInstance(pr, MyDatagramProto)
tr.close()
@@ -189,35 +187,36 @@ def test_create_datagram_endpoint_sock(self):
@unittest.skipIf(sys.platform == "win32", "no Unix sockets on Windows")
def test_create_datagram_endpoint_sock_unix_domain(self):
+
class Proto(asyncio.DatagramProtocol):
done = None
def __init__(self, loop):
- self.state = "INITIAL"
+ self.state = 'INITIAL'
self.addrs = set()
self.done = asyncio.Future(loop=loop)
- self.data = b""
+ self.data = b''
def connection_made(self, transport):
self.transport = transport
- assert self.state == "INITIAL", self.state
- self.state = "INITIALIZED"
+ assert self.state == 'INITIAL', self.state
+ self.state = 'INITIALIZED'
def datagram_received(self, data, addr):
- assert self.state == "INITIALIZED", self.state
+ assert self.state == 'INITIALIZED', self.state
self.addrs.add(addr)
self.data += data
- if self.data == b"STOP" and not self.done.done():
+ if self.data == b'STOP' and not self.done.done():
self.done.set_result(True)
def error_received(self, exc):
- assert self.state == "INITIALIZED", self.state
+ assert self.state == 'INITIALIZED', self.state
if not self.done.done():
self.done.set_exception(exc or RuntimeError())
def connection_lost(self, exc):
- assert self.state == "INITIALIZED", self.state
- self.state = "CLOSED"
+ assert self.state == 'INITIALIZED', self.state
+ self.state = 'CLOSED'
if self.done and not self.done.done():
self.done.set_result(None)
@@ -227,7 +226,8 @@ def connection_lost(self, exc):
with sock:
pr = Proto(loop=self.loop)
- f = self.loop.create_datagram_endpoint(lambda: pr, sock=sock)
+ f = self.loop.create_datagram_endpoint(
+ lambda: pr, sock=sock)
tr, pr_prime = self.loop.run_until_complete(f)
self.assertIs(pr, pr_prime)
@@ -237,11 +237,10 @@ def connection_lost(self, exc):
with sock2:
f2 = self.loop.create_datagram_endpoint(
- asyncio.DatagramProtocol, sock=sock2
- )
+ asyncio.DatagramProtocol, sock=sock2)
tr2, pr2 = self.loop.run_until_complete(f2)
- tr2.sendto(b"STOP", tmp_file)
+ tr2.sendto(b'STOP', tmp_file)
self.loop.run_until_complete(pr.done)
@@ -254,24 +253,20 @@ def connection_lost(self, exc):
self.assertIn(tmp_file2, pr.addrs)
def test_create_datagram_1(self):
- server_addr = ("127.0.0.1", 8888)
- client_addr = ("127.0.0.1", 0)
+ server_addr = ('127.0.0.1', 8888)
+ client_addr = ('127.0.0.1', 0)
async def run():
- (
- server_transport,
- client_protocol,
- ) = await self.loop.create_datagram_endpoint(
- asyncio.DatagramProtocol, local_addr=server_addr
- )
+ server_transport, client_protocol = \
+ await self.loop.create_datagram_endpoint(
+ asyncio.DatagramProtocol,
+ local_addr=server_addr)
- client_transport, client_conn = (
+ client_transport, client_conn = \
await self.loop.create_datagram_endpoint(
asyncio.DatagramProtocol,
remote_addr=server_addr,
- local_addr=client_addr,
- )
- )
+ local_addr=client_addr)
client_transport.close()
server_transport.close()
@@ -299,18 +294,18 @@ def datagram_received(self, data, addr):
tr, pr = self.loop.run_until_complete(f)
self.assertIsInstance(pr, Proto)
- s2.send(b"hello, socketpair")
+ s2.send(b'hello, socketpair')
addr = self.loop.run_until_complete(asyncio.wait_for(peername, 1))
- if sys.platform.startswith("linux"):
+ if sys.platform.startswith('linux'):
self.assertEqual(addr, None)
else:
- self.assertEqual(addr, "")
+ self.assertEqual(addr, '')
self.assertEqual(pr.nbytes, 17)
if not self.is_asyncio_loop():
# asyncio doesn't support sendto(xx) on UDP sockets
# https://git.io/Jfqbw
- data = b"from uvloop"
+ data = b'from uvloop'
tr.sendto(data)
result = self.loop.run_until_complete(
asyncio.wait_for(
@@ -323,7 +318,7 @@ def datagram_received(self, data, addr):
self.loop.run_until_complete(pr.done)
def _skip_create_datagram_endpoint_reuse_addr(self):
- if self.implementation == "asyncio":
+ if self.implementation == 'asyncio':
if sys.version_info[:2] >= (3, 11):
raise unittest.SkipTest()
if (3, 8, 0) <= sys.version_info < (3, 8, 1):
@@ -337,9 +332,8 @@ def test_create_datagram_endpoint_reuse_address_error(self):
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
- local_addr=("127.0.0.1", 0),
- reuse_address=True,
- )
+ local_addr=('127.0.0.1', 0),
+ reuse_address=True)
with self.assertRaises(ValueError):
self.loop.run_until_complete(coro)
@@ -351,9 +345,8 @@ def test_create_datagram_endpoint_reuse_address_warning(self):
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
- local_addr=("127.0.0.1", 0),
- reuse_address=False,
- )
+ local_addr=('127.0.0.1', 0),
+ reuse_address=False)
with self.assertWarns(DeprecationWarning):
tr, pr = self.loop.run_until_complete(coro)
@@ -367,25 +360,23 @@ def test_create_datagram_endpoint_wrong_sock(self):
sock = socket.socket(socket.AF_INET)
with sock:
coro = self.loop.create_datagram_endpoint(lambda: None, sock=sock)
- with self.assertRaisesRegex(
- ValueError, "A UDP Socket was expected"
- ):
+ with self.assertRaisesRegex(ValueError,
+ 'A UDP Socket was expected'):
self.loop.run_until_complete(coro)
def test_udp_sendto_dns(self):
coro = self.loop.create_datagram_endpoint(
asyncio.DatagramProtocol,
- local_addr=("127.0.0.1", 0),
- family=socket.AF_INET,
- )
+ local_addr=('127.0.0.1', 0),
+ family=socket.AF_INET)
s_transport, server = self.loop.run_until_complete(coro)
- with self.assertRaisesRegex(ValueError, "DNS lookup"):
- s_transport.sendto(b"aaaa", ("example.com", 80))
+ with self.assertRaisesRegex(ValueError, 'DNS lookup'):
+ s_transport.sendto(b'aaaa', ('example.com', 80))
- with self.assertRaisesRegex(ValueError, "socket family mismatch"):
- s_transport.sendto(b"aaaa", ("::1", 80))
+ with self.assertRaisesRegex(ValueError, 'socket family mismatch'):
+ s_transport.sendto(b'aaaa', ('::1', 80))
s_transport.close()
self.loop.run_until_complete(asyncio.sleep(0.01))
@@ -393,24 +384,23 @@ def test_udp_sendto_dns(self):
def test_send_after_close(self):
coro = self.loop.create_datagram_endpoint(
asyncio.DatagramProtocol,
- local_addr=("127.0.0.1", 0),
- family=socket.AF_INET,
- )
+ local_addr=('127.0.0.1', 0),
+ family=socket.AF_INET)
s_transport, _ = self.loop.run_until_complete(coro)
s_transport.close()
- s_transport.sendto(b"aaaa", ("127.0.0.1", 80))
+ s_transport.sendto(b'aaaa', ('127.0.0.1', 80))
self.loop.run_until_complete(asyncio.sleep(0.01))
- s_transport.sendto(b"aaaa", ("127.0.0.1", 80))
+ s_transport.sendto(b'aaaa', ('127.0.0.1', 80))
- @unittest.skipUnless(tb.has_IPv6, "no IPv6")
+ @unittest.skipUnless(tb.has_IPv6, 'no IPv6')
def test_create_datagram_endpoint_addrs_ipv6(self):
self._test_create_datagram_endpoint_addrs_ipv6()
class Test_AIO_UDP(_TestUDP, tb.AIOTestCase):
- @unittest.skipUnless(tb.has_IPv6, "no IPv6")
+ @unittest.skipUnless(tb.has_IPv6, 'no IPv6')
def test_create_datagram_endpoint_addrs_ipv6(self):
self._test_create_datagram_endpoint_addrs_ipv6()
diff --git a/tests/test_unix.py b/tests/test_unix.py
index b3e9c537e..ff7960ccb 100644
--- a/tests/test_unix.py
+++ b/tests/test_unix.py
@@ -9,26 +9,27 @@
from uvloop import _testbase as tb
+
SSL_HANDSHAKE_TIMEOUT = 15.0
@unittest.skipIf(sys.platform == "win32", "no Unix socket tests on Windows")
class _TestUnix:
def test_create_unix_server_1(self):
- CNT = 0 # number of clients that were successful
- TOTAL_CNT = 100 # total number of clients that test will create
- TIMEOUT = 5.0 # timeout for this test
+ CNT = 0 # number of clients that were successful
+ TOTAL_CNT = 100 # total number of clients that test will create
+ TIMEOUT = 5.0 # timeout for this test
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(4)
- self.assertEqual(data, b"AAAA")
- writer.write(b"OK")
+ self.assertEqual(data, b'AAAA')
+ writer.write(b'OK')
data = await reader.readexactly(4)
- self.assertEqual(data, b"BBBB")
- writer.write(b"SPAM")
+ self.assertEqual(data, b'BBBB')
+ writer.write(b'SPAM')
await writer.drain()
writer.close()
@@ -42,27 +43,29 @@ async def test_client(addr):
sock.setblocking(False)
await self.loop.sock_connect(sock, addr)
- await self.loop.sock_sendall(sock, b"AAAA")
+ await self.loop.sock_sendall(sock, b'AAAA')
- buf = b""
+ buf = b''
while len(buf) != 2:
buf += await self.loop.sock_recv(sock, 1)
- self.assertEqual(buf, b"OK")
+ self.assertEqual(buf, b'OK')
- await self.loop.sock_sendall(sock, b"BBBB")
+ await self.loop.sock_sendall(sock, b'BBBB')
- buf = b""
+ buf = b''
while len(buf) != 4:
buf += await self.loop.sock_recv(sock, 1)
- self.assertEqual(buf, b"SPAM")
+ self.assertEqual(buf, b'SPAM')
async def start_server():
nonlocal CNT
CNT = 0
with tempfile.TemporaryDirectory() as td:
- sock_name = os.path.join(td, "sock")
- srv = await asyncio.start_unix_server(handle_client, sock_name)
+ sock_name = os.path.join(td, 'sock')
+ srv = await asyncio.start_unix_server(
+ handle_client,
+ sock_name)
try:
srv_socks = srv.sockets
@@ -79,12 +82,9 @@ async def start_server():
self.loop.call_soon(srv.close)
await srv.wait_closed()
- if self.implementation == "asyncio" and sys.version_info[
- :3
- ] >= (
- 3,
- 12,
- 0,
+ if (
+ self.implementation == 'asyncio'
+ and sys.version_info[:3] >= (3, 12, 0)
):
# asyncio regression in 3.12 -- wait_closed()
# doesn't wait for `close()` to actually complete.
@@ -113,7 +113,7 @@ async def start_server_sock(start_server, is_unix_api=True):
CNT = 0
with tempfile.TemporaryDirectory() as td:
- sock_name = os.path.join(td, "sock")
+ sock_name = os.path.join(td, 'sock')
sock = socket.socket(socket.AF_UNIX)
sock.bind(sock_name)
@@ -134,12 +134,9 @@ async def start_server_sock(start_server, is_unix_api=True):
self.loop.call_soon(srv.close)
await srv.wait_closed()
- if self.implementation == "asyncio" and sys.version_info[
- :3
- ] >= (
- 3,
- 12,
- 0,
+ if (
+ self.implementation == 'asyncio'
+ and sys.version_info[:3] >= (3, 12, 0)
):
# asyncio regression in 3.12 -- wait_closed()
# doesn't wait for `close()` to actually complete.
@@ -158,55 +155,46 @@ async def start_server_sock(start_server, is_unix_api=True):
else:
self.assertFalse(os.path.exists(sock_name))
- with self.subTest(func="start_unix_server(host, port)"):
+ with self.subTest(func='start_unix_server(host, port)'):
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
- with self.subTest(func="start_unix_server(sock)"):
- self.loop.run_until_complete(
- start_server_sock(
- lambda sock: asyncio.start_unix_server(
- handle_client, None, sock=sock
- )
- )
- )
+ with self.subTest(func='start_unix_server(sock)'):
+ self.loop.run_until_complete(start_server_sock(
+ lambda sock: asyncio.start_unix_server(
+ handle_client,
+ None,
+ sock=sock)))
self.assertEqual(CNT, TOTAL_CNT)
- with self.subTest(func="start_server(sock)"):
- self.loop.run_until_complete(
- start_server_sock(
- lambda sock: asyncio.start_server(
- handle_client, None, None, sock=sock
- ),
- is_unix_api=False,
- )
- )
+ with self.subTest(func='start_server(sock)'):
+ self.loop.run_until_complete(start_server_sock(
+ lambda sock: asyncio.start_server(
+ handle_client,
+ None, None,
+ sock=sock), is_unix_api=False))
self.assertEqual(CNT, TOTAL_CNT)
def test_create_unix_server_2(self):
with tempfile.TemporaryDirectory() as td:
- sock_name = os.path.join(td, "sock")
- with open(sock_name, "wt") as f:
- f.write("x")
+ sock_name = os.path.join(td, 'sock')
+ with open(sock_name, 'wt') as f:
+ f.write('x')
with self.assertRaisesRegex(
- OSError, "Address '{}' is already in use".format(sock_name)
- ):
+ OSError, "Address '{}' is already in use".format(
+ sock_name)):
+
self.loop.run_until_complete(
- self.loop.create_unix_server(object, sock_name)
- )
+ self.loop.create_unix_server(object, sock_name))
def test_create_unix_server_3(self):
with self.assertRaisesRegex(
- ValueError, "ssl_handshake_timeout is only meaningful"
- ):
+ ValueError, 'ssl_handshake_timeout is only meaningful'):
self.loop.run_until_complete(
self.loop.create_unix_server(
- lambda: None,
- path="/tmp/a",
- ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT,
- )
- )
+ lambda: None, path='/tmp/a',
+ ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT))
def test_create_unix_server_existing_path_sock(self):
with self.unix_sock_name() as path:
@@ -225,11 +213,11 @@ def test_create_unix_connection_open_unix_con_addr(self):
async def client(addr):
reader, writer = await asyncio.open_unix_connection(addr)
- writer.write(b"AAAA")
- self.assertEqual(await reader.readexactly(2), b"OK")
+ writer.write(b'AAAA')
+ self.assertEqual(await reader.readexactly(2), b'OK')
- writer.write(b"BBBB")
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ writer.write(b'BBBB')
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
writer.close()
await self.wait_closed(writer)
@@ -242,11 +230,11 @@ async def client(addr):
sock.connect(addr)
reader, writer = await asyncio.open_unix_connection(sock=sock)
- writer.write(b"AAAA")
- self.assertEqual(await reader.readexactly(2), b"OK")
+ writer.write(b'AAAA')
+ self.assertEqual(await reader.readexactly(2), b'OK')
- writer.write(b"BBBB")
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ writer.write(b'BBBB')
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
writer.close()
await self.wait_closed(writer)
@@ -259,11 +247,11 @@ async def client(addr):
sock.connect(addr)
reader, writer = await asyncio.open_connection(sock=sock)
- writer.write(b"AAAA")
- self.assertEqual(await reader.readexactly(2), b"OK")
+ writer.write(b'AAAA')
+ self.assertEqual(await reader.readexactly(2), b'OK')
- writer.write(b"BBBB")
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ writer.write(b'BBBB')
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
writer.close()
await self.wait_closed(writer)
@@ -276,12 +264,12 @@ def _test_create_unix_connection_1(self, client):
def server(sock):
data = sock.recv_all(4)
- self.assertEqual(data, b"AAAA")
- sock.send(b"OK")
+ self.assertEqual(data, b'AAAA')
+ sock.send(b'OK')
data = sock.recv_all(4)
- self.assertEqual(data, b"BBBB")
- sock.send(b"SPAM")
+ self.assertEqual(data, b'BBBB')
+ sock.send(b'SPAM')
async def client_wrapper(addr):
await client(addr)
@@ -292,9 +280,9 @@ def run(coro):
nonlocal CNT
CNT = 0
- with self.unix_server(
- server, max_clients=TOTAL_CNT, backlog=TOTAL_CNT
- ) as srv:
+ with self.unix_server(server,
+ max_clients=TOTAL_CNT,
+ backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
@@ -329,16 +317,16 @@ def test_create_unix_connection_3(self):
def server(sock):
data = sock.recv_all(4)
- self.assertEqual(data, b"AAAA")
+ self.assertEqual(data, b'AAAA')
sock.close()
async def client(addr):
reader, writer = await asyncio.open_unix_connection(addr)
- sock = writer._transport.get_extra_info("socket")
+ sock = writer._transport.get_extra_info('socket')
self.assertEqual(sock.family, socket.AF_UNIX)
- writer.write(b"AAAA")
+ writer.write(b'AAAA')
with self.assertRaises(asyncio.IncompleteReadError):
await reader.readexactly(10)
@@ -353,9 +341,9 @@ def run(coro):
nonlocal CNT
CNT = 0
- with self.unix_server(
- server, max_clients=TOTAL_CNT, backlog=TOTAL_CNT
- ) as srv:
+ with self.unix_server(server,
+ max_clients=TOTAL_CNT,
+ backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
@@ -376,7 +364,7 @@ async def client():
await self.wait_closed(writer)
async def runner():
- with self.assertRaisesRegex(OSError, "Bad file"):
+ with self.assertRaisesRegex(OSError, 'Bad file'):
await client()
self.loop.run_until_complete(runner())
@@ -394,39 +382,34 @@ def connection_lost(self, exc):
async def client():
t, _ = await self.loop.create_unix_connection(
- lambda: proto, None, sock=s2
- )
+ lambda: proto,
+ None,
+ sock=s2)
- t.write(b"AAAAA")
+ t.write(b'AAAAA')
s1.close()
- t.write(b"AAAAA")
+ t.write(b'AAAAA')
await asyncio.sleep(0.1)
self.loop.run_until_complete(client())
self.assertEqual(len(excs), 1)
- self.assertIn(
- excs[0].__class__, (BrokenPipeError, ConnectionResetError)
- )
+ self.assertIn(excs[0].__class__,
+ (BrokenPipeError, ConnectionResetError))
def test_create_unix_connection_6(self):
with self.assertRaisesRegex(
- ValueError, "ssl_handshake_timeout is only meaningful"
- ):
+ ValueError, 'ssl_handshake_timeout is only meaningful'):
self.loop.run_until_complete(
self.loop.create_unix_connection(
- lambda: None,
- path="/tmp/a",
- ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT,
- )
- )
+ lambda: None, path='/tmp/a',
+ ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT))
def test_create_unix_connection_sock_cancel_detaches(self):
async def test():
- srv_path = os.path.join(tempfile.mkdtemp(), "test.sock")
+ srv_path = os.path.join(tempfile.mkdtemp(), 'test.sock')
srv = await asyncio.start_unix_server(
- lambda r, w: w.close(), path=srv_path
- )
+ lambda r, w: w.close(), path=srv_path)
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.setblocking(False)
@@ -437,8 +420,8 @@ async def test():
await asyncio.sleep(0.01)
task = asyncio.ensure_future(
- self.loop.create_unix_connection(asyncio.Protocol, sock=sock)
- )
+ self.loop.create_unix_connection(
+ asyncio.Protocol, sock=sock))
await asyncio.sleep(0)
task.cancel()
with self.assertRaises(asyncio.CancelledError):
@@ -458,10 +441,9 @@ def test_create_unix_connection_sock_cancel_fd_leak(self):
# the create_unix_connection(sock=) path.
async def test():
- srv_path = os.path.join(tempfile.mkdtemp(), "test.sock")
+ srv_path = os.path.join(tempfile.mkdtemp(), 'test.sock')
srv = await asyncio.start_unix_server(
- lambda r, w: w.close(), path=srv_path
- )
+ lambda r, w: w.close(), path=srv_path)
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.setblocking(False)
@@ -469,8 +451,8 @@ async def test():
stale_fd = sock.fileno()
task = self.loop.create_task(
- self.loop.create_unix_connection(asyncio.Protocol, sock=sock)
- )
+ self.loop.create_unix_connection(
+ asyncio.Protocol, sock=sock))
await asyncio.sleep(0)
task.cancel()
with self.assertRaises(asyncio.CancelledError):
@@ -481,9 +463,8 @@ async def test():
victim_sock.setblocking(False)
await self.loop.sock_connect(victim_sock, srv_path)
victim_tr, _ = await self.loop.create_unix_connection(
- asyncio.Protocol, sock=victim_sock
- )
- victim_fd = victim_tr.get_extra_info("socket").fileno()
+ asyncio.Protocol, sock=victim_sock)
+ victim_fd = victim_tr.get_extra_info('socket').fileno()
if victim_fd != stale_fd:
victim_tr.close()
sock.close()
@@ -492,8 +473,7 @@ async def test():
if os.path.exists(srv_path):
os.unlink(srv_path)
raise unittest.SkipTest(
- f"fd not reused (got {victim_fd}, need {stale_fd})"
- )
+ f'fd not reused (got {victim_fd}, need {stale_fd})')
spy_a, spy_b = socket.socketpair()
spy_b.setblocking(False)
@@ -510,12 +490,12 @@ async def test():
os.dup2(spy_a.fileno(), stale_fd)
spy_a.close()
- victim_tr.write(b"LEAKED")
+ victim_tr.write(b'LEAKED')
try:
leaked = spy_b.recv(4096)
except BlockingIOError:
- leaked = b""
+ leaked = b''
if victim_broken:
os.close(stale_fd)
@@ -530,35 +510,32 @@ async def test():
if os.path.exists(srv_path):
os.unlink(srv_path)
- self.assertEqual(
- leaked,
- b"",
- f"Data leaked to an unrelated socket: " f"got {leaked!r}",
- )
+ self.assertEqual(leaked, b'',
+ f"Data leaked to an unrelated socket: "
+ f"got {leaked!r}")
self.loop.run_until_complete(test())
class Test_UV_Unix(_TestUnix, tb.UVTestCase):
- @unittest.skipUnless(hasattr(os, "fspath"), "no os.fspath()")
+
+ @unittest.skipUnless(hasattr(os, 'fspath'), 'no os.fspath()')
def test_create_unix_connection_pathlib(self):
async def run(addr):
t, _ = await self.loop.create_unix_connection(
- asyncio.Protocol, addr
- )
+ asyncio.Protocol, addr)
t.close()
with self.unix_server(lambda sock: time.sleep(0.01)) as srv:
addr = pathlib.Path(srv.addr)
self.loop.run_until_complete(run(addr))
- @unittest.skipUnless(hasattr(os, "fspath"), "no os.fspath()")
+ @unittest.skipUnless(hasattr(os, 'fspath'), 'no os.fspath()')
def test_create_unix_server_pathlib(self):
with self.unix_sock_name() as srv_path:
srv_path = pathlib.Path(srv_path)
srv = self.loop.run_until_complete(
- self.loop.create_unix_server(asyncio.Protocol, srv_path)
- )
+ self.loop.create_unix_server(asyncio.Protocol, srv_path))
srv.close()
self.loop.run_until_complete(srv.wait_closed())
@@ -568,15 +545,15 @@ def test_transport_fromsock_get_extra_info(self):
async def test(sock):
t, _ = await self.loop.create_unix_connection(
- asyncio.Protocol, sock=sock
- )
+ asyncio.Protocol,
+ sock=sock)
- sock = t.get_extra_info("socket")
- self.assertIs(t.get_extra_info("socket"), sock)
+ sock = t.get_extra_info('socket')
+ self.assertIs(t.get_extra_info('socket'), sock)
- with self.assertRaisesRegex(RuntimeError, "is used by transport"):
+ with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_writer(sock.fileno(), lambda: None)
- with self.assertRaisesRegex(RuntimeError, "is used by transport"):
+ with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_writer(sock.fileno())
t.close()
@@ -588,41 +565,37 @@ async def test(sock):
def test_create_unix_server_path_dgram(self):
sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
with sock:
- coro = self.loop.create_unix_server(lambda: None, sock=sock)
- with self.assertRaisesRegex(
- ValueError, "A UNIX Domain Stream.*was expected"
- ):
+ coro = self.loop.create_unix_server(lambda: None,
+ sock=sock)
+ with self.assertRaisesRegex(ValueError,
+ 'A UNIX Domain Stream.*was expected'):
self.loop.run_until_complete(coro)
- @unittest.skipUnless(
- hasattr(socket, "SOCK_NONBLOCK"),
- "no socket.SOCK_NONBLOCK (linux only)",
- )
+ @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
+ 'no socket.SOCK_NONBLOCK (linux only)')
def test_create_unix_server_path_stream_bittype(self):
sock = socket.socket(
- socket.AF_UNIX, socket.SOCK_STREAM | socket.SOCK_NONBLOCK
- )
+ socket.AF_UNIX, socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
with tempfile.NamedTemporaryFile() as file:
fn = file.name
with sock:
sock.bind(fn)
- coro = self.loop.create_unix_server(
- lambda: None, path=None, sock=sock, cleanup_socket=True
- )
+ coro = self.loop.create_unix_server(lambda: None, path=None,
+ sock=sock, cleanup_socket=True)
srv = self.loop.run_until_complete(coro)
srv.close()
self.loop.run_until_complete(srv.wait_closed())
- @unittest.skipUnless(sys.platform.startswith("linux"), "requires epoll")
+ @unittest.skipUnless(sys.platform.startswith('linux'), 'requires epoll')
def test_epollhup(self):
SIZE = 50
eof = False
done = False
- recvd = b""
+ recvd = b''
class Proto(asyncio.BaseProtocol):
def connection_made(self, tr):
- tr.write(b"hello")
+ tr.write(b'hello')
self.data = bytearray(SIZE)
self.buf = memoryview(self.data)
@@ -643,7 +616,7 @@ def connection_lost(self, exc):
async def test():
with tempfile.TemporaryDirectory() as td:
- sock_name = os.path.join(td, "sock")
+ sock_name = os.path.join(td, 'sock')
srv = await self.loop.create_unix_server(Proto, sock_name)
s = socket.socket(socket.AF_UNIX)
@@ -651,10 +624,10 @@ async def test():
s.setblocking(False)
await self.loop.sock_connect(s, sock_name)
d = await self.loop.sock_recv(s, 100)
- self.assertEqual(d, b"hello")
+ self.assertEqual(d, b'hello')
# IMPORTANT: overflow recv buffer and close immediately
- await self.loop.sock_sendall(s, b"a" * (SIZE + 1))
+ await self.loop.sock_sendall(s, b'a' * (SIZE + 1))
srv.close()
await srv.wait_closed()
@@ -662,7 +635,7 @@ async def test():
self.loop.run_until_complete(test())
self.assertTrue(eof)
self.assertIsNone(done)
- self.assertEqual(recvd, b"a" * (SIZE + 1))
+ self.assertEqual(recvd, b'a' * (SIZE + 1))
class Test_AIO_Unix(_TestUnix, tb.AIOTestCase):
@@ -671,16 +644,17 @@ class Test_AIO_Unix(_TestUnix, tb.AIOTestCase):
@unittest.skipIf(sys.platform == "win32", "no Unix socket tests on Windows")
class _TestSSL(tb.SSLTestCase):
- ONLYCERT = tb._cert_fullname(__file__, "ssl_cert.pem")
- ONLYKEY = tb._cert_fullname(__file__, "ssl_key.pem")
+
+ ONLYCERT = tb._cert_fullname(__file__, 'ssl_cert.pem')
+ ONLYKEY = tb._cert_fullname(__file__, 'ssl_key.pem')
def test_create_unix_server_ssl_1(self):
- CNT = 0 # number of clients that were successful
- TOTAL_CNT = 25 # total number of clients that test will create
- TIMEOUT = 10.0 # timeout for this test
+ CNT = 0 # number of clients that were successful
+ TOTAL_CNT = 25 # total number of clients that test will create
+ TIMEOUT = 10.0 # timeout for this test
- A_DATA = b"A" * 1024 * 1024
- B_DATA = b"B" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
+ B_DATA = b'B' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
@@ -692,11 +666,11 @@ async def handle_client(reader, writer):
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
- writer.write(b"OK")
+ writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
- writer.writelines([b"SP", bytearray(b"A"), memoryview(b"M")])
+ writer.writelines([b'SP', bytearray(b'A'), memoryview(b'M')])
await writer.drain()
writer.close()
@@ -714,24 +688,21 @@ def prog(sock):
sock.send(A_DATA)
data = sock.recv_all(2)
- self.assertEqual(data, b"OK")
+ self.assertEqual(data, b'OK')
sock.send(B_DATA)
data = sock.recv_all(4)
- self.assertEqual(data, b"SPAM")
+ self.assertEqual(data, b'SPAM')
sock.close()
except Exception as ex:
self.loop.call_soon_threadsafe(
- lambda ex=ex: (
- fut.cancelled() or fut.set_exception(ex)
- )
- )
+ lambda ex=ex:
+ (fut.cancelled() or fut.set_exception(ex)))
else:
self.loop.call_soon_threadsafe(
- lambda: (fut.cancelled() or fut.set_result(None))
- )
+ lambda: (fut.cancelled() or fut.set_result(None)))
client = self.unix_client(prog)
client.start()
@@ -743,11 +714,13 @@ async def start_server():
extras = dict(ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT)
with tempfile.TemporaryDirectory() as td:
- sock_name = os.path.join(td, "sock")
+ sock_name = os.path.join(td, 'sock')
srv = await asyncio.start_unix_server(
- handle_client, sock_name, ssl=sslctx, **extras
- )
+ handle_client,
+ sock_name,
+ ssl=sslctx,
+ **extras)
try:
tasks = []
@@ -764,9 +737,9 @@ async def start_server():
with self._silence_eof_received_warning():
self.loop.run_until_complete(start_server())
except asyncio.TimeoutError:
- if os.environ.get("TRAVIS_OS_NAME") == "osx":
+ if os.environ.get('TRAVIS_OS_NAME') == 'osx':
# XXX: figure out why this fails on macOS on Travis
- raise unittest.SkipTest("unexplained error on Travis macOS")
+ raise unittest.SkipTest('unexplained error on Travis macOS')
else:
raise
@@ -779,8 +752,8 @@ def test_create_unix_connection_ssl_1(self):
CNT = 0
TOTAL_CNT = 25
- A_DATA = b"A" * 1024 * 1024
- B_DATA = b"B" * 1024 * 1024
+ A_DATA = b'A' * 1024 * 1024
+ B_DATA = b'B' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
@@ -790,11 +763,11 @@ def server(sock):
data = sock.recv_all(len(A_DATA))
self.assertEqual(data, A_DATA)
- sock.send(b"OK")
+ sock.send(b'OK')
data = sock.recv_all(len(B_DATA))
self.assertEqual(data, B_DATA)
- sock.send(b"SPAM")
+ sock.send(b'SPAM')
sock.close()
@@ -802,14 +775,16 @@ async def client(addr):
extras = dict(ssl_handshake_timeout=SSL_HANDSHAKE_TIMEOUT)
reader, writer = await asyncio.open_unix_connection(
- addr, ssl=client_sslctx, server_hostname="", **extras
- )
+ addr,
+ ssl=client_sslctx,
+ server_hostname='',
+ **extras)
writer.write(A_DATA)
- self.assertEqual(await reader.readexactly(2), b"OK")
+ self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
- self.assertEqual(await reader.readexactly(4), b"SPAM")
+ self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
@@ -821,9 +796,9 @@ def run(coro):
nonlocal CNT
CNT = 0
- with self.unix_server(
- server, max_clients=TOTAL_CNT, backlog=TOTAL_CNT
- ) as srv:
+ with self.unix_server(server,
+ max_clients=TOTAL_CNT,
+ backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
diff --git a/uvloop/_testbase.py b/uvloop/_testbase.py
index a4d9af777..57946c0f1 100644
--- a/uvloop/_testbase.py
+++ b/uvloop/_testbase.py
@@ -1,5 +1,6 @@
"""Test utilities. Don't use outside of the uvloop project."""
+
import asyncio
import asyncio.events
import collections
@@ -33,7 +34,8 @@ def __init__(self, name):
def __setitem__(self, key, value):
if key in self.data:
- raise RuntimeError("duplicate test {}.{}".format(self.name, key))
+ raise RuntimeError('duplicate test {}.{}'.format(
+ self.name, key))
super().__setitem__(key, value)
@@ -45,14 +47,14 @@ def __prepare__(mcls, name, bases):
def __new__(mcls, name, bases, dct):
for test_name in dct:
- if not test_name.startswith("test_"):
+ if not test_name.startswith('test_'):
continue
for base in bases:
if hasattr(base, test_name):
raise RuntimeError(
- "duplicate test {}.{} (also defined in {} "
- "parent class)".format(name, test_name, base.__name__)
- )
+ 'duplicate test {}.{} (also defined in {} '
+ 'parent class)'.format(
+ name, test_name, base.__name__))
return super().__new__(mcls, name, bases, dict(dct))
@@ -77,7 +79,7 @@ async def wait_closed(self, obj):
pass
def is_asyncio_loop(self):
- return type(self.loop).__module__.startswith("asyncio.")
+ return type(self.loop).__module__.startswith('asyncio.')
def run_loop_briefly(self, *, delay=0.01):
self.loop.run_until_complete(asyncio.sleep(delay))
@@ -87,8 +89,6 @@ def loop_exception_handler(self, loop, context):
self.loop.default_exception_handler(context)
def setUp(self):
- # WINLOOP comment: next two lines are swapped because otherwise
- # setting event loop policy has no effect.
asyncio.set_event_loop_policy(self.new_policy())
self.loop = self.new_loop()
asyncio.set_event_loop(self.loop)
@@ -101,9 +101,9 @@ def tearDown(self):
self.loop.close()
if self.__unhandled_exceptions:
- print("Unexpected calls to loop.call_exception_handler():")
+ print('Unexpected calls to loop.call_exception_handler():')
pprint.pprint(self.__unhandled_exceptions)
- self.fail("unexpected calls to loop.call_exception_handler()")
+ self.fail('unexpected calls to loop.call_exception_handler()')
return
if not self._check_unclosed_resources_in_debug:
@@ -114,7 +114,7 @@ def tearDown(self):
gc.collect()
gc.collect()
- if getattr(self.loop, "_debug_cc", False):
+ if getattr(self.loop, '_debug_cc', False):
gc.collect()
gc.collect()
gc.collect()
@@ -122,42 +122,33 @@ def tearDown(self):
self.assertEqual(
self.loop._debug_uv_handles_total,
self.loop._debug_uv_handles_freed,
- "not all uv_handle_t handles were freed",
- )
+ 'not all uv_handle_t handles were freed')
self.assertEqual(
- self.loop._debug_cb_handles_count,
- 0,
- "not all callbacks (call_soon) are GCed",
- )
+ self.loop._debug_cb_handles_count, 0,
+ 'not all callbacks (call_soon) are GCed')
self.assertEqual(
- self.loop._debug_cb_timer_handles_count,
- 0,
- "not all timer callbacks (call_later) are GCed",
- )
+ self.loop._debug_cb_timer_handles_count, 0,
+ 'not all timer callbacks (call_later) are GCed')
self.assertEqual(
- self.loop._debug_stream_write_ctx_cnt,
- 0,
- "not all stream write contexts are GCed",
- )
+ self.loop._debug_stream_write_ctx_cnt, 0,
+ 'not all stream write contexts are GCed')
for h_name, h_cnt in self.loop._debug_handles_current.items():
- with self.subTest(
- "Alive handle after test", handle_name=h_name
- ):
+ with self.subTest('Alive handle after test',
+ handle_name=h_name):
self.assertEqual(
- h_cnt, 0, "alive {} after test".format(h_name)
- )
+ h_cnt, 0,
+ 'alive {} after test'.format(h_name))
for h_name, h_cnt in self.loop._debug_handles_total.items():
- with self.subTest("Total/closed handles", handle_name=h_name):
+ with self.subTest('Total/closed handles',
+ handle_name=h_name):
self.assertEqual(
- h_cnt,
- self.loop._debug_handles_closed[h_name],
- "total != closed for {}".format(h_name),
- )
+ h_cnt, self.loop._debug_handles_closed[h_name],
+ 'total != closed for {}'.format(h_name))
asyncio.set_event_loop(None)
asyncio.set_event_loop_policy(None)
@@ -166,31 +157,26 @@ def tearDown(self):
def skip_unclosed_handles_check(self):
self._check_unclosed_resources_in_debug = False
- def tcp_server(
- self,
- server_prog,
- *,
- family=socket.AF_INET,
- addr=None,
- timeout=5,
- backlog=1,
- max_clients=10,
- ):
+ def tcp_server(self, server_prog, *,
+ family=socket.AF_INET,
+ addr=None,
+ timeout=5,
+ backlog=1,
+ max_clients=10):
if addr is None:
- # Winloop comment: Windows has no Unix sockets
- if hasattr(socket, "AF_UNIX") and family == socket.AF_UNIX:
+ if hasattr(socket, 'AF_UNIX') and family == socket.AF_UNIX:
with tempfile.NamedTemporaryFile() as tmp:
addr = tmp.name
else:
- addr = ("127.0.0.1", 0)
+ addr = ('127.0.0.1', 0)
sock = socket.socket(family, socket.SOCK_STREAM)
if timeout is None:
- raise RuntimeError("timeout is required")
+ raise RuntimeError('timeout is required')
if timeout <= 0:
- raise RuntimeError("only blocking sockets are supported")
+ raise RuntimeError('only blocking sockets are supported')
sock.settimeout(timeout)
try:
@@ -201,20 +187,22 @@ def tcp_server(
raise ex
return TestThreadedServer(
- self, sock, server_prog, timeout, max_clients
- )
+ self, sock, server_prog, timeout, max_clients)
- def tcp_client(self, client_prog, family=socket.AF_INET, timeout=10):
+ def tcp_client(self, client_prog,
+ family=socket.AF_INET,
+ timeout=10):
sock = socket.socket(family, socket.SOCK_STREAM)
if timeout is None:
- raise RuntimeError("timeout is required")
+ raise RuntimeError('timeout is required')
if timeout <= 0:
- raise RuntimeError("only blocking sockets are supported")
+ raise RuntimeError('only blocking sockets are supported')
sock.settimeout(timeout)
- return TestThreadedClient(self, sock, client_prog, timeout)
+ return TestThreadedClient(
+ self, sock, client_prog, timeout)
def unix_server(self, *args, **kwargs):
return self.tcp_server(*args, family=socket.AF_UNIX, **kwargs)
@@ -225,7 +213,7 @@ def unix_client(self, *args, **kwargs):
@contextlib.contextmanager
def unix_sock_name(self):
with tempfile.TemporaryDirectory() as td:
- fn = os.path.join(td, "sock")
+ fn = os.path.join(td, 'sock')
try:
yield fn
finally:
@@ -242,9 +230,8 @@ def _abort_socket_test(self, ex):
def _cert_fullname(test_file_name, cert_file_name):
- fullname = os.path.abspath(
- os.path.join(os.path.dirname(test_file_name), "certs", cert_file_name)
- )
+ fullname = os.path.abspath(os.path.join(
+ os.path.dirname(test_file_name), 'certs', cert_file_name))
assert os.path.isfile(fullname)
return fullname
@@ -254,12 +241,10 @@ def silence_long_exec_warning():
class Filter(logging.Filter):
def filter(self, record):
- return not (
- record.msg.startswith("Executing")
- and record.msg.endswith("seconds")
- )
+ return not (record.msg.startswith('Executing') and
+ record.msg.endswith('seconds'))
- logger = logging.getLogger("asyncio")
+ logger = logging.getLogger('asyncio')
filter = Filter()
logger.addFilter(filter)
try:
@@ -273,20 +258,20 @@ def find_free_port(start_from=50000):
sock = socket.socket()
with sock:
try:
- sock.bind(("", port))
+ sock.bind(('', port))
except socket.error:
continue
else:
return port
- raise RuntimeError("could not find a free port")
+ raise RuntimeError('could not find a free port')
class SSLTestCase:
def _create_server_ssl_context(self, certfile, keyfile=None):
- if hasattr(ssl, "PROTOCOL_TLS_SERVER"):
+ if hasattr(ssl, 'PROTOCOL_TLS_SERVER'):
sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
- elif hasattr(ssl, "PROTOCOL_TLS"):
+ elif hasattr(ssl, 'PROTOCOL_TLS'):
sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS)
else:
sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
@@ -304,8 +289,8 @@ def _create_client_ssl_context(self, *, disable_verify=True):
@contextlib.contextmanager
def _silence_eof_received_warning(self):
# TODO This warning has to be fixed in asyncio.
- logger = logging.getLogger("asyncio")
- filter = logging.Filter("has no effect when using ssl")
+ logger = logging.getLogger('asyncio')
+ filter = logging.Filter('has no effect when using ssl')
logger.addFilter(filter)
try:
yield
@@ -315,7 +300,7 @@ def _silence_eof_received_warning(self):
class UVTestCase(BaseTestCase):
- implementation = "uvloop"
+ implementation = 'uvloop'
def new_loop(self):
return uvloop.new_event_loop()
@@ -326,7 +311,7 @@ def new_policy(self):
class AIOTestCase(BaseTestCase):
- implementation = "asyncio"
+ implementation = 'asyncio'
def setUp(self):
super().setUp()
@@ -352,7 +337,7 @@ def has_IPv6():
server_sock = socket.socket(socket.AF_INET6)
with server_sock:
try:
- server_sock.bind(("::1", 0))
+ server_sock.bind(('::1', 0))
except OSError:
return False
else:
@@ -373,31 +358,25 @@ def __init__(self, sock):
self.__sock = sock
def recv_all(self, n):
- buf = b""
+ buf = b''
while len(buf) < n:
data = self.recv(n - len(buf))
- if data == b"":
+ if data == b'':
raise ConnectionAbortedError
buf += data
return buf
- def starttls(
- self,
- ssl_context,
- *,
- server_side=False,
- server_hostname=None,
- do_handshake_on_connect=True,
- ):
+ def starttls(self, ssl_context, *,
+ server_side=False,
+ server_hostname=None,
+ do_handshake_on_connect=True):
assert isinstance(ssl_context, ssl.SSLContext)
ssl_sock = ssl_context.wrap_socket(
- self.__sock,
- server_side=server_side,
+ self.__sock, server_side=server_side,
server_hostname=server_hostname,
- do_handshake_on_connect=do_handshake_on_connect,
- )
+ do_handshake_on_connect=do_handshake_on_connect)
if server_side:
ssl_sock.do_handshake()
@@ -409,7 +388,7 @@ def __getattr__(self, name):
return getattr(self.__sock, name)
def __repr__(self):
- return "<{} {!r}>".format(type(self).__name__, self.__sock)
+ return '<{} {!r}>'.format(type(self).__name__, self.__sock)
class SocketThread(threading.Thread):
@@ -429,7 +408,7 @@ def __exit__(self, *exc):
class TestThreadedClient(SocketThread):
def __init__(self, test, sock, prog, timeout):
- threading.Thread.__init__(self, None, None, "test-client")
+ threading.Thread.__init__(self, None, None, 'test-client')
self.daemon = True
self._timeout = timeout
@@ -450,7 +429,7 @@ def run(self):
class TestThreadedServer(SocketThread):
def __init__(self, test, sock, prog, timeout, max_clients):
- threading.Thread.__init__(self, None, None, "test-server")
+ threading.Thread.__init__(self, None, None, 'test-server')
self.daemon = True
self._clients = 0
@@ -471,7 +450,7 @@ def stop(self):
try:
if self._s2 and self._s2.fileno() != -1:
try:
- self._s2.send(b"stop")
+ self._s2.send(b'stop')
except OSError:
pass
finally:
@@ -492,8 +471,7 @@ def _run(self):
return
r, w, x = select.select(
- [self._sock, self._s1], [], [], self._timeout
- )
+ [self._sock, self._s1], [], [], self._timeout)
if self._s1 in r:
return
diff --git a/uvloop/dns.pyx b/uvloop/dns.pyx
index 0a2c02dcd..ad347f177 100644
--- a/uvloop/dns.pyx
+++ b/uvloop/dns.pyx
@@ -154,7 +154,7 @@ cdef __convert_pyaddr_to_sockaddr(int family, object addr,
(&ret.addr).sin6_flowinfo = flowinfo
(&ret.addr).sin6_scope_id = scope_id
- elif family == uv.AF_UNIX and (not system.PLATFORM_IS_WINDOWS):
+ elif not system.PLATFORM_IS_WINDOWS and family == uv.AF_UNIX:
if isinstance(addr, str):
addr = addr.encode(sys_getfilesystemencoding())
elif not isinstance(addr, bytes):
@@ -357,10 +357,7 @@ cdef class AddrInfoRequest(UVRequest):
# `getaddrinfo("localhost", ...)`. This is inconsistent with
# libuv 1.48 which treats empty nodename as EINVAL.
chost = 'localhost'
- elif host == b'' and sys_platform == "win32":
- # On Windows, `getaddrinfo("", ...)` is *almost* equivalent to
- # `getaddrinfo("..localmachine", ...)`. This is inconsistent with
- # libuv 1.48 which treats empty nodename as EINVAL.
+ elif host == b'' and sys_platform == 'win32':
chost = '..localmachine'
else:
@@ -393,11 +390,6 @@ cdef class AddrInfoRequest(UVRequest):
try:
if err == uv.UV_EINVAL:
# Convert UV_EINVAL to EAI_NONAME to match libc behavior
- # Winloop comment: on Windows, cPython has a simpler error
- # message than uvlib (via winsock probably) instead of
- # EAI_NONAME [ErrNo 10001] "No such host is known. ".
- # We replace the message with "getaddrinfo failed".
- # See also errors.pyx.
if sys_platform == 'win32':
msg = 'getaddrinfo failed'
else:
diff --git a/uvloop/errors.pyx b/uvloop/errors.pyx
index 84c3e9e5f..55ccb9114 100644
--- a/uvloop/errors.pyx
+++ b/uvloop/errors.pyx
@@ -1,29 +1,19 @@
-
-
cdef str __strerr(int errno):
return strerror(errno).decode()
cdef __convert_python_error(int uverr):
- # XXX Won't work for Windows:
# From libuv docs:
# Implementation detail: on Unix error codes are the
# negated errno (or -errno), while on Windows they
# are defined by libuv to arbitrary negative numbers.
-
cdef int oserr
- cdef object err
if system.PLATFORM_IS_WINDOWS:
-
- # So Let's try converting them a different way if were using windows.
- # Winloop has a smarter technique for showing these errors.
- err = getattr(win_errno, uv.uv_err_name(uverr).decode(), uverr)
+ err = getattr(win_errno, uv.uv_err_name(uverr).decode(), -uverr)
return OSError(err, uv.uv_strerror(uverr).decode())
-
- oserr = -uverr
-
+ oserr = -uverr
exc = OSError
if uverr in (uv.UV_EACCES, uv.UV_EPERM):
@@ -121,20 +111,11 @@ cdef convert_error(int uverr):
sock_err = __convert_socket_error(uverr)
if sock_err:
- # Winloop comment: Sometimes libraries will throw in some
- # unwanted unicode BS to unravel, to prevent the possibility of this being a threat,
- # surrogateescape is utilized
- # SEE: https://github.com/Vizonex/Winloop/issues/32
- msg = system.gai_strerror(sock_err).decode('utf-8', "surrogateescape")
- # Winloop comment: on Windows, cPython has a simpler error
- # message than uvlib (via winsock probably) in these two cases:
- # EAI_FAMILY [ErrNo 10047] "An address incompatible with the requested protocol was used. "
- # EAI_NONAME [ErrNo 10001] "No such host is known. "
- # We replace these messages with "getaddrinfo failed"
- if sys_platform == "win32":
- if sock_err in (socket_EAI_FAMILY, socket_EAI_NONAME):
- msg = 'getaddrinfo failed'
- return socket_gaierror(sock_err, msg)
+ if (system.PLATFORM_IS_WINDOWS and
+ sock_err in (socket_EAI_FAMILY, socket_EAI_NONAME)):
+ msg = 'getaddrinfo failed'
+ else:
+ msg = system.gai_strerror(sock_err).decode('utf-8')
+ return socket_gaierror(sock_err, msg)
return __convert_python_error(uverr)
-
diff --git a/uvloop/handles/process.pyx b/uvloop/handles/process.pyx
index 846119712..4b15ef62b 100644
--- a/uvloop/handles/process.pyx
+++ b/uvloop/handles/process.pyx
@@ -28,10 +28,8 @@ cdef class UVProcess(UVHandle):
pass_fds, debug_flags, preexec_fn, restore_signals):
global __forking
-
- if not system.PLATFORM_IS_WINDOWS:
- global __forking_loop
- global __forkHandler
+ global __forking_loop
+ global __forkHandler
cdef int err
@@ -91,33 +89,25 @@ cdef class UVProcess(UVHandle):
self._restore_signals = restore_signals
loop.active_process_handler = self
-
-
if not system.PLATFORM_IS_WINDOWS:
__forking = 1
__forking_loop = loop
system.setForkHandler(&__get_fork_handler)
PyOS_BeforeFork()
- else:
- py_gil_state = PyGILState_Ensure()
-
+
err = uv.uv_spawn(loop.uvloop,
- self._handle,
- &self.options)
-
-
+ self._handle,
+ &self.options)
+
if not system.PLATFORM_IS_WINDOWS:
__forking = 0
__forking_loop = None
system.resetForkHandler()
PyOS_AfterFork_Parent()
- else:
- PyGILState_Release(py_gil_state)
-
- loop.active_process_handler = None
+ loop.active_process_handler = None
if err < 0:
self._close_process_handle()
@@ -268,16 +258,6 @@ cdef class UVProcess(UVHandle):
if start_new_session:
self.options.flags |= uv.UV_PROCESS_DETACHED
- # if system.PLATFORM_IS_WINDOWS:
- # TODO Forget these flags for right now until we have figured out/diagnosed the real issue...
- # "All of these flags have been set because they're all meaningful on windows systems...
- # see uv_process_fags for more reasons why I had to set all of these up this way" - Vizonex
- # https://docs.libuv.org/en/v1.x/process.html#c.uv_process_flags
- # enabling VERBATIM_ARGUMENTS is helpful here because we're not enabling children...
- # self.options.flags |= uv.UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS
- # pass
-
-
if force_fork:
# This is a hack to work around the change in libuv 1.44:
# > macos: use posix_spawn instead of fork
@@ -439,10 +419,6 @@ cdef class UVProcessTransport(UVProcess):
else:
self._pending_calls.append((_CALL_PIPE_DATA_RECEIVED, fd, data))
- # TODO: https://github.com/Vizonex/Winloop/issues/126 bug fix for uvloop
- # Might need a special implementation for subprocess.Popen._get_handles()
- # but can't seem to wrap my head around how to go about doing it.
-
cdef _file_redirect_stdio(self, int fd):
fd = os_dup(fd)
os_set_inheritable(fd, True)
@@ -496,16 +472,6 @@ cdef class UVProcessTransport(UVProcess):
'subprocess.STDOUT is supported only by stderr parameter')
else:
io[0] = self._file_redirect_stdio(_stdin)
-
- elif system.PLATFORM_IS_WINDOWS and system.__UVLOOP_STDIN_BAD:
-
- # When a stdio is in a gui-like state without a console.
- # Using a standard redirect is not a good idea. This at least
- # is a better workaround that is a bit cleaner than doing what the
- # python standard library subprocess does with the _get_handles function
- # on windows. SEE: https://github.com/Vizonex/Winloop/issues/126
-
- io[0] = self._file_devnull()
else:
io[0] = self._file_redirect_stdio(0)
@@ -534,8 +500,6 @@ cdef class UVProcessTransport(UVProcess):
'subprocess.STDOUT is supported only by stderr parameter')
else:
io[1] = self._file_redirect_stdio(_stdout)
- elif system.PLATFORM_IS_WINDOWS and system.__UVLOOP_STDOUT_BAD:
- io[1] = self._file_devnull()
else:
io[1] = self._file_redirect_stdio(1)
@@ -561,9 +525,6 @@ cdef class UVProcessTransport(UVProcess):
io[2] = self._file_devnull()
else:
io[2] = self._file_redirect_stdio(_stderr)
-
- elif system.PLATFORM_IS_WINDOWS and system.__UVLOOP_STDOUT_BAD:
- io[2] = self._file_devnull()
else:
io[2] = self._file_redirect_stdio(2)
@@ -819,12 +780,7 @@ cdef __socketpair():
int fds[2]
int err
- # Winloop comment: no Unix sockets on Windows, using uv.uv_pipe()
- # instead of system.socketpair(). Also, see changes to
- # libuv/src/win/pipe.c to deal with UV_EPERM = -4048 errors
- # for stdin pipe.
if system.PLATFORM_IS_WINDOWS:
- # NB: uv.uv_file is int type on Windows
err = uv.uv_pipe(fds, uv.UV_NONBLOCK_PIPE, uv.UV_NONBLOCK_PIPE)
else:
err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)
diff --git a/uvloop/handles/stream.pyx b/uvloop/handles/stream.pyx
index 974d6ab33..4d4c0abbc 100644
--- a/uvloop/handles/stream.pyx
+++ b/uvloop/handles/stream.pyx
@@ -355,15 +355,10 @@ cdef class UVStream(UVBaseTransport):
Py_ssize_t blen
int saved_errno
int fd
-
+
if system.PLATFORM_IS_WINDOWS:
- # Winloop comment: WSASend below does not work with pipes.
- # For pipes, using Writefile() from Windows fileapi.h would
- # be an option, but the corresponding files have been created
- # FILE_FLAG_OVERLAPPED set, but we don't want to go that way here.
- # We detect pipes on Windows as pseudosockets.
if self._get_socket().family == uv.AF_UNIX:
- return 0 # use zero instead of an error as this is not a problem.
+ return 0
if (self._handle).write_queue_size != 0:
raise RuntimeError(
@@ -412,9 +407,6 @@ cdef class UVStream(UVBaseTransport):
if saved_errno in (errno.EAGAIN, system.EWOULDBLOCK):
return 0
elif system.PLATFORM_IS_WINDOWS:
- # Winloop comment: use uv_translate_sys_error for
- # correct results on all platforms as -saved_errno
- # only works for POSIX.
exc = convert_error(uv.uv_translate_sys_error(saved_errno))
self._fatal_error(exc, True)
return -1
@@ -445,8 +437,9 @@ cdef class UVStream(UVBaseTransport):
cdef bint all_sent
if (not self._protocol_paused and
- (self._handle).write_queue_size == 0 and
- self._buffer_size > self._high_water):
+ (self._handle).write_queue_size == 0 and
+ (not system.PLATFORM_IS_WINDOWS or
+ self._buffer_size > self._high_water)):
# Fast-path. If:
# - the protocol isn't yet paused,
# - there is no data in libuv buffers for this stream,
@@ -693,14 +686,9 @@ cdef class UVStream(UVBaseTransport):
cpdef write(self, object buf):
self._ensure_alive()
-
- if system.PLATFORM_IS_WINDOWS:
- # Winloop Comment: Winloop gets itself into trouble if this is
- # is not checked immediately, it's too costly to call the python function
- # bring in the flag instead to indicate closure.
- # SEE: https://github.com/Vizonex/Winloop/issues/84
- if self._closing:
- raise RuntimeError("Cannot call write() when UVStream is closing")
+
+ if system.PLATFORM_IS_WINDOWS and self._closing:
+ raise RuntimeError('Cannot call write() when UVStream is closing')
if self._eof:
raise RuntimeError('Cannot call write() after write_eof()')
@@ -832,11 +820,10 @@ cdef inline bint __uv_stream_on_read_common(
if sc.__read_error_close:
# Used for getting notified when a pipe is closed.
# See WriteUnixTransport for the explanation.
- # Winloop comment: 0-reads on pipes used, e.g., for stdin
- # ("write only") give ERROR_ACCESS_DENIED, and in this case
- # we should keep the transport open for further writes.
- if (system.PLATFORM_IS_WINDOWS and nread == uv.UV_EPERM
- and uv.uv_is_writable( sc._handle)):
+ # Keep write-only Windows pipes open after ERROR_ACCESS_DENIED.
+ if (system.PLATFORM_IS_WINDOWS and
+ nread == uv.UV_EPERM and
+ uv.uv_is_writable(sc._handle)):
sc._stop_reading()
else:
sc._on_eof()
diff --git a/uvloop/includes/compat.h b/uvloop/includes/compat.h
index f5d8a89c1..b008ff618 100644
--- a/uvloop/includes/compat.h
+++ b/uvloop/includes/compat.h
@@ -7,8 +7,8 @@
#include
#include
#else
-#include
#include
+#include
#endif
#include "Python.h"
@@ -32,9 +32,7 @@
#else
# define PLATFORM_IS_LINUX 0
# define EPOLL_CTL_DEL 2
-/* error C2016: C requires that a struct or union have at least one member on Windows
-with default compilation flags. Therefore put dummy field for now. */
-struct epoll_event {int dummyfield;};
+struct epoll_event { int unused; };
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) {
return 0;
};
@@ -158,7 +156,7 @@ _Py_RestoreSignals(void)
#ifdef _WIN32
void PyOS_BeforeFork() {
return;
-}
+}
void PyOS_AfterFork_Parent() {
return;
}
@@ -169,39 +167,8 @@ void PyOS_AfterFork_Child() {
#ifdef _WIN32
-/* For some strange reason this structure does not want to show up
- * when compiling in debug mode on 3.13+ on windows so lets redefine it as a macro */
-
-/* IDK How big to make this so will just leave it at 1 incase somehow accidently exposed */
+/* Cython omits this definition for traced generators on Windows. */
#ifndef __Pyx_MonitoringEventTypes_CyGen_count
#define __Pyx_MonitoringEventTypes_CyGen_count 1
#endif /* __Pyx_MonitoringEventTypes_CyGen_count */
#endif
-
-
-/* There is a bug with CX-Freeze on windows when compiled
- * to an exe this tries to fix it by seeing if alternate
- * workarounds like DEVNULL need to be provided.
- * SEE: https://github.com/Vizonex/Winloop/issues/126
- * There are several alternate workarounds to the problem but
- * what were going to attempt to do here is see if stdin, stdout, or stderr
- * are all mapped properly to 0, 1, 2. If these are -2 then the implementation
- * seen in subprocess.py will need to be applied where a handle is open with one closed
- * off... */
-
-#ifdef _WIN32
-#include
-
-/* if these show up as -2 console is deemed absent */
-#define __UVLOOP_STDIN_BAD (_fileno(stdin) == -2)
-#define __UVLOOP_STDOUT_BAD (_fileno(stdout) == -2)
-#define __UVLOOP_STDERR_BAD (_fileno(stderr) == -2)
-
-
-#else
-/* On Unix these are not needed, but we define it anyways so the
-compiler doesn't wind up throwing a fit about it */
-#define __UVLOOP_STDIN_BAD 0
-#define __UVLOOP_STDOUT_BAD 0
-#define __UVLOOP_STDERR_BAD 0
-#endif
diff --git a/uvloop/includes/python.pxd b/uvloop/includes/python.pxd
index 77f7f15b6..94007e537 100644
--- a/uvloop/includes/python.pxd
+++ b/uvloop/includes/python.pxd
@@ -29,4 +29,3 @@ cdef extern from "includes/compat.h":
void PyOS_AfterFork_Child()
void _Py_RestoreSignals()
-
diff --git a/uvloop/includes/stdlib.pxi b/uvloop/includes/stdlib.pxi
index 259842c7b..8ffc31dbd 100644
--- a/uvloop/includes/stdlib.pxi
+++ b/uvloop/includes/stdlib.pxi
@@ -55,7 +55,6 @@ cdef col_OrderedDict = collections.OrderedDict
cdef cc_ThreadPoolExecutor = concurrent.futures.ThreadPoolExecutor
cdef cc_Future = concurrent.futures.Future
-# windows needs access to errno for exception handling.
cdef win_errno = errno
cdef errno_EBADF = errno.EBADF
@@ -151,11 +150,9 @@ cdef int subprocess_STDOUT = subprocess.STDOUT
cdef int subprocess_DEVNULL = subprocess.DEVNULL
cdef subprocess_SubprocessError = subprocess.SubprocessError
-cdef int signal_SIGABRT = signal.SIGABRT
-cdef int signal_SIGINT = signal.SIGINT
cdef int signal_NSIG = signal.NSIG
cdef signal_signal = signal.signal
-cdef signal_siginterrupt = getattr(signal, "siginterrupt", None)
+cdef signal_siginterrupt = getattr(signal, 'siginterrupt', None)
cdef signal_set_wakeup_fd = signal.set_wakeup_fd
cdef signal_default_int_handler = signal.default_int_handler
cdef signal_SIG_DFL = signal.SIG_DFL
diff --git a/uvloop/includes/system.pxd b/uvloop/includes/system.pxd
index a80606b0f..ae81a92d6 100644
--- a/uvloop/includes/system.pxd
+++ b/uvloop/includes/system.pxd
@@ -65,12 +65,6 @@ cdef extern from "includes/compat.h" nogil:
int epoll_ctl(int epfd, int op, int fd, epoll_event *event)
object MakeUnixSockPyAddr(sockaddr_un *addr)
- # Checks if values are -2. This check only applies to windows.
- int __UVLOOP_STDIN_BAD
- int __UVLOOP_STDOUT_BAD
- int __UVLOOP_STDERR_BAD
-
-
cdef extern from "includes/fork_handler.h":
uint64_t MAIN_THREAD_ID
@@ -90,23 +84,12 @@ cdef extern from "includes/fork_handler.h":
cdef extern from * nogil:
"""
#ifdef _WIN32
-static inline uint64_t
-__win_atomic_fetch_add(uint64_t *ptr, uint64_t val){
- return *ptr = *(volatile uint64_t *)ptr + val;
-}
-
-static inline uint64_t
-__win_atomic_fetch_sub(uint64_t *ptr, uint64_t val){
- return *ptr = *(volatile uint64_t *)ptr - val;
-}
-
#define __atomic_fetch_add(ptr, val, memorder) \
- __win_atomic_fetch_add(ptr, val)
+ InterlockedExchangeAdd64((volatile LONG64*)(ptr), (LONG64)(val))
#define __atomic_fetch_sub(ptr, val, memorder) \
- __win_atomic_fetch_sub(ptr, val)
+ InterlockedExchangeAdd64((volatile LONG64*)(ptr), -(LONG64)(val))
-/* We need ATOMIC RELAXED still */
#define __ATOMIC_RELAXED 0
#endif /* _WIN32 */
"""
diff --git a/uvloop/includes/uv.pxd b/uvloop/includes/uv.pxd
index 2a47807bc..6da609d7f 100644
--- a/uvloop/includes/uv.pxd
+++ b/uvloop/includes/uv.pxd
@@ -56,9 +56,6 @@ cdef extern from "uv.h" nogil:
cdef int UV_EAI_SERVICE
cdef int UV_EAI_SOCKTYPE
- # Need for windows's sake
- cdef int SO_BROADCAST
-
cdef int SOL_SOCKET
cdef int SO_ERROR
cdef int SO_REUSEADDR
@@ -231,8 +228,7 @@ cdef extern from "uv.h" nogil:
const char* uv_strerror(int err)
const char* uv_err_name(int err)
-
- # Needed on windows
+
int uv_translate_sys_error(int sys_errno)
@@ -496,7 +492,7 @@ cdef extern from "uv.h" nogil:
ctypedef struct uv_stdio_container_t:
uv_stdio_flags flags
uv_stdio_container_data_u data
-
+
ctypedef unsigned char uv_uid_t
ctypedef unsigned char uv_gid_t
diff --git a/uvloop/loop.pyx b/uvloop/loop.pyx
index 59425723e..c57130a7f 100644
--- a/uvloop/loop.pyx
+++ b/uvloop/loop.pyx
@@ -28,10 +28,6 @@ from libc.stdint cimport uint64_t
from libc.string cimport memset, strerror, memcpy
from libc cimport errno
-# Winloop Comment: We need some cleaver hacky techniques for
-# preventing slow spawnning processes for MSVC
-from cpython.pystate cimport (PyGILState_Ensure, PyGILState_Release,
- PyGILState_STATE)
from cpython cimport PyObject
from cpython cimport PyErr_CheckSignals, PyErr_Occurred
from cpython cimport PyThread_get_thread_ident
@@ -1782,8 +1778,8 @@ cdef class Loop:
sock.setsockopt(uv.SOL_SOCKET, uv.SO_REUSEADDR, 1)
if reuse_port:
if system.PLATFORM_IS_WINDOWS:
- # replaced uv.SO_REUSEPORT with uv.SO_BROADCAST because it's the equivalent on windows systems...
- sock.setsockopt(uv.SOL_SOCKET, uv.SO_BROADCAST, 1)
+ raise ValueError(
+ 'reuse_port is not supported on Windows')
else:
sock.setsockopt(uv.SOL_SOCKET, SO_REUSEPORT, 1)
# Disable IPv4/IPv6 dual stack support (enabled by
@@ -2844,23 +2840,21 @@ cdef class Loop:
raise ValueError("shell must be True")
if not system.PLATFORM_IS_WINDOWS:
- args = [cmd]
- if shell:
- args = [b'/bin/sh', b'-c'] + args
+ args = [b'/bin/sh', b'-c', cmd]
else:
# SEE: https://github.com/libuv/libuv/pull/2627
# See subprocess.py for the mirror of this code.
- comspec = os_environ.get("ComSpec")
+ comspec = os_environ.get('ComSpec')
if not comspec:
system_root = os_environ.get("SystemRoot", '')
comspec = os_path_join(system_root, 'System32', 'cmd.exe')
if not os_path_isabs(comspec):
- raise FileNotFoundError('shell not found: neither %ComSpec% nor %SystemRoot% is set')
-
- args = [comspec]
- args.append('/c')
- args.append(cmd)
+ raise FileNotFoundError(
+ 'shell not found: neither %ComSpec% nor '
+ '%SystemRoot% is set')
+
+ args = [comspec, '/c', cmd]
return await self.__subprocess_run(protocol_factory, args, shell=True,
**kwargs)
@@ -2982,15 +2976,10 @@ cdef class Loop:
try:
# Register a dummy signal handler to ask Python to write the signal
# number in the wakeup file descriptor.
+ signal_signal(sig, self.__sighandler)
if not system.PLATFORM_IS_WINDOWS:
- signal_signal(sig, self.__sighandler)
-
# Set SA_RESTART to limit EINTR occurrences.
signal_siginterrupt(sig, False)
- else:
- # Windows doesn't have sig_interrupt function.
- # Something else must be attempted instead.
- signal_signal(signal_SIGINT, self.__sighandler)
except OSError as exc:
del self._signal_handlers[sig]
diff --git a/vendor/libuv b/vendor/libuv
index 1cfa32ff5..e9f29cb98 160000
--- a/vendor/libuv
+++ b/vendor/libuv
@@ -1 +1 @@
-Subproject commit 1cfa32ff59c076ffb6ed735bbc8c18361558661f
+Subproject commit e9f29cb984231524e3931aa0ae2c5dae1a32884e