@zigc/lib 0.16.0-test.1 → 0.17.0-dev.131

package/std/Io.zig

@@ -243,8 +243,6 @@ pub const VTable = struct {
     netConnectUnix: *const fn (?*anyopaque, *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle,
     netSocketCreatePair: *const fn (?*anyopaque, net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket,
     netSend: *const fn (?*anyopaque, net.Socket.Handle, []net.OutgoingMessage, net.SendFlags) struct { ?net.Socket.SendError, usize },
-    /// Returns 0 on end of stream.
-    netRead: *const fn (?*anyopaque, src: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize,
     netWrite: *const fn (?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize,
     netWriteFile: *const fn (?*anyopaque, net.Socket.Handle, header: []const u8, *Io.File.Reader, Io.Limit) net.Stream.Writer.WriteFileError!usize,
     netClose: *const fn (?*anyopaque, handle: []const net.Socket.Handle) void,
@@ -261,6 +259,7 @@ pub const Operation = union(enum) {
     /// other systems this tag is unreachable.
     device_io_control: DeviceIoControl,
     net_receive: NetReceive,
+    net_read: NetRead,
 
     pub const Tag = @typeInfo(Operation).@"union".tag_type.?;
 
@@ -374,11 +373,35 @@ pub const Operation = union(enum) {
             ConnectionResetByPeer,
             /// The local network interface used to reach the destination is offline.
             NetworkDown,
+            /// A connectionless packet was previously sent successfully,
+            /// however, it was not received because no service is operating at
+            /// the destination port of the transport on the remote system.
+            /// This caused an ICMP port unreachable packet to be returned to
+            /// the OS where it was queued up to be reported at the next call
+            /// to send or receive on the bound socket.
+            PortUnreachable,
         } || Io.UnexpectedError;
 
         pub const Result = struct { ?net.Socket.ReceiveError, usize };
     };
 
+    pub const NetRead = struct {
+        socket_handle: net.Socket.Handle,
+        data: [][]u8,
+
+        pub const Error = error{
+            SystemResources,
+            ConnectionResetByPeer,
+            SocketUnconnected,
+            /// The file descriptor does not hold the required rights to read
+            /// from it.
+            AccessDenied,
+            NetworkDown,
+        } || Io.UnexpectedError;
+
+        pub const Result = Error!usize;
+    };
+
     pub const Result = Result: {
         const operation_fields = @typeInfo(Operation).@"union".fields;
         var field_names: [operation_fields.len][]const u8 = undefined;
@@ -500,8 +523,8 @@ pub const Batch = struct {
     /// Returns the index that will be returned by `next` after the operation completes.
     /// Asserts that no more than `storage.len` operations are active at a time.
     pub fn add(batch: *Batch, operation: Operation) u32 {
-        const index = batch.unused.next;
-        batch.addAt(index.toIndex(), operation);
+        const index = batch.unused.head.toIndex();
+        batch.addAt(index, operation);
         return index;
     }
 
@@ -867,7 +890,7 @@ pub const Clock = enum {
             if (t.clock == clock) return t;
             const now_old = t.clock.now(io);
             const now_new = clock.now(io);
-            const duration = now_old.durationTo(t);
+            const duration = now_old.durationTo(t.raw);
             return .{
                 .clock = clock,
                 .raw = now_new.addDuration(duration),
@@ -1658,20 +1681,29 @@ pub const Condition = struct {
         .epoch = .init(0),
     };
 
+    /// Blocks until the condition is signaled or canceled.
+    ///
+    /// See also:
+    /// * `waitUncancelable`
+    /// * `waitTimeout`
     pub fn wait(cond: *Condition, io: Io, mutex: *Mutex) Cancelable!void {
-        try waitInner(cond, io, mutex, false);
+        waitTimeout(cond, io, mutex, .none) catch |err| switch (err) {
+            error.Timeout => unreachable,
+            error.Canceled => |e| return e,
+        };
     }
 
-    /// Same as `wait`, except does not introduce a cancelation point.
+    pub const WaitTimeoutError = Cancelable || Timeout.Error;
+
+    /// Blocks until the condition is signaled, canceled, or the provided
+    /// timeout expires.
     ///
-    /// For a description of cancelation and cancelation points, see `Future.cancel`.
-    pub fn waitUncancelable(cond: *Condition, io: Io, mutex: *Mutex) void {
-        waitInner(cond, io, mutex, true) catch |err| switch (err) {
-            error.Canceled => unreachable,
-        };
-    }
+    /// See also:
+    /// * `wait`
+    /// * `waitUncancelable`
+    pub fn waitTimeout(cond: *Condition, io: Io, mutex: *Mutex, timeout: Timeout) WaitTimeoutError!void {
+        const deadline = timeout.toDeadline(io);
 
-    fn waitInner(cond: *Condition, io: Io, mutex: *Mutex, uncancelable: bool) Cancelable!void {
         var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
 
         {
@@ -1683,10 +1715,7 @@ pub const Condition = struct {
         defer mutex.lockUncancelable(io);
 
         while (true) {
-            const result = if (uncancelable)
-                io.futexWaitUncancelable(u32, &cond.epoch.raw, epoch)
-            else
-                io.futexWait(u32, &cond.epoch.raw, epoch);
+            const result = io.futexWaitTimeout(u32, &cond.epoch.raw, epoch, deadline);
 
             epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before `state` laod
 
@@ -1706,13 +1735,62 @@ pub const Condition = struct {
             }
 
             // There are no more signals available; this was a spurious wakeup or an error. If it
-            // was an error, we will remove ourselves as a waiter and return that error. Otherwise,
-            // we'll loop back to the futex wait.
+            // was an error, we will remove ourselves as a waiter and return that error. If a
+            // timeout was specified and the deadline has passed, we remove ourselves as a waiter
+            // and return `error.Timeout`. Otherwise, we'll loop back to the futex wait.
             result catch |err| {
                 const prev_state = cond.state.fetchSub(.{ .waiters = 1, .signals = 0 }, .monotonic);
                 assert(prev_state.waiters > 0); // underflow caused by illegal state
                 return err;
             };
+            switch (deadline) {
+                .none => {},
+                .deadline => |d| if (d.untilNow(io).raw.nanoseconds >= 0) {
+                    const prev_state = cond.state.fetchSub(.{ .waiters = 1, .signals = 0 }, .monotonic);
+                    assert(prev_state.waiters > 0); // underflow caused by illegal state
+                    return error.Timeout;
+                },
+                .duration => unreachable,
+            }
+        }
+    }
+
+    /// Same as `wait`, except does not introduce a cancelation point.
+    ///
+    /// See `Future.cancel` for a description of cancelation points.
+    pub fn waitUncancelable(cond: *Condition, io: Io, mutex: *Mutex) void {
+        var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
+
+        {
+            const prev_state = cond.state.fetchAdd(.{ .waiters = 1, .signals = 0 }, .monotonic);
+            assert(prev_state.waiters < math.maxInt(u16)); // overflow caused by too many waiters
+        }
+
+        mutex.unlock(io);
+        defer mutex.lockUncancelable(io);
+
+        while (true) {
+            io.futexWaitUncancelable(u32, &cond.epoch.raw, epoch);
+
+            epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before `state` laod
+
+            // Even on error, try to consume a pending signal first. Otherwise a race might
+            // cause a signal to get stuck in the state with no corresponding waiter.
+            {
+                var prev_state = cond.state.load(.monotonic);
+                while (prev_state.signals > 0) {
+                    prev_state = cond.state.cmpxchgWeak(prev_state, .{
+                        .waiters = prev_state.waiters - 1,
+                        .signals = prev_state.signals - 1,
+                    }, .acquire, .monotonic) orelse {
+                        // We successfully consumed a signal.
+                        return;
+                    };
+                }
+            }
+
+            // There are no more signals available; this was a spurious wakeup,
+            // so we'll loop back to the futex wait.
         }
     }
 
@@ -2491,3 +2569,957 @@ test {
     _ = Semaphore;
     _ = @import("Io/test.zig");
 }
+
+/// An implementation of `Io` which simulates a system supporting no `Io` operations.
+///
+/// This system has the following properties:
+/// * Concurrency is unavailable.
+/// * The stdio handles are pipes whose remote ends are already closed.
+/// * The filesystem is entirely empty, including that the cwd is no longer present.
+/// * The filesystem is full, so attempting to create entries always returns `error.NoSpaceLeft`.
+/// * No entropy source is supported, so `randomSecure` always returns `error.EntropyUnavailable`, and `random` always returns (fills the buffer) with 0.
+/// * No clocks are supported, so `now` and `sleep` always return `error.UnsupportedClock`.
+/// * No network is connected, so network operations always return `error.NetworkDown`.
+pub const failing: std.Io = .{
+    .userdata = null,
+    .vtable = &.{
+        .crashHandler = noCrashHandler,
+
+        .async = noAsync,
+        .concurrent = failingConcurrent,
+        .await = unreachableAwait,
+        .cancel = unreachableCancel,
+
+        .groupAsync = noGroupAsync,
+        .groupConcurrent = failingGroupConcurrent,
+        .groupAwait = unreachableGroupAwait,
+        .groupCancel = unreachableGroupCancel,
+
+        .recancel = unreachableRecancel,
+        .swapCancelProtection = unreachableSwapCancelProtection,
+        .checkCancel = unreachableCheckCancel,
+
+        .futexWait = noFutexWait,
+        .futexWaitUncancelable = noFutexWaitUncancelable,
+        .futexWake = noFutexWake,
+
+        .operate = failingOperate,
+        .batchAwaitAsync = unreachableBatchAwaitAsync,
+        .batchAwaitConcurrent = unreachableBatchAwaitConcurrent,
+        .batchCancel = unreachableBatchCancel,
+
+        .dirCreateDir = failingDirCreateDir,
+        .dirCreateDirPath = failingDirCreateDirPath,
+        .dirCreateDirPathOpen = failingDirCreateDirPathOpen,
+        .dirOpenDir = failingDirOpenDir,
+        .dirStat = failingDirStat,
+        .dirStatFile = failingDirStatFile,
+        .dirAccess = failingDirAccess,
+        .dirCreateFile = failingDirCreateFile,
+        .dirCreateFileAtomic = failingDirCreateFileAtomic,
+        .dirOpenFile = failingDirOpenFile,
+        .dirClose = unreachableDirClose,
+        .dirRead = noDirRead,
+        .dirRealPath = failingDirRealPath,
+        .dirRealPathFile = failingDirRealPathFile,
+        .dirDeleteFile = failingDirDeleteFile,
+        .dirDeleteDir = failingDirDeleteDir,
+        .dirRename = failingDirRename,
+        .dirRenamePreserve = failingDirRenamePreserve,
+        .dirSymLink = failingDirSymLink,
+        .dirReadLink = failingDirReadLink,
+        .dirSetOwner = failingDirSetOwner,
+        .dirSetFileOwner = failingDirSetFileOwner,
+        .dirSetPermissions = failingDirSetPermissions,
+        .dirSetFilePermissions = failingDirSetFilePermissions,
+        .dirSetTimestamps = noDirSetTimestamps,
+        .dirHardLink = failingDirHardLink,
+
+        .fileStat = failingFileStat,
+        .fileLength = failingFileLength,
+        .fileClose = unreachableFileClose,
+        .fileWritePositional = failingFileWritePositional,
+        .fileWriteFileStreaming = noFileWriteFileStreaming,
+        .fileWriteFilePositional = noFileWriteFilePositional,
+        .fileReadPositional = failingFileReadPositional,
+        .fileSeekBy = failingFileSeekBy,
+        .fileSeekTo = failingFileSeekTo,
+        .fileSync = failingFileSync,
+        .fileIsTty = unreachableFileIsTty,
+        .fileEnableAnsiEscapeCodes = unreachableFileEnableAnsiEscapeCodes,
+        .fileSupportsAnsiEscapeCodes = unreachableFileSupportsAnsiEscapeCodes,
+        .fileSetLength = failingFileSetLength,
+        .fileSetOwner = failingFileSetOwner,
+        .fileSetPermissions = failingFileSetPermissions,
+        .fileSetTimestamps = noFileSetTimestamps,
+        .fileLock = failingFileLock,
+        .fileTryLock = failingFileTryLock,
+        .fileUnlock = unreachableFileUnlock,
+        .fileDowngradeLock = failingFileDowngradeLock,
+        .fileRealPath = failingFileRealPath,
+        .fileHardLink = failingFileHardLink,
+
+        .fileMemoryMapCreate = failingFileMemoryMapCreate,
+        .fileMemoryMapDestroy = unreachableFileMemoryMapDestroy,
+        .fileMemoryMapSetLength = unreachableFileMemoryMapSetLength,
+        .fileMemoryMapRead = unreachableFileMemoryMapRead,
+        .fileMemoryMapWrite = unreachableFileMemoryMapWrite,
+
+        .processExecutableOpen = failingProcessExecutableOpen,
+        .processExecutablePath = failingProcessExecutablePath,
+        .lockStderr = unreachableLockStderr,
+        .tryLockStderr = noTryLockStderr,
+        .unlockStderr = unreachableUnlockStderr,
+        .processCurrentPath = failingProcessCurrentPath,
+        .processSetCurrentDir = failingProcessSetCurrentDir,
+        .processSetCurrentPath = failingProcessSetCurrentPath,
+        .processReplace = failingProcessReplace,
+        .processReplacePath = failingProcessReplacePath,
+        .processSpawn = failingProcessSpawn,
+        .processSpawnPath = failingProcessSpawnPath,
+        .childWait = unreachableChildWait,
+        .childKill = unreachableChildKill,
+
+        .progressParentFile = failingProgressParentFile,
+
+        .random = noRandom,
+        .randomSecure = failingRandomSecure,
+
+        .now = noNow,
+        .clockResolution = failingClockResolution,
+        .sleep = noSleep,
+
+        .netListenIp = failingNetListenIp,
+        .netAccept = failingNetAccept,
+        .netBindIp = failingNetBindIp,
+        .netConnectIp = failingNetConnectIp,
+        .netListenUnix = failingNetListenUnix,
+        .netConnectUnix = failingNetConnectUnix,
+        .netSocketCreatePair = failingNetSocketCreatePair,
+        .netSend = failingNetSend,
+        .netWrite = failingNetWrite,
+        .netWriteFile = failingNetWriteFile,
+        .netClose = unreachableNetClose,
+        .netShutdown = failingNetShutdown,
+        .netInterfaceNameResolve = failingNetInterfaceNameResolve,
+        .netInterfaceName = unreachableNetInterfaceName,
+        .netLookup = failingNetLookup,
+    },
+};
+
+pub fn noCrashHandler(userdata: ?*anyopaque) void {
+    _ = userdata;
+}
+
+pub fn noAsync(userdata: ?*anyopaque, result: []u8, result_alignment: std.mem.Alignment, context: []const u8, context_alignment: std.mem.Alignment, start: *const fn (context: *const anyopaque, result: *anyopaque) void) ?*AnyFuture {
+    _ = userdata;
+    _ = result_alignment;
+    _ = context_alignment;
+    start(context.ptr, result.ptr);
+    return null;
+}
+
+pub fn failingConcurrent(
+    userdata: ?*anyopaque,
+    result_len: usize,
+    result_alignment: std.mem.Alignment,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+) ConcurrentError!*AnyFuture {
+    _ = userdata;
+    _ = result_len;
+    _ = result_alignment;
+    _ = context;
+    _ = context_alignment;
+    _ = start;
+    return error.ConcurrencyUnavailable;
+}
+
+pub fn unreachableAwait(
+    userdata: ?*anyopaque,
+    any_future: *AnyFuture,
+    result: []u8,
+    result_alignment: std.mem.Alignment,
+) void {
+    _ = userdata;
+    _ = any_future;
+    _ = result;
+    _ = result_alignment;
+    unreachable;
+}
+
+pub fn unreachableCancel(
+    userdata: ?*anyopaque,
+    any_future: *AnyFuture,
+    result: []u8,
+    result_alignment: std.mem.Alignment,
+) void {
+    _ = userdata;
+    _ = any_future;
+    _ = result;
+    _ = result_alignment;
+    unreachable;
+}
+
+pub fn noGroupAsync(
+    userdata: ?*anyopaque,
+    group: *Group,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque) void,
+) void {
+    _ = userdata;
+    _ = group;
+    _ = context_alignment;
+    start(context.ptr);
+}
+
+pub fn failingGroupConcurrent(
+    userdata: ?*anyopaque,
+    group: *Group,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque) void,
+) ConcurrentError!void {
+    _ = userdata;
+    _ = group;
+    _ = context;
+    _ = context_alignment;
+    _ = start;
+    return error.ConcurrencyUnavailable;
+}
+
+pub fn unreachableGroupAwait(userdata: ?*anyopaque, group: *Group, token: *anyopaque) Cancelable!void {
+    _ = userdata;
+    _ = group;
+    _ = token;
+    unreachable;
+}
+
+pub fn unreachableGroupCancel(userdata: ?*anyopaque, group: *Group, token: *anyopaque) void {
+    _ = userdata;
+    _ = group;
+    _ = token;
+    unreachable;
+}
+
+pub fn unreachableRecancel(userdata: ?*anyopaque) void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn unreachableSwapCancelProtection(userdata: ?*anyopaque, new: CancelProtection) CancelProtection {
+    _ = userdata;
+    _ = new;
+    unreachable;
+}
+
+pub fn unreachableCheckCancel(userdata: ?*anyopaque) Cancelable!void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn noFutexWait(userdata: ?*anyopaque, ptr: *const u32, expected: u32, timeout: Timeout) Cancelable!void {
+    _ = userdata;
+    std.debug.assert(ptr.* == expected or timeout != .none);
+}
+
+pub fn noFutexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void {
+    _ = userdata;
+    std.debug.assert(ptr.* == expected);
+}
+
+pub fn noFutexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
+    _ = userdata;
+    _ = ptr;
+    _ = max_waiters;
+    // no-op
+}
+
+pub fn failingOperate(userdata: ?*anyopaque, operation: Operation) Cancelable!Operation.Result {
+    _ = userdata;
+    return switch (operation) {
+        .file_read_streaming => .{ .file_read_streaming = error.InputOutput },
+        .file_write_streaming => .{ .file_write_streaming = error.InputOutput },
+        .device_io_control => unreachable,
+        .net_receive => .{ .net_receive = .{ error.NetworkDown, 0 } },
+        .net_read => .{ .net_read = error.NetworkDown },
+    };
+}
+
+pub fn unreachableBatchAwaitAsync(userdata: ?*anyopaque, b: *Batch) Cancelable!void {
+    _ = userdata;
+    _ = b;
+    unreachable;
+}
+
+pub fn unreachableBatchAwaitConcurrent(userdata: ?*anyopaque, b: *Batch, timeout: Timeout) Batch.AwaitConcurrentError!void {
+    _ = userdata;
+    _ = b;
+    _ = timeout;
+    unreachable;
+}
+
+pub fn unreachableBatchCancel(userdata: ?*anyopaque, b: *Batch) void {
+    _ = userdata;
+    _ = b;
+    unreachable;
+}
+
+pub fn failingDirCreateDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateDirPath(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateDirPathOpen(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions, options: Dir.OpenOptions) Dir.CreateDirPathOpenError!Dir {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirOpenDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.OpenOptions) Dir.OpenError!Dir {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
+    _ = userdata;
+    _ = dir;
+    return error.Streaming;
+}
+
+pub fn failingDirStatFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.StatFileOptions) Dir.StatFileError!File.Stat {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirAccess(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.AccessOptions) Dir.AccessError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: File.CreateFlags) File.OpenError!File {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateFileAtomic(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.CreateFileAtomicOptions) Dir.CreateFileAtomicError!File.Atomic {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn unreachableDirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
+    _ = userdata;
+    _ = dirs;
+    unreachable;
+}
+
+pub fn noDirRead(userdata: ?*anyopaque, dir_reader: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize {
+    _ = userdata;
+    _ = dir_reader;
+    _ = buffer;
+    return 0;
+}
+
+pub fn failingDirRealPath(userdata: ?*anyopaque, dir: Dir, out_buffer: []u8) Dir.RealPathError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRealPathFile(userdata: ?*anyopaque, dir: Dir, path_name: []const u8, out_buffer: []u8) Dir.RealPathFileError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = path_name;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirDeleteDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteDirError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRename(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8) Dir.RenameError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRenamePreserve(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8) Dir.RenamePreserveError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSymLink(userdata: ?*anyopaque, dir: Dir, target_path: []const u8, sym_link_path: []const u8, flags: Dir.SymLinkFlags) Dir.SymLinkError!void {
+    _ = userdata;
+    _ = dir;
+    _ = target_path;
+    _ = sym_link_path;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn failingDirReadLink(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetOwner(userdata: ?*anyopaque, dir: Dir, owner: ?File.Uid, group: ?File.Gid) Dir.SetOwnerError!void {
+    _ = userdata;
+    _ = dir;
+    _ = owner;
+    _ = group;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetFileOwner(userdata: ?*anyopaque, dir: std.Io.Dir, sub_path: []const u8, owner: ?File.Uid, group: ?File.Gid, options: Dir.SetFileOwnerOptions) Dir.SetFileOwnerError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = owner;
+    _ = group;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetPermissions(userdata: ?*anyopaque, dir: Dir, permissions: Dir.Permissions) Dir.SetPermissionsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = permissions;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetFilePermissions(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: File.Permissions, options: Dir.SetFilePermissionsOptions) Dir.SetFilePermissionsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn noDirSetTimestamps(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.SetTimestampsOptions) Dir.SetTimestampsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    // no-op
+}
+
+pub fn failingDirHardLink(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8, options: Dir.HardLinkOptions) Dir.HardLinkError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingFileStat(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
+    _ = userdata;
+    _ = file;
+    return error.Streaming;
+}
+
+pub fn failingFileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64 {
+    _ = userdata;
+    _ = file;
+    return error.Streaming;
+}
+
+pub fn unreachableFileClose(userdata: ?*anyopaque, files: []const File) void {
+    _ = userdata;
+    _ = files;
+    unreachable;
+}
+
+pub fn failingFileWritePositional(userdata: ?*anyopaque, file: File, header: []const u8, data: []const []const u8, splat: usize, offset: u64) File.WritePositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = offset;
+    for (data[0 .. data.len - 1]) |item| {
+        if (item.len > 0) return error.BrokenPipe;
+    }
+    if (data[data.len - 1].len != 0 and splat != 0) return error.BrokenPipe;
+    return 0;
+}
+
+pub fn noFileWriteFileStreaming(userdata: ?*anyopaque, file: File, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit) File.Writer.WriteFileError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.Unimplemented;
+}
+
+pub fn noFileWriteFilePositional(userdata: ?*anyopaque, file: File, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit, offset: u64) File.WriteFilePositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    _ = offset;
+    return error.Unimplemented;
+}
+
+pub fn failingFileReadPositional(userdata: ?*anyopaque, file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = offset;
+    for (data) |item| {
+        if (item.len > 0) return error.InputOutput;
+    }
+    return 0;
+}
+
+pub fn failingFileSeekBy(userdata: ?*anyopaque, file: File, relative_offset: i64) File.SeekError!void {
+    _ = userdata;
+    _ = file;
+    _ = relative_offset;
+    return error.Unseekable;
+}
+
+pub fn failingFileSeekTo(userdata: ?*anyopaque, file: File, absolute_offset: u64) File.SeekError!void {
+    _ = userdata;
+    _ = file;
+    _ = absolute_offset;
+    return error.Unseekable;
+}
+
+pub fn failingFileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
+    _ = userdata;
+    _ = file;
+    return error.NoSpaceLeft;
+}
+
+pub fn unreachableFileIsTty(userdata: ?*anyopaque, file: File) Cancelable!bool {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn unreachableFileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn unreachableFileSupportsAnsiEscapeCodes(userdata: ?*anyopaque, file: File) Cancelable!bool {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn failingFileSetLength(userdata: ?*anyopaque, file: File, length: u64) File.SetLengthError!void {
+    _ = userdata;
+    _ = file;
+    _ = length;
+    return error.NonResizable;
+}
+
+pub fn failingFileSetOwner(userdata: ?*anyopaque, file: File, owner: ?File.Uid, group: ?File.Gid) File.SetOwnerError!void {
+    _ = userdata;
+    _ = file;
+    _ = owner;
+    _ = group;
+    return error.FileNotFound;
+}
+
+pub fn failingFileSetPermissions(userdata: ?*anyopaque, file: File, permissions: File.Permissions) File.SetPermissionsError!void {
+    _ = userdata;
+    _ = file;
+    _ = permissions;
+    return error.FileNotFound;
+}
+
+pub fn noFileSetTimestamps(userdata: ?*anyopaque, file: File, options: File.SetTimestampsOptions) File.SetTimestampsError!void {
+    _ = userdata;
+    _ = file;
+    _ = options;
+    // no-op
+}
+
+pub fn failingFileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!void {
+    _ = userdata;
+    _ = file;
+    _ = lock;
+    return error.FileLocksUnsupported;
+}
+
+pub fn failingFileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!bool {
+    _ = userdata;
+    _ = file;
+    _ = lock;
+    return error.FileLocksUnsupported;
+}
+
+pub fn unreachableFileUnlock(userdata: ?*anyopaque, file: File) void {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn failingFileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!void {
+    _ = userdata;
+    _ = file;
+    // no-op
+}
+
+pub fn failingFileRealPath(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.RealPathError!usize {
+    _ = userdata;
+    _ = file;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingFileHardLink(userdata: ?*anyopaque, file: File, new_dir: Dir, new_sub_path: []const u8, options: File.HardLinkOptions) File.HardLinkError!void {
+    _ = userdata;
+    _ = file;
+    _ = new_dir;
+    _ = new_sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingFileMemoryMapCreate(userdata: ?*anyopaque, file: File, options: File.MemoryMap.CreateOptions) File.MemoryMap.CreateError!File.MemoryMap {
+    _ = userdata;
+    _ = file;
+    _ = options;
+    return error.AccessDenied;
+}
+
+pub fn unreachableFileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapSetLength(userdata: ?*anyopaque, mm: *File.MemoryMap, new_len: usize) File.MemoryMap.SetLengthError!void {
+    _ = userdata;
+    _ = mm;
+    _ = new_len;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn failingProcessExecutableOpen(userdata: ?*anyopaque, flags: File.OpenFlags) std.process.OpenExecutableError!File {
+    _ = userdata;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessExecutablePath(userdata: ?*anyopaque, buffer: []u8) std.process.ExecutablePathError!usize {
+    _ = userdata;
+    _ = buffer;
+    return error.FileNotFound;
+}
+
+pub fn unreachableLockStderr(userdata: ?*anyopaque, terminal_mode: ?Terminal.Mode) Cancelable!LockedStderr {
+    _ = userdata;
+    _ = terminal_mode;
+    unreachable;
+}
+
+pub fn noTryLockStderr(userdata: ?*anyopaque, terminal_mode: ?Terminal.Mode) Cancelable!?LockedStderr {
+    _ = userdata;
+    _ = terminal_mode;
+    return null;
+}
+
+pub fn unreachableUnlockStderr(userdata: ?*anyopaque) void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn failingProcessCurrentPath(userdata: ?*anyopaque, buffer: []u8) std.process.CurrentPathError!usize {
+    _ = userdata;
+    _ = buffer;
+    return error.CurrentDirUnlinked;
+}
+
+pub fn failingProcessSetCurrentDir(userdata: ?*anyopaque, dir: Dir) std.process.SetCurrentDirError!void {
+    _ = userdata;
+    _ = dir;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessSetCurrentPath(userdata: ?*anyopaque, path: []const u8) std.process.SetCurrentPathError!void {
+    _ = userdata;
+    _ = path;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessReplace(userdata: ?*anyopaque, options: std.process.ReplaceOptions) std.process.ReplaceError {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessReplacePath(userdata: ?*anyopaque, dir: Dir, options: std.process.ReplaceOptions) std.process.ReplaceError {
+    _ = userdata;
+    _ = dir;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessSpawn(userdata: ?*anyopaque, options: std.process.SpawnOptions) std.process.SpawnError!std.process.Child {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessSpawnPath(userdata: ?*anyopaque, dir: Dir, options: std.process.SpawnOptions) std.process.SpawnError!std.process.Child {
+    _ = userdata;
+    _ = dir;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn unreachableChildWait(userdata: ?*anyopaque, child: *std.process.Child) std.process.Child.WaitError!std.process.Child.Term {
+    _ = userdata;
+    _ = child;
+    unreachable;
+}
+
+pub fn unreachableChildKill(userdata: ?*anyopaque, child: *std.process.Child) void {
+    _ = userdata;
+    _ = child;
+    unreachable;
+}
+
+pub fn failingProgressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
+    _ = userdata;
+    return error.UnsupportedOperation;
+}
+
+pub fn noRandom(userdata: ?*anyopaque, buffer: []u8) void {
+    _ = userdata;
+    @memset(buffer, 0);
+}
+
+pub fn failingRandomSecure(userdata: ?*anyopaque, buffer: []u8) RandomSecureError!void {
+    _ = userdata;
+    _ = buffer;
+    return error.EntropyUnavailable;
+}
+
+pub fn noNow(userdata: ?*anyopaque, clock: Clock) Timestamp {
+    _ = userdata;
+    _ = clock;
+    return .zero;
+}
+
+pub fn failingClockResolution(userdata: ?*anyopaque, clock: Clock) Clock.ResolutionError!Duration {
+    _ = userdata;
+    _ = clock;
+    return error.ClockUnavailable;
+}
+
+pub fn noSleep(userdata: ?*anyopaque, clock: Timeout) Cancelable!void {
+    _ = userdata;
+    _ = clock;
+}
+
+pub fn failingNetListenIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.ListenOptions) net.IpAddress.ListenError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetAccept(userdata: ?*anyopaque, listen_fd: net.Socket.Handle, options: net.Server.AcceptOptions) net.Server.AcceptError!net.Socket {
+    _ = userdata;
+    _ = listen_fd;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetBindIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.BindOptions) net.IpAddress.BindError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetConnectIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.ConnectOptions) net.IpAddress.ConnectError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetListenUnix(userdata: ?*anyopaque, address: *const net.UnixAddress, options: net.UnixAddress.ListenOptions) net.UnixAddress.ListenError!net.Socket.Handle {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetConnectUnix(userdata: ?*anyopaque, address: *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle {
+    _ = userdata;
+    _ = address;
+    return error.NetworkDown;
+}
+
+pub fn failingNetSocketCreatePair(userdata: ?*anyopaque, options: net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingNetSend(userdata: ?*anyopaque, handle: net.Socket.Handle, messages: []net.OutgoingMessage, flags: net.SendFlags) struct { ?net.Socket.SendError, usize } {
+    _ = userdata;
+    _ = handle;
+    _ = messages;
+    _ = flags;
+    return .{ error.NetworkDown, 0 };
+}
+
+pub fn failingNetWrite(userdata: ?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize {
+    _ = userdata;
+    _ = dest;
+    _ = header;
+    _ = data;
+    _ = splat;
+    return error.NetworkDown;
+}
+
+pub fn failingNetWriteFile(userdata: ?*anyopaque, handle: net.Socket.Handle, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit) net.Stream.Writer.WriteFileError!usize {
+    _ = userdata;
+    _ = handle;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.NetworkDown;
+}
+
+pub fn unreachableNetClose(userdata: ?*anyopaque, handle: []const net.Socket.Handle) void {
+    _ = userdata;
+    _ = handle;
+    unreachable;
+}
+
+pub fn failingNetShutdown(userdata: ?*anyopaque, handle: net.Socket.Handle, how: net.ShutdownHow) net.ShutdownError!void {
+    _ = userdata;
+    _ = handle;
+    _ = how;
+    return error.NetworkDown;
+}
+
+pub fn failingNetInterfaceNameResolve(userdata: ?*anyopaque, name: *const net.Interface.Name) net.Interface.Name.ResolveError!net.Interface {
+    _ = userdata;
+    _ = name;
+    return error.InterfaceNotFound;
+}
+
+pub fn unreachableNetInterfaceName(userdata: ?*anyopaque, interface: net.Interface) net.Interface.NameError!net.Interface.Name {
+    _ = userdata;
+    _ = interface;
+    unreachable;
+}
+
+pub fn failingNetLookup(userdata: ?*anyopaque, host_name: net.HostName, resolved: *Queue(net.HostName.LookupResult), options: net.HostName.LookupOptions) net.HostName.LookupError!void {
+    _ = userdata;
+    _ = host_name;
+    _ = resolved;
+    _ = options;
+    return error.NetworkDown;
+}
+
+test failing {
+    const f: Io = .failing;
+    // file stuff
+    try std.testing.expectError(error.NoSpaceLeft, Dir.createDir(.cwd(), f, "test", .default_dir));
+    try std.testing.expectError(error.NoSpaceLeft, Dir.createFile(.cwd(), f, "test", .{}));
+    try std.testing.expectError(error.FileNotFound, Dir.openDir(.cwd(), f, "test", .{}));
+    try std.testing.expectError(error.FileNotFound, Dir.openFile(.cwd(), f, "test", .{}));
+    try File.writeStreamingAll(.stdout(), f, &.{});
+    try std.testing.expectError(error.AccessDenied, File.MemoryMap.create(f, .stdout(), .{ .len = 0 }));
+    // async stuff
+    const closure = struct {
+        var foo: usize = 0;
+        fn doOp() void {
+            foo = 4;
+        }
+    };
+    var future = f.async(closure.doOp, .{});
+    _ = future.await(f);
+    try std.testing.expect(closure.foo == 4);
+    // random stuff
+    var buffer: [1]u8 = undefined;
+    f.random(&buffer);
+    try std.testing.expect(buffer[0] == 0);
+}