std.Io.Reader.Limited can hang #25093

const std = @import("std");

// An unlimited stream of 0xaa bytes.
pub const AAStream = struct {
    reader: std.Io.Reader,

    pub fn init(
        buffer: []u8,
    ) AAStream {
        return AAStream{
            .reader = .{
                .vtable = &.{
                    .stream = AAStream.streamHexAA,
                },
                .buffer = buffer,
                .seek = 0,
                .end = 0,
            },
        };
    }

    fn streamHexAA(io_reader: *std.Io.Reader, w: *std.Io.Writer, limit: std.Io.Limit) std.Io.Reader.StreamError!usize {
        _ = io_reader;

        // Uncomment this line to see that this function is repeatedly called with limit 0.
        // defer std.debug.print("stream function finished. called with limit: {?}\n", .{limit.toInt()});

        const n_bytes_remaining = limit.minInt(2);
        for (0..n_bytes_remaining) |_| {
            try w.writeByte(0xaa);
        }
        return n_bytes_remaining;
    }
};

test {
    var aa_buffer: [1024]u8 = undefined;
    var aa_stream = AAStream.init(&aa_buffer);

    // apply a limit of 2 bytes
    var buffer: [1024]u8 = undefined;
    var limited = std.Io.Reader.limited(
        &aa_stream.reader,
        .limited(2),
        &buffer,
    );
    const reader = &limited.interface;

    // trigger EndOfStream
    var out_buffer: [8]u8 = undefined;
    try std.testing.expectError(error.EndOfStream, reader.readSliceAll(&out_buffer));
}