std.Io.Reader.takeDelimiterExclusive() return error.StreamTooLong instead of error.EndOfStream

[truly-not-taken]

Zig Version

0.15.1

Steps to Reproduce and Observed Behavior

test {
    var reader = std.Io.Reader.fixed("");
    try std.testing.expectError(
        error.EndOfStream,
        reader.takeDelimiterExclusive('\n'),
    );
}

failed: expected error.EndOfStream, found error.StreamTooLong

Expected Behavior

Docs say

Returned slice excludes the delimiter. End-of-stream is treated equivalent to a delimiter, unless it would result in a length 0 return value, in which case error.EndOfStream is returned instead.

[truly-not-taken]

I guess you can just catch error.StreamTooLong the same as error.EndOfStream to fix this.

pub fn takeDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
    const result = r.peekDelimiterInclusive(delimiter) catch |err| switch (err) {
        error.EndOfStream, error.StreamTooLong => {
            const remaining = r.buffer[r.seek..r.end];
            if (remaining.len == 0) return error.EndOfStream;
            r.toss(remaining.len);
            return remaining;
        },
        else => |e| return e,
    };
    r.toss(result.len);
    return result[0 .. result.len - 1];
}

[truly-not-taken]

This fix kind of works for me

pub fn takeDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
    const result = r.peekDelimiterInclusive(delimiter) catch |err| switch (err) {
        error.StreamTooLong => {
            if (r.seek == r.end) return error.EndOfStream;
            return error.StreamTooLong;
        },

[truly-not-taken]

The behavior of std.Io.Reader.fixed is different from a file reader. This test does not fail while it is basically the same:

const std = @import("std");
test {
    var file = try std.fs.cwd().openFile("/dev/null", .{});
    var buffer: [1024]u8 = undefined;
    var reader = file.readerStreaming(&buffer);
    try std.testing.expectError(
        error.EndOfStream,
        reader.interface.takeDelimiterExclusive('\n'),
    );
}

But how do I do unit tests now? I need to test my function behavior against empty input.

[truly-not-taken]

This hack in lib/std/Io/Reader.zig works for me but I have no idea how to make it work in a non-hacky way.

pub fn takeDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
    const result = r.peekDelimiterInclusive(delimiter) catch |err| switch (err) {
        error.StreamTooLong => {
            const remaining = r.buffer[r.seek..r.end];
            if (remaining.len == 0) return error.EndOfStream;
            if (remaining.len == r.buffer.len and r.vtable.rebase != &endingRebase)
                return error.StreamTooLong;
            r.toss(remaining.len);
            return remaining;
        },
        error.EndOfStream => {

[truly-not-taken]

This is ridiculous! It keeps gaslighting me about long streams while they are empty.

test {
    try std.testing.expectError(
        error.EndOfStream,
        std.Io.Reader.ending.takeDelimiterExclusive('\n'),
    );
}

error: '1.test_0' failed: expected error.EndOfStream, found error.StreamTooLong

[truly-not-taken]

So here is a work around. I hope I have not done anything illegal.

lib/std/Io/Reader.zig

/// Constructs a `Reader` such that it will read from `buffer` and then end.
/// Its `takeDelimiterExclusive()` will return `error.EndOfStream`
/// even if the last byte is not the delimiter.
pub fn fixedZ(bufferZ: [:0]const u8) Reader {
    var buffer:[]const u8 = bufferZ;
    buffer.len += 1;
    return .{
        .vtable = &.{
            .stream = endingStream,
            .discard = endingDiscard,
            .readVec = endingReadVec,
            .rebase = endingRebase,
        },
        // This cast is safe because all potential writes to it will instead
        // return `error.EndOfStream`.
        .buffer = @constCast(buffer),
        .end = bufferZ.len,
        .seek = 0,
    };
}

Now I can test my function against an empty input:

test {
    var reader = std.Io.Reader.fixedZ("");
    try std.testing.expectError(
        error.EndOfStream,
        reader.takeDelimiterExclusive('\n'),
    );
}