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

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

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Protocol, TypeVar
+
+import outcome
+import pytest
+
+import trio
+
+from .. import _core
+from .._core._tests.tutil import slow
+from .._timeouts import (
+    TooSlowError,
+    fail_after,
+    fail_at,
+    move_on_after,
+    move_on_at,
+    sleep,
+    sleep_forever,
+    sleep_until,
+)
+from ..testing import assert_checkpoints
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+T = TypeVar("T")
+
+
+async def check_takes_about(f: Callable[[], Awaitable[T]], expected_dur: float) -> T:
+    start = time.perf_counter()
+    result = await outcome.acapture(f)
+    dur = time.perf_counter() - start
+    print(dur / expected_dur)
+    # 1.5 is an arbitrary fudge factor because there's always some delay
+    # between when we become eligible to wake up and when we actually do. We
+    # used to sleep for 0.05, and regularly observed overruns of 1.6x on
+    # Appveyor, and then started seeing overruns of 2.3x on Travis's macOS, so
+    # now we bumped up the sleep to 1 second, marked the tests as slow, and
+    # hopefully now the proportional error will be less huge.
+    #
+    # We also also for durations that are a hair shorter than expected. For
+    # example, here's a run on Windows where a 1.0 second sleep was measured
+    # to take 0.9999999999999858 seconds:
+    #   https://ci.appveyor.com/project/njsmith/trio/build/1.0.768/job/3lbdyxl63q3h9s21
+    # I believe that what happened here is that Windows's low clock resolution
+    # meant that our calls to time.monotonic() returned exactly the same
+    # values as the calls inside the actual run loop, but the two subtractions
+    # returned slightly different values because the run loop's clock adds a
+    # random floating point offset to both times, which should cancel out, but
+    # lol floating point we got slightly different rounding errors. (That
+    # value above is exactly 128 ULPs below 1.0, which would make sense if it
+    # started as a 1 ULP error at a different dynamic range.)
+    assert (1 - 1e-8) <= (dur / expected_dur) < 1.5
+
+    return result.unwrap()
+
+
+# How long to (attempt to) sleep for when testing. Smaller numbers make the
+# test suite go faster.
+TARGET = 1.0
+
+
+@slow
+async def test_sleep() -> None:
+    async def sleep_1() -> None:
+        await sleep_until(_core.current_time() + TARGET)
+
+    await check_takes_about(sleep_1, TARGET)
+
+    async def sleep_2() -> None:
+        await sleep(TARGET)
+
+    await check_takes_about(sleep_2, TARGET)
+
+    with assert_checkpoints():
+        await sleep(0)
+    # This also serves as a test of the trivial move_on_at
+    with move_on_at(_core.current_time()):
+        with pytest.raises(_core.Cancelled):
+            await sleep(0)
+
+
+@slow
+async def test_move_on_after() -> None:
+    async def sleep_3() -> None:
+        with move_on_after(TARGET):
+            await sleep(100)
+
+    await check_takes_about(sleep_3, TARGET)
+
+
+async def test_cannot_wake_sleep_forever() -> None:
+    # Test an error occurs if you manually wake sleep_forever().
+    task = trio.lowlevel.current_task()
+
+    async def wake_task() -> None:
+        await trio.lowlevel.checkpoint()
+        trio.lowlevel.reschedule(task, outcome.Value(None))
+
+    async with trio.open_nursery() as nursery:
+        nursery.start_soon(wake_task)
+        with pytest.raises(RuntimeError):
+            await trio.sleep_forever()
+
+
+class TimeoutScope(Protocol):
+    def __call__(self, seconds: float, *, shield: bool) -> trio.CancelScope: ...
+
+
+@pytest.mark.parametrize("scope", [move_on_after, fail_after])
+async def test_context_shields_from_outer(scope: TimeoutScope) -> None:
+    with _core.CancelScope() as outer, scope(TARGET, shield=True) as inner:
+        outer.cancel()
+        try:
+            await trio.lowlevel.checkpoint()
+        except trio.Cancelled:  # pragma: no cover
+            pytest.fail("shield didn't work")
+        inner.shield = False
+        with pytest.raises(trio.Cancelled):
+            await trio.lowlevel.checkpoint()
+
+
+@slow
+async def test_move_on_after_moves_on_even_if_shielded() -> None:
+    async def task() -> None:
+        with _core.CancelScope() as outer, move_on_after(TARGET, shield=True):
+            outer.cancel()
+            # The outer scope is cancelled, but this task is protected by the
+            # shield, so it manages to get to sleep until deadline is met
+            await sleep_forever()
+
+    await check_takes_about(task, TARGET)
+
+
+@slow
+async def test_fail_after_fails_even_if_shielded() -> None:
+    async def task() -> None:
+        with (
+            pytest.raises(TooSlowError),
+            _core.CancelScope() as outer,
+            fail_after(
+                TARGET,
+                shield=True,
+            ),
+        ):
+            outer.cancel()
+            # The outer scope is cancelled, but this task is protected by the
+            # shield, so it manages to get to sleep until deadline is met
+            await sleep_forever()
+
+    await check_takes_about(task, TARGET)
+
+
+@slow
+async def test_fail() -> None:
+    async def sleep_4() -> None:
+        with fail_at(_core.current_time() + TARGET):
+            await sleep(100)
+
+    with pytest.raises(TooSlowError):
+        await check_takes_about(sleep_4, TARGET)
+
+    with fail_at(_core.current_time() + 100):
+        await sleep(0)
+
+    async def sleep_5() -> None:
+        with fail_after(TARGET):
+            await sleep(100)
+
+    with pytest.raises(TooSlowError):
+        await check_takes_about(sleep_5, TARGET)
+
+    with fail_after(100):
+        await sleep(0)
+
+
+async def test_timeouts_raise_value_error() -> None:
+    # deadlines are allowed to be negative, but not delays.
+    # neither delays nor deadlines are allowed to be NaN
+
+    nan = float("nan")
+
+    for fun, val in (
+        (sleep, -1),
+        (sleep, nan),
+        (sleep_until, nan),
+    ):
+        with pytest.raises(
+            ValueError,
+            match=r"^(deadline|`seconds`) must (not )*be (non-negative|NaN)$",
+        ):
+            await fun(val)
+
+    for cm, val in (
+        (fail_after, -1),
+        (fail_after, nan),
+        (fail_at, nan),
+        (move_on_after, -1),
+        (move_on_after, nan),
+        (move_on_at, nan),
+    ):
+        with pytest.raises(
+            ValueError,
+            match=r"^(deadline|`seconds`) must (not )*be (non-negative|NaN)$",
+        ):
+            with cm(val):
+                pass  # pragma: no cover
+
+
+async def test_timeout_deadline_on_entry(mock_clock: _core.MockClock) -> None:
+    rcs = move_on_after(5)
+    assert rcs.relative_deadline == 5
+
+    mock_clock.jump(3)
+    start = _core.current_time()
+    with rcs as cs:
+        assert cs.is_relative is None
+
+        # This would previously be start+2
+        assert cs.deadline == start + 5
+        assert cs.relative_deadline == 5
+
+        cs.deadline = start + 3
+        assert cs.deadline == start + 3
+        assert cs.relative_deadline == 3
+
+        cs.relative_deadline = 4
+        assert cs.deadline == start + 4
+        assert cs.relative_deadline == 4
+
+    rcs = move_on_after(5)
+    assert rcs.shield is False
+    rcs.shield = True
+    assert rcs.shield is True
+
+    mock_clock.jump(3)
+    start = _core.current_time()
+    with rcs as cs:
+        assert cs.deadline == start + 5
+
+        assert rcs is cs
+
+
+async def test_invalid_access_unentered(mock_clock: _core.MockClock) -> None:
+    cs = move_on_after(5)
+    mock_clock.jump(3)
+    start = _core.current_time()
+
+    match_str = "^unentered relative cancel scope does not have an absolute deadline"
+    with pytest.warns(DeprecationWarning, match=match_str):
+        assert cs.deadline == start + 5
+    mock_clock.jump(1)
+    # this is hella sketchy, but they *have* been warned
+    with pytest.warns(DeprecationWarning, match=match_str):
+        assert cs.deadline == start + 6
+
+    with pytest.warns(DeprecationWarning, match=match_str):
+        cs.deadline = 7
+    # now transformed into absolute
+    assert cs.deadline == 7
+    assert not cs.is_relative
+
+    cs = move_on_at(5)
+
+    match_str = (
+        "^unentered non-relative cancel scope does not have a relative deadline$"
+    )
+    with pytest.raises(RuntimeError, match=match_str):
+        assert cs.relative_deadline
+    with pytest.raises(RuntimeError, match=match_str):
+        cs.relative_deadline = 7
+
+
+@pytest.mark.xfail(reason="not implemented")
+async def test_fail_access_before_entering() -> None:  # pragma: no cover
+    my_fail_at = fail_at(5)
+    assert my_fail_at.deadline  # type: ignore[attr-defined]
+    my_fail_after = fail_after(5)
+    assert my_fail_after.relative_deadline  # type: ignore[attr-defined]

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

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import trio
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+
+async def coro1(event: trio.Event) -> None:
+    event.set()
+    await trio.sleep_forever()
+
+
+async def coro2(event: trio.Event) -> None:
+    await coro1(event)
+
+
+async def coro3(event: trio.Event) -> None:
+    await coro2(event)
+
+
+async def coro2_async_gen(event: trio.Event) -> AsyncGenerator[None, None]:
+    # mypy does not like `yield await trio.lowlevel.checkpoint()` - but that
+    # should be equivalent to splitting the statement
+    await trio.lowlevel.checkpoint()
+    yield
+    await coro1(event)
+    yield  # pragma: no cover
+    await trio.lowlevel.checkpoint()  # pragma: no cover
+    yield  # pragma: no cover
+
+
+async def coro3_async_gen(event: trio.Event) -> None:
+    async for _ in coro2_async_gen(event):
+        pass
+
+
+async def test_task_iter_await_frames() -> None:
+    async with trio.open_nursery() as nursery:
+        event = trio.Event()
+        nursery.start_soon(coro3, event)
+        await event.wait()
+
+        (task,) = nursery.child_tasks
+
+        assert [frame.f_code.co_name for frame, _ in task.iter_await_frames()][:3] == [
+            "coro3",
+            "coro2",
+            "coro1",
+        ]
+
+        nursery.cancel_scope.cancel()
+
+
+async def test_task_iter_await_frames_async_gen() -> None:
+    async with trio.open_nursery() as nursery:
+        event = trio.Event()
+        nursery.start_soon(coro3_async_gen, event)
+        await event.wait()
+
+        (task,) = nursery.child_tasks
+
+        assert [frame.f_code.co_name for frame, _ in task.iter_await_frames()][:3] == [
+            "coro3_async_gen",
+            "coro2_async_gen",
+            "coro1",
+        ]
+
+        nursery.cancel_scope.cancel()
+
+
+async def test_closed_task_iter_await_frames() -> None:
+    async with trio.open_nursery() as nursery:
+        task = object()
+
+        async def capture_task() -> None:
+            nonlocal task
+            task = trio.lowlevel.current_task()
+            await trio.lowlevel.checkpoint()
+
+        nursery.start_soon(capture_task)
+
+    # Task has completed, so coro.cr_frame should be None, thus no frames
+    assert isinstance(task, trio.lowlevel.Task)  # Ran `capture_task`
+    assert task.coro.cr_frame is None  # and the task was over, but
+    assert list(task.iter_await_frames()) == []  # look, no crash!

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

@@ -0,0 +1,8 @@
+def test_trio_import() -> None:
+    import sys
+
+    for module in list(sys.modules.keys()):
+        if module.startswith("trio"):
+            del sys.modules[module]
+
+    import trio  # noqa: F401

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

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import errno
+import os
+import select
+import sys
+from typing import TYPE_CHECKING
+
+import pytest
+
+from .. import _core
+from .._core._tests.tutil import gc_collect_harder, skip_if_fbsd_pipes_broken
+from ..testing import check_one_way_stream, wait_all_tasks_blocked
+
+if TYPE_CHECKING:
+    from .._file_io import _HasFileNo
+
+posix = os.name == "posix"
+pytestmark = pytest.mark.skipif(not posix, reason="posix only")
+
+assert not TYPE_CHECKING or sys.platform == "unix"
+
+if posix:
+    from .._unix_pipes import FdStream
+
+
+async def make_pipe() -> tuple[FdStream, FdStream]:
+    """Makes a new pair of pipes."""
+    r, w = os.pipe()
+    return FdStream(w), FdStream(r)
+
+
+async def make_clogged_pipe() -> tuple[FdStream, FdStream]:
+    s, r = await make_pipe()
+    try:
+        while True:
+            # We want to totally fill up the pipe buffer.
+            # This requires working around a weird feature that POSIX pipes
+            # have.
+            # If you do a write of <= PIPE_BUF bytes, then it's guaranteed
+            # to either complete entirely, or not at all. So if we tried to
+            # write PIPE_BUF bytes, and the buffer's free space is only
+            # PIPE_BUF/2, then the write will raise BlockingIOError... even
+            # though a smaller write could still succeed! To avoid this,
+            # make sure to write >PIPE_BUF bytes each time, which disables
+            # the special behavior.
+            # For details, search for PIPE_BUF here:
+            #   http://pubs.opengroup.org/onlinepubs/9699919799/functions/write.html
+
+            # for the getattr:
+            # https://bitbucket.org/pypy/pypy/issues/2876/selectpipe_buf-is-missing-on-pypy3
+            buf_size = getattr(select, "PIPE_BUF", 8192)
+            os.write(s.fileno(), b"x" * buf_size * 2)
+    except BlockingIOError:
+        pass
+    return s, r
+
+
+async def test_send_pipe() -> None:
+    r, w = os.pipe()
+    async with FdStream(w) as send:
+        assert send.fileno() == w
+        await send.send_all(b"123")
+        assert (os.read(r, 8)) == b"123"
+
+        os.close(r)
+
+
+async def test_receive_pipe() -> None:
+    r, w = os.pipe()
+    async with FdStream(r) as recv:
+        assert (recv.fileno()) == r
+        os.write(w, b"123")
+        assert (await recv.receive_some(8)) == b"123"
+
+        os.close(w)
+
+
+async def test_pipes_combined() -> None:
+    write, read = await make_pipe()
+    count = 2**20
+
+    async def sender() -> None:
+        big = bytearray(count)
+        await write.send_all(big)
+
+    async def reader() -> None:
+        await wait_all_tasks_blocked()
+        received = 0
+        while received < count:
+            received += len(await read.receive_some(4096))
+
+        assert received == count
+
+    async with _core.open_nursery() as n:
+        n.start_soon(sender)
+        n.start_soon(reader)
+
+    await read.aclose()
+    await write.aclose()
+
+
+async def test_pipe_errors() -> None:
+    with pytest.raises(TypeError):
+        FdStream(None)
+
+    r, w = os.pipe()
+    os.close(w)
+    async with FdStream(r) as s:
+        with pytest.raises(ValueError, match=r"^max_bytes must be integer >= 1$"):
+            await s.receive_some(0)
+
+
+async def test_del() -> None:
+    w, r = await make_pipe()
+    f1, f2 = w.fileno(), r.fileno()
+    del w, r
+    gc_collect_harder()
+
+    with pytest.raises(OSError, match=r"Bad file descriptor$") as excinfo:
+        os.close(f1)
+    assert excinfo.value.errno == errno.EBADF
+
+    with pytest.raises(OSError, match=r"Bad file descriptor$") as excinfo:
+        os.close(f2)
+    assert excinfo.value.errno == errno.EBADF
+
+
+async def test_async_with() -> None:
+    w, r = await make_pipe()
+    async with w, r:
+        pass
+
+    assert w.fileno() == -1
+    assert r.fileno() == -1
+
+    with pytest.raises(OSError, match=r"Bad file descriptor$") as excinfo:
+        os.close(w.fileno())
+    assert excinfo.value.errno == errno.EBADF
+
+    with pytest.raises(OSError, match=r"Bad file descriptor$") as excinfo:
+        os.close(r.fileno())
+    assert excinfo.value.errno == errno.EBADF
+
+
+async def test_misdirected_aclose_regression() -> None:
+    # https://github.com/python-trio/trio/issues/661#issuecomment-456582356
+    w, r = await make_pipe()
+    old_r_fd = r.fileno()
+
+    # Close the original objects
+    await w.aclose()
+    await r.aclose()
+
+    # Do a little dance to get a new pipe whose receive handle matches the old
+    # receive handle.
+    r2_fd, w2_fd = os.pipe()
+    if r2_fd != old_r_fd:  # pragma: no cover
+        os.dup2(r2_fd, old_r_fd)
+        os.close(r2_fd)
+    async with FdStream(old_r_fd) as r2:
+        assert r2.fileno() == old_r_fd
+
+        # And now set up a background task that's working on the new receive
+        # handle
+        async def expect_eof() -> None:
+            assert await r2.receive_some(10) == b""
+
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(expect_eof)
+            await wait_all_tasks_blocked()
+
+            # Here's the key test: does calling aclose() again on the *old*
+            # handle, cause the task blocked on the *new* handle to raise
+            # ClosedResourceError?
+            await r.aclose()
+            await wait_all_tasks_blocked()
+
+            # Guess we survived! Close the new write handle so that the task
+            # gets an EOF and can exit cleanly.
+            os.close(w2_fd)
+
+
+async def test_close_at_bad_time_for_receive_some(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # We used to have race conditions where if one task was using the pipe,
+    # and another closed it at *just* the wrong moment, it would give an
+    # unexpected error instead of ClosedResourceError:
+    # https://github.com/python-trio/trio/issues/661
+    #
+    # This tests what happens if the pipe gets closed in the moment *between*
+    # when receive_some wakes up, and when it tries to call os.read
+    async def expect_closedresourceerror() -> None:
+        with pytest.raises(_core.ClosedResourceError):
+            await r.receive_some(10)
+
+    orig_wait_readable = _core._run.TheIOManager.wait_readable
+
+    async def patched_wait_readable(
+        self: _core._run.TheIOManager,
+        fd: int | _HasFileNo,
+    ) -> None:
+        await orig_wait_readable(self, fd)
+        await r.aclose()
+
+    monkeypatch.setattr(_core._run.TheIOManager, "wait_readable", patched_wait_readable)
+    s, r = await make_pipe()
+    async with s, r:
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(expect_closedresourceerror)
+            await wait_all_tasks_blocked()
+            # Trigger everything by waking up the receiver
+            await s.send_all(b"x")
+
+
+async def test_close_at_bad_time_for_send_all(monkeypatch: pytest.MonkeyPatch) -> None:
+    # We used to have race conditions where if one task was using the pipe,
+    # and another closed it at *just* the wrong moment, it would give an
+    # unexpected error instead of ClosedResourceError:
+    # https://github.com/python-trio/trio/issues/661
+    #
+    # This tests what happens if the pipe gets closed in the moment *between*
+    # when send_all wakes up, and when it tries to call os.write
+    async def expect_closedresourceerror() -> None:
+        with pytest.raises(_core.ClosedResourceError):
+            await s.send_all(b"x" * 100)
+
+    orig_wait_writable = _core._run.TheIOManager.wait_writable
+
+    async def patched_wait_writable(
+        self: _core._run.TheIOManager,
+        fd: int | _HasFileNo,
+    ) -> None:
+        await orig_wait_writable(self, fd)
+        await s.aclose()
+
+    monkeypatch.setattr(_core._run.TheIOManager, "wait_writable", patched_wait_writable)
+    s, r = await make_clogged_pipe()
+    async with s, r:
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(expect_closedresourceerror)
+            await wait_all_tasks_blocked()
+            # Trigger everything by waking up the sender. On ppc64el, PIPE_BUF
+            # is 8192 but make_clogged_pipe() ends up writing a total of
+            # 1048576 bytes before the pipe is full, and then a subsequent
+            # receive_some(10000) isn't sufficient for orig_wait_writable() to
+            # return for our subsequent aclose() call. It's necessary to empty
+            # the pipe further before this happens. So we loop here until the
+            # pipe is empty to make sure that the sender wakes up even in this
+            # case. Otherwise patched_wait_writable() never gets to the
+            # aclose(), so expect_closedresourceerror() never returns, the
+            # nursery never finishes all tasks and this test hangs.
+            received_data = await r.receive_some(10000)
+            while received_data:
+                received_data = await r.receive_some(10000)
+
+
+# On FreeBSD, directories are readable, and we haven't found any other trick
+# for making an unreadable fd, so there's no way to run this test. Fortunately
+# the logic this is testing doesn't depend on the platform, so testing on
+# other platforms is probably good enough.
+@pytest.mark.skipif(
+    sys.platform.startswith("freebsd"),
+    reason="no way to make read() return a bizarro error on FreeBSD",
+)
+async def test_bizarro_OSError_from_receive() -> None:
+    # Make sure that if the read syscall returns some bizarro error, then we
+    # get a BrokenResourceError. This is incredibly unlikely; there's almost
+    # no way to trigger a failure here intentionally (except for EBADF, but we
+    # exploit that to detect file closure, so it takes a different path). So
+    # we set up a strange scenario where the pipe fd somehow transmutes into a
+    # directory fd, causing os.read to raise IsADirectoryError (yes, that's a
+    # real built-in exception type).
+    s, r = await make_pipe()
+    async with s, r:
+        dir_fd = os.open("/", os.O_DIRECTORY, 0)
+        try:
+            os.dup2(dir_fd, r.fileno())
+            with pytest.raises(_core.BrokenResourceError):
+                await r.receive_some(10)
+        finally:
+            os.close(dir_fd)
+
+
+@skip_if_fbsd_pipes_broken
+async def test_pipe_fully() -> None:
+    await check_one_way_stream(make_pipe, make_clogged_pipe)