@ajksunkang-aios/kgraph-linux-x64 0.1.2 → 0.1.3

package/lib/site-packages/trio/_tests/test_util.py

@@ -0,0 +1,349 @@
+from __future__ import annotations
+
+import sys
+import types
+from typing import TYPE_CHECKING, TypeVar
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Coroutine, Generator
+import pytest
+
+import trio
+from trio.testing import _Matcher as Matcher, _RaisesGroup as RaisesGroup
+
+from .. import _core
+from .._core._tests.tutil import (
+    create_asyncio_future_in_new_loop,
+    ignore_coroutine_never_awaited_warnings,
+)
+from .._util import (
+    ConflictDetector,
+    MultipleExceptionError,
+    NoPublicConstructor,
+    coroutine_or_error,
+    final,
+    fixup_module_metadata,
+    is_main_thread,
+    raise_single_exception_from_group,
+)
+from ..testing import wait_all_tasks_blocked
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import BaseExceptionGroup, ExceptionGroup
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+T = TypeVar("T")
+
+
+async def test_ConflictDetector() -> None:
+    ul1 = ConflictDetector("ul1")
+    ul2 = ConflictDetector("ul2")
+
+    with ul1:
+        with ul2:
+            print("ok")
+
+    with pytest.raises(_core.BusyResourceError, match="ul1"):
+        with ul1:
+            with ul1:
+                pass  # pragma: no cover
+
+    async def wait_with_ul1() -> None:
+        with ul1:
+            await wait_all_tasks_blocked()
+
+    with RaisesGroup(Matcher(_core.BusyResourceError, "ul1")):
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(wait_with_ul1)
+            nursery.start_soon(wait_with_ul1)
+
+
+def test_module_metadata_is_fixed_up() -> None:
+    import trio
+    import trio.testing
+
+    assert trio.Cancelled.__module__ == "trio"
+    assert trio.open_nursery.__module__ == "trio"
+    assert trio.abc.Stream.__module__ == "trio.abc"
+    assert trio.lowlevel.wait_task_rescheduled.__module__ == "trio.lowlevel"
+    assert trio.testing.trio_test.__module__ == "trio.testing"
+
+    # Also check methods
+    assert trio.lowlevel.ParkingLot.__init__.__module__ == "trio.lowlevel"
+    assert trio.abc.Stream.send_all.__module__ == "trio.abc"
+
+    # And names
+    assert trio.Cancelled.__name__ == "Cancelled"
+    assert trio.Cancelled.__qualname__ == "Cancelled"
+    assert trio.abc.SendStream.send_all.__name__ == "send_all"
+    assert trio.abc.SendStream.send_all.__qualname__ == "SendStream.send_all"
+    assert trio.to_thread.__name__ == "trio.to_thread"
+    assert trio.to_thread.run_sync.__name__ == "run_sync"
+    assert trio.to_thread.run_sync.__qualname__ == "run_sync"
+
+
+async def test_is_main_thread() -> None:
+    assert is_main_thread()
+
+    def not_main_thread() -> None:
+        assert not is_main_thread()
+
+    await trio.to_thread.run_sync(not_main_thread)
+
+
+# @coroutine is deprecated since python 3.8, which is fine with us.
+@pytest.mark.filterwarnings("ignore:.*@coroutine.*:DeprecationWarning")
+def test_coroutine_or_error() -> None:
+    class Deferred:
+        "Just kidding"
+
+    with ignore_coroutine_never_awaited_warnings():
+
+        async def f() -> None:  # pragma: no cover
+            pass
+
+        with pytest.raises(TypeError) as excinfo:
+            coroutine_or_error(f())  # type: ignore[arg-type, unused-coroutine]
+        assert "expecting an async function" in str(excinfo.value)
+
+        import asyncio
+
+        if sys.version_info < (3, 11):
+
+            @asyncio.coroutine
+            def generator_based_coro() -> (
+                Generator[Coroutine[None, None, None], None, None]
+            ):  # pragma: no cover
+                yield from asyncio.sleep(1)
+
+            with pytest.raises(TypeError) as excinfo:
+                coroutine_or_error(generator_based_coro())  # type: ignore[arg-type, unused-coroutine]
+            assert "asyncio" in str(excinfo.value)
+
+        with pytest.raises(TypeError) as excinfo:
+            coroutine_or_error(create_asyncio_future_in_new_loop())  # type: ignore[arg-type, unused-coroutine]
+        assert "asyncio" in str(excinfo.value)
+
+        # does not raise arg-type error
+        with pytest.raises(TypeError) as excinfo:
+            coroutine_or_error(create_asyncio_future_in_new_loop)  # type: ignore[unused-coroutine]
+        assert "asyncio" in str(excinfo.value)
+
+        with pytest.raises(TypeError) as excinfo:
+            coroutine_or_error(Deferred())  # type: ignore[arg-type, unused-coroutine]
+        assert "twisted" in str(excinfo.value)
+
+        with pytest.raises(TypeError) as excinfo:
+            coroutine_or_error(lambda: Deferred())  # type: ignore[arg-type, unused-coroutine, return-value]
+        assert "twisted" in str(excinfo.value)
+
+        with pytest.raises(TypeError) as excinfo:
+            coroutine_or_error(len, [[1, 2, 3]])  # type: ignore[arg-type, unused-coroutine]
+
+        assert "appears to be synchronous" in str(excinfo.value)
+
+        async def async_gen(
+            _: object,
+        ) -> AsyncGenerator[None, None]:  # pragma: no cover
+            yield
+
+        with pytest.raises(TypeError) as excinfo:
+            coroutine_or_error(async_gen, [0])  # type: ignore[arg-type,unused-coroutine]
+        msg = "expected an async function but got an async generator"
+        assert msg in str(excinfo.value)
+
+        # Make sure no references are kept around to keep anything alive
+        del excinfo
+
+
+def test_final_decorator() -> None:
+    """Test that subclassing a @final-annotated class is not allowed.
+
+    This checks both runtime results, and verifies that type checkers detect
+    the error statically through the type-ignore comment.
+    """
+
+    @final
+    class FinalClass:
+        pass
+
+    with pytest.raises(TypeError):
+
+        class SubClass(FinalClass):  # type: ignore[misc]
+            pass
+
+
+def test_no_public_constructor_metaclass() -> None:
+    """The NoPublicConstructor metaclass prevents calling the constructor directly."""
+
+    class SpecialClass(metaclass=NoPublicConstructor):
+        def __init__(self, a: int, b: float) -> None:
+            """Check arguments can be passed to __init__."""
+            assert a == 8
+            assert b == 3.15
+
+    with pytest.raises(TypeError):
+        SpecialClass(8, 3.15)
+
+    # Private constructor should not raise, and passes args to __init__.
+    assert isinstance(SpecialClass._create(8, b=3.15), SpecialClass)
+
+
+def test_fixup_module_metadata() -> None:
+    # Ignores modules not in the trio.X tree.
+    non_trio_module = types.ModuleType("not_trio")
+    non_trio_module.some_func = lambda: None  # type: ignore[attr-defined]
+    non_trio_module.some_func.__name__ = "some_func"
+    non_trio_module.some_func.__qualname__ = "some_func"
+
+    fixup_module_metadata(non_trio_module.__name__, vars(non_trio_module))
+
+    assert non_trio_module.some_func.__name__ == "some_func"
+    assert non_trio_module.some_func.__qualname__ == "some_func"
+
+    # Bulild up a fake module to test. Just use lambdas since all we care about is the names.
+    mod = types.ModuleType("trio._somemodule_impl")
+    mod.some_func = lambda: None  # type: ignore[attr-defined]
+    mod.some_func.__name__ = "_something_else"
+    mod.some_func.__qualname__ = "_something_else"
+
+    # No __module__ means it's unchanged.
+    mod.not_funclike = types.SimpleNamespace()  # type: ignore[attr-defined]
+    mod.not_funclike.__name__ = "not_funclike"
+
+    # Check __qualname__ being absent works.
+    mod.only_has_name = types.SimpleNamespace()  # type: ignore[attr-defined]
+    mod.only_has_name.__module__ = "trio._somemodule_impl"
+    mod.only_has_name.__name__ = "only_name"
+
+    # Underscored names are unchanged.
+    mod._private = lambda: None  # type: ignore[attr-defined]
+    mod._private.__module__ = "trio._somemodule_impl"
+    mod._private.__name__ = mod._private.__qualname__ = "_private"
+
+    # We recurse into classes.
+    mod.SomeClass = type(  # type: ignore[attr-defined]
+        "SomeClass",
+        (),
+        {
+            "__init__": lambda self: None,
+            "method": lambda self: None,
+        },
+    )
+    # Reference loop is fine.
+    mod.SomeClass.recursion = mod.SomeClass
+
+    fixup_module_metadata("trio.somemodule", vars(mod))
+    assert mod.some_func.__name__ == "some_func"
+    assert mod.some_func.__module__ == "trio.somemodule"
+    assert mod.some_func.__qualname__ == "some_func"
+
+    assert mod.not_funclike.__name__ == "not_funclike"
+    assert mod._private.__name__ == "_private"
+    assert mod._private.__module__ == "trio._somemodule_impl"
+    assert mod._private.__qualname__ == "_private"
+
+    assert mod.only_has_name.__name__ == "only_has_name"
+    assert mod.only_has_name.__module__ == "trio.somemodule"
+    assert not hasattr(mod.only_has_name, "__qualname__")
+
+    assert mod.SomeClass.method.__name__ == "method"
+    assert mod.SomeClass.method.__module__ == "trio.somemodule"
+    assert mod.SomeClass.method.__qualname__ == "SomeClass.method"
+    # Make coverage happy.
+    non_trio_module.some_func()
+    mod.some_func()
+    mod._private()
+    mod.SomeClass().method()
+
+
+async def test_raise_single_exception_from_group() -> None:
+    excinfo: pytest.ExceptionInfo[BaseException]
+
+    exc = ValueError("foo")
+    cause = SyntaxError("cause")
+    context = TypeError("context")
+    exc.__cause__ = cause
+    exc.__context__ = context
+    cancelled = trio.Cancelled._create(source="deadline")
+
+    with pytest.raises(ValueError, match="foo") as excinfo:
+        raise_single_exception_from_group(ExceptionGroup("", [exc]))
+    assert excinfo.value.__cause__ == cause
+    assert excinfo.value.__context__ == context
+
+    # only unwraps one layer of exceptiongroup
+    inner_eg = ExceptionGroup("inner eg", [exc])
+    inner_cause = SyntaxError("inner eg cause")
+    inner_context = TypeError("inner eg context")
+    inner_eg.__cause__ = inner_cause
+    inner_eg.__context__ = inner_context
+    with RaisesGroup(Matcher(ValueError, match="^foo$"), match="^inner eg$") as eginfo:
+        raise_single_exception_from_group(ExceptionGroup("", [inner_eg]))
+    assert eginfo.value.__cause__ == inner_cause
+    assert eginfo.value.__context__ == inner_context
+
+    with pytest.raises(ValueError, match="foo") as excinfo:
+        raise_single_exception_from_group(
+            BaseExceptionGroup("", [cancelled, cancelled, exc])
+        )
+    assert excinfo.value.__cause__ == cause
+    assert excinfo.value.__context__ == context
+
+    # multiple non-cancelled
+    eg = ExceptionGroup("", [ValueError("foo"), ValueError("bar")])
+    with pytest.raises(
+        MultipleExceptionError,
+        match=r"^Attempted to unwrap exceptiongroup with multiple non-cancelled exceptions. This is often caused by a bug in the caller.$",
+    ) as excinfo:
+        raise_single_exception_from_group(eg)
+    assert excinfo.value.__cause__ is eg
+    assert excinfo.value.__context__ is None
+
+    # keyboardinterrupt overrides everything
+    eg_ki = BaseExceptionGroup(
+        "",
+        [
+            ValueError("foo"),
+            ValueError("bar"),
+            KeyboardInterrupt("preserve error msg"),
+        ],
+    )
+    with pytest.raises(
+        KeyboardInterrupt,
+        match=r"^preserve error msg$",
+    ) as excinfo:
+        raise_single_exception_from_group(eg_ki)
+
+    assert excinfo.value.__cause__ is eg_ki
+    assert excinfo.value.__context__ is None
+
+    # and same for SystemExit but verify code too
+    systemexit_ki = BaseExceptionGroup(
+        "",
+        [
+            ValueError("foo"),
+            ValueError("bar"),
+            SystemExit(2),
+        ],
+    )
+
+    with pytest.raises(SystemExit) as excinfo:
+        raise_single_exception_from_group(systemexit_ki)
+
+    assert excinfo.value.code == 2
+    assert excinfo.value.__cause__ is systemexit_ki
+    assert excinfo.value.__context__ is None
+
+    # if we only got cancelled, first one is reraised
+    with pytest.raises(trio.Cancelled, match=r"^cancelled due to deadline$") as excinfo:
+        raise_single_exception_from_group(
+            BaseExceptionGroup(
+                "", [cancelled, trio.Cancelled._create(source="explicit")]
+            )
+        )
+    assert excinfo.value is cancelled
+    assert excinfo.value.__cause__ is None
+    assert excinfo.value.__context__ is None

package/lib/site-packages/trio/_tests/test_wait_for_object.py

@@ -0,0 +1,225 @@
+import os
+
+import pytest
+
+on_windows = os.name == "nt"
+# Mark all the tests in this file as being windows-only
+pytestmark = pytest.mark.skipif(not on_windows, reason="windows only")
+
+import trio
+
+from .. import _core, _timeouts
+from .._core._tests.tutil import slow
+
+if on_windows:
+    from .._core._windows_cffi import Handle, ffi, kernel32
+    from .._wait_for_object import WaitForMultipleObjects_sync, WaitForSingleObject
+
+
+def test_WaitForMultipleObjects_sync() -> None:
+    # This does a series of tests where we set/close the handle before
+    # initiating the waiting for it.
+    #
+    # Note that closing the handle (not signaling) will cause the
+    # *initiation* of a wait to return immediately. But closing a handle
+    # that is already being waited on will not stop whatever is waiting
+    # for it.
+
+    # One handle
+    handle1 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    kernel32.SetEvent(handle1)
+    WaitForMultipleObjects_sync(handle1)
+    kernel32.CloseHandle(handle1)
+    print("test_WaitForMultipleObjects_sync one OK")
+
+    # Two handles, signal first
+    handle1 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    handle2 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    kernel32.SetEvent(handle1)
+    WaitForMultipleObjects_sync(handle1, handle2)
+    kernel32.CloseHandle(handle1)
+    kernel32.CloseHandle(handle2)
+    print("test_WaitForMultipleObjects_sync set first OK")
+
+    # Two handles, signal second
+    handle1 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    handle2 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    kernel32.SetEvent(handle2)
+    WaitForMultipleObjects_sync(handle1, handle2)
+    kernel32.CloseHandle(handle1)
+    kernel32.CloseHandle(handle2)
+    print("test_WaitForMultipleObjects_sync set second OK")
+
+    # Two handles, close first
+    handle1 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    handle2 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    kernel32.CloseHandle(handle1)
+    with pytest.raises(OSError, match=r"^\[WinError 6\] The handle is invalid$"):
+        WaitForMultipleObjects_sync(handle1, handle2)
+    kernel32.CloseHandle(handle2)
+    print("test_WaitForMultipleObjects_sync close first OK")
+
+    # Two handles, close second
+    handle1 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    handle2 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    kernel32.CloseHandle(handle2)
+    with pytest.raises(OSError, match=r"^\[WinError 6\] The handle is invalid$"):
+        WaitForMultipleObjects_sync(handle1, handle2)
+    kernel32.CloseHandle(handle1)
+    print("test_WaitForMultipleObjects_sync close second OK")
+
+
+@slow
+async def test_WaitForMultipleObjects_sync_slow() -> None:
+    # This does a series of test in which the main thread sync-waits for
+    # handles, while we spawn a thread to set the handles after a short while.
+
+    TIMEOUT = 0.3
+
+    # One handle
+    handle1 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    t0 = _core.current_time()
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(
+            trio.to_thread.run_sync,
+            WaitForMultipleObjects_sync,
+            handle1,
+        )
+        await _timeouts.sleep(TIMEOUT)
+        # If we would comment the line below, the above thread will be stuck,
+        # and Trio won't exit this scope
+        kernel32.SetEvent(handle1)
+    t1 = _core.current_time()
+    assert TIMEOUT <= (t1 - t0) < 2.0 * TIMEOUT
+    kernel32.CloseHandle(handle1)
+    print("test_WaitForMultipleObjects_sync_slow one OK")
+
+    # Two handles, signal first
+    handle1 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    handle2 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    t0 = _core.current_time()
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(
+            trio.to_thread.run_sync,
+            WaitForMultipleObjects_sync,
+            handle1,
+            handle2,
+        )
+        await _timeouts.sleep(TIMEOUT)
+        kernel32.SetEvent(handle1)
+    t1 = _core.current_time()
+    assert TIMEOUT <= (t1 - t0) < 2.0 * TIMEOUT
+    kernel32.CloseHandle(handle1)
+    kernel32.CloseHandle(handle2)
+    print("test_WaitForMultipleObjects_sync_slow thread-set first OK")
+
+    # Two handles, signal second
+    handle1 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    handle2 = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    t0 = _core.current_time()
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(
+            trio.to_thread.run_sync,
+            WaitForMultipleObjects_sync,
+            handle1,
+            handle2,
+        )
+        await _timeouts.sleep(TIMEOUT)
+        kernel32.SetEvent(handle2)
+    t1 = _core.current_time()
+    assert TIMEOUT <= (t1 - t0) < 2.0 * TIMEOUT
+    kernel32.CloseHandle(handle1)
+    kernel32.CloseHandle(handle2)
+    print("test_WaitForMultipleObjects_sync_slow thread-set second OK")
+
+
+async def test_WaitForSingleObject() -> None:
+    # This does a series of test for setting/closing the handle before
+    # initiating the wait.
+
+    # Test already set
+    handle = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    kernel32.SetEvent(handle)
+    await WaitForSingleObject(handle)  # should return at once
+    kernel32.CloseHandle(handle)
+    print("test_WaitForSingleObject already set OK")
+
+    # Test already set, as int
+    handle = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    handle_int = int(ffi.cast("intptr_t", handle))
+    kernel32.SetEvent(handle)
+    await WaitForSingleObject(handle_int)  # should return at once
+    kernel32.CloseHandle(handle)
+    print("test_WaitForSingleObject already set OK")
+
+    # Test already closed
+    handle = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    kernel32.CloseHandle(handle)
+    with pytest.raises(OSError, match=r"^\[WinError 6\] The handle is invalid$"):
+        await WaitForSingleObject(handle)  # should return at once
+    print("test_WaitForSingleObject already closed OK")
+
+    # Not a handle
+    with pytest.raises(TypeError):
+        await WaitForSingleObject("not a handle")  # type: ignore[arg-type] # Wrong type
+    # with pytest.raises(OSError):
+    #     await WaitForSingleObject(99)  # If you're unlucky, it actually IS a handle :(
+    print("test_WaitForSingleObject not a handle OK")
+
+
+@slow
+async def test_WaitForSingleObject_slow() -> None:
+    # This does a series of test for setting the handle in another task,
+    # and cancelling the wait task.
+
+    # Set the timeout used in the tests. We test the waiting time against
+    # the timeout with a certain margin.
+    TIMEOUT = 0.3
+
+    async def signal_soon_async(handle: Handle) -> None:
+        await _timeouts.sleep(TIMEOUT)
+        kernel32.SetEvent(handle)
+
+    # Test handle is SET after TIMEOUT in separate coroutine
+
+    handle = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    t0 = _core.current_time()
+
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(WaitForSingleObject, handle)
+        nursery.start_soon(signal_soon_async, handle)
+
+    kernel32.CloseHandle(handle)
+    t1 = _core.current_time()
+    assert TIMEOUT <= (t1 - t0) < 2.0 * TIMEOUT
+    print("test_WaitForSingleObject_slow set from task OK")
+
+    # Test handle is SET after TIMEOUT in separate coroutine, as int
+
+    handle = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    handle_int = int(ffi.cast("intptr_t", handle))
+    t0 = _core.current_time()
+
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(WaitForSingleObject, handle_int)
+        nursery.start_soon(signal_soon_async, handle)
+
+    kernel32.CloseHandle(handle)
+    t1 = _core.current_time()
+    assert TIMEOUT <= (t1 - t0) < 2.0 * TIMEOUT
+    print("test_WaitForSingleObject_slow set from task as int OK")
+
+    # Test handle is CLOSED after 1 sec - NOPE see comment above
+
+    # Test cancellation
+
+    handle = kernel32.CreateEventA(ffi.NULL, True, False, ffi.NULL)
+    t0 = _core.current_time()
+
+    with _timeouts.move_on_after(TIMEOUT):
+        await WaitForSingleObject(handle)
+
+    kernel32.CloseHandle(handle)
+    t1 = _core.current_time()
+    assert TIMEOUT <= (t1 - t0) < 2.0 * TIMEOUT
+    print("test_WaitForSingleObject_slow cancellation OK")

package/lib/site-packages/trio/_tests/test_windows_pipes.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+import pytest
+
+from .. import _core
+from ..testing import check_one_way_stream, wait_all_tasks_blocked
+
+# Mark all the tests in this file as being windows-only
+pytestmark = pytest.mark.skipif(sys.platform != "win32", reason="windows only")
+
+assert (  # Skip type checking when not on Windows
+    sys.platform == "win32" or not TYPE_CHECKING
+)
+
+if sys.platform == "win32":
+    from asyncio.windows_utils import pipe
+
+    from .._core._windows_cffi import _handle, kernel32
+    from .._windows_pipes import PipeReceiveStream, PipeSendStream
+
+
+async def make_pipe() -> tuple[PipeSendStream, PipeReceiveStream]:
+    """Makes a new pair of pipes."""
+    r, w = pipe()
+    return PipeSendStream(w), PipeReceiveStream(r)
+
+
+def test_pipe_typecheck() -> None:
+    with pytest.raises(TypeError):
+        PipeSendStream(1.0)  # type: ignore[arg-type]
+    with pytest.raises(TypeError):
+        PipeReceiveStream(None)  # type: ignore[arg-type]
+
+
+async def test_pipe_error_on_close() -> None:
+    # Make sure we correctly handle a failure from kernel32.CloseHandle
+    r, w = pipe()
+
+    send_stream = PipeSendStream(w)
+    receive_stream = PipeReceiveStream(r)
+
+    assert kernel32.CloseHandle(_handle(r))
+    assert kernel32.CloseHandle(_handle(w))
+
+    with pytest.raises(OSError, match=r"^\[WinError 6\] The handle is invalid$"):
+        await send_stream.aclose()
+    with pytest.raises(OSError, match=r"^\[WinError 6\] The handle is invalid$"):
+        await receive_stream.aclose()
+
+
+async def test_pipes_combined() -> None:
+    write, read = await make_pipe()
+    count = 2**20
+    replicas = 3
+
+    async def sender() -> None:
+        async with write:
+            big = bytearray(count)
+            for _ in range(replicas):
+                await write.send_all(big)
+
+    async def reader() -> None:
+        async with read:
+            await wait_all_tasks_blocked()
+            total_received = 0
+            while True:
+                # 5000 is chosen because it doesn't evenly divide 2**20
+                received = len(await read.receive_some(5000))
+                if not received:
+                    break
+                total_received += received
+
+            assert total_received == count * replicas
+
+    async with _core.open_nursery() as n:
+        n.start_soon(sender)
+        n.start_soon(reader)
+
+
+async def test_async_with() -> None:
+    w, r = await make_pipe()
+    async with w, r:
+        pass
+
+    with pytest.raises(_core.ClosedResourceError):
+        await w.send_all(b"")
+    with pytest.raises(_core.ClosedResourceError):
+        await r.receive_some(10)
+
+
+async def test_close_during_write() -> None:
+    w, _r = await make_pipe()
+    async with _core.open_nursery() as nursery:
+
+        async def write_forever() -> None:
+            with pytest.raises(_core.ClosedResourceError) as excinfo:
+                while True:
+                    await w.send_all(b"x" * 4096)
+            assert "another task" in str(excinfo.value)
+
+        nursery.start_soon(write_forever)
+        await wait_all_tasks_blocked(0.1)
+        await w.aclose()
+
+
+async def test_pipe_fully() -> None:
+    # passing make_clogged_pipe tests wait_send_all_might_not_block, and we
+    # can't implement that on Windows
+    await check_one_way_stream(make_pipe, None)