// Row ownership mirrors ref/hare/bufio/scanner_test+test.ha.
// Streams are built as `let st = memio.fixed(buf); &st.vt` — the #94
// unified value-return io surface (read/write/close return size/io.error).

package bufio_test;

import bufio;
import encoding.utf8;
import errors;
import io;
import memio;
import test;

fn putstr(s: str, into: []u8, off: i32) i32 = {
	let i: i32 = 0;
	for (i < s.len) {
		into[off + i] = s[i];
		i += 1;
	};
	return off + s.len;
};

let errvt: io.vtable;

fn errread(s: io.stream, buf: []u8) (size | io.eof | io.error) = {
	let nm: nomem; let e: io.error = nm; return e;
};
fn errwrite(s: io.stream, buf: []u8) (size | io.error) = {
	let nm: nomem; let e: io.error = nm; return e;
};
fn errsource() io.stream = {
	errvt.reader = (&errread):  *io.reader;
	errvt.writer = (&errwrite): *io.writer;
	return &errvt;
};

// stepstream is a deliberately short-reading source. `zero` makes its
// first call return no progress so scanner EOF handling is observable.
type stepstream = struct {
	vt: io.vtable,
	src: []u8,
	pos: i32,
	calls: i32,
	step: i32,
	zero: bool,
	badcap: bool,
};

fn stepread(s: io.stream, buf: []u8) (size | io.eof | io.error) = {
	let r: *stepstream = s: *stepstream;
	r.calls += 1;
	if (buf.cap != buf.len) { r.badcap = true; };
	if (r.zero) {
		r.zero = false;
		return 0: size;
	};
	if (r.pos == r.src.len) { let e: io.eof; return e; };
	let n: i32 = r.step;
	if (n > buf.len) { n = buf.len; };
	if (n > r.src.len - r.pos) { n = r.src.len - r.pos; };
	let i: i32 = 0;
	for (i < n) {
		buf[i] = r.src[r.pos + i];
		i += 1;
	};
	r.pos += n;
	return n: size;
};

fn newstepstream(src: []u8, step: i32, zero: bool) stepstream = {
	let r: stepstream;
	r.vt.reader = (&stepread): *io.reader;
	r.src = src;
	r.pos = 0;
	r.calls = 0;
	r.step = step;
	r.zero = zero;
	r.badcap = false;
	return r;
};

def WANT_INVALID: i32 = -1;
def WANT_EOF: i32 = -2;

fn checkrune(sc: *bufio.scanner, want: i32) void = {
	let r: (rune | io.eof | io.error | utf8.invalid | errors.overflow) =
		bufio.scanrune(sc);
	match (r) {
	case let got: rune => assert(want >= 0 && got: i32 == want);
	case io.eof => assert(want == WANT_EOF);
	case let e: io.error => abort();
	case utf8.invalid => assert(want == WANT_INVALID);
	case errors.overflow => abort();
	};
};

@test fn scanbytecases() void = {
	let raw: [4]u8;
	raw[0] = 11u8; raw[1] = 22u8; raw[2] = 33u8; raw[3] = 44u8;

	let mem: memio.stream = memio.fixed(raw[0:4]);
	let m:   io.stream = &mem.vt;
	let buf: [2]u8;
	let sc:  bufio.scanner = bufio.newscannerbuf(m, buf[0:2]);

	// (wantbyte, weof)
	let want: [6]u8;
	let weof: [6]i32;
	want[0]=11u8; weof[0]=0;
	want[1]=22u8; weof[1]=0;
	want[2]=33u8; weof[2]=0;
	want[3]=44u8; weof[3]=0;
	want[4]=0u8;  weof[4]=1;	// past end → eof
	want[5]=0u8;  weof[5]=1;	// stay at eof

	let i: i32 = 0;
	for (i < 6) {
		let r: (u8 | io.eof | io.error | errors.overflow) = bufio.scanbyte(&sc);
		match (r) {
		case let b: u8 => {
			assert(!(weof[i] != 0));
			assert(!(b != want[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		case let e: io.error => abort();
		case errors.overflow => abort();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

@test fn scanlinecases() void = {
	let src: [32]u8;
	let n: i32 = putstr("foo\nbar\nbaz\ntrailing", src[0:32], 0);

	let mem: memio.stream = memio.fixed(src[0:n]);
	let m:   io.stream = &mem.vt;
	let buf: [32]u8;
	let sc:  bufio.scanner = bufio.newscannerbuf(m, buf[0:32]);

	// (wantlen, wantfirst, weof, wovr)
	let wl:    [5]i32;
	let wf:    [5]u8;
	let weof:  [5]i32;
	let wovr:  [5]i32;
	wl[0]=3; wf[0]=102u8; weof[0]=0; wovr[0]=0;	// foo
	wl[1]=3; wf[1]=98u8;  weof[1]=0; wovr[1]=0;	// bar
	wl[2]=3; wf[2]=98u8;  weof[2]=0; wovr[2]=0;	// baz
	wl[3]=0; wf[3]=0u8;   weof[3]=1; wovr[3]=0;	// trailing → eof
	wl[4]=0; wf[4]=0u8;   weof[4]=1; wovr[4]=0;	// stay eof

	let i: i32 = 0;
	for (i < 5) {
		let r: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc);
		match (r) {
		case let v: str => {
			assert(!(weof[i] != 0));
			assert(!(wovr[i] != 0));
			assert(!(v.len != wl[i]));
			assert(v.cap == v.len);
			assert(!(v.len > 0 && v[0] != wf[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		case let e: io.error => abort();
		case errors.overflow => { assert(!(wovr[i] == 0)); };
		};
		i += 1;
	};

	bufio.finish(&sc);
};

@test fn scanlineoverflow() void = {
	let src: [32]u8;
	let n: i32 = putstr("ABCDEFGHI\n", src[0:32], 0);

	let mem: memio.stream = memio.fixed(src[0:n]);
	let m:   io.stream = &mem.vt;

	// Buffer too small for the 9-byte payload + delim.
	let buf: [4]u8;
	let sc:  bufio.scanner = bufio.newscannerbuf(m, buf[0:4]);

	let r: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc);
	match (r) {
	case let v: str => abort();
	case io.eof => abort();
	case let e: io.error => abort();
	case errors.overflow => { };
	};

	bufio.finish(&sc);
};

@test fn scanbytescases() void = {
	let src: [16]u8;
	// ",a,,b,c"  — leading delim, empty token, multi-hit, trailing fragment.
	let n: i32 = putstr(",a,,b,c", src[0:16], 0);

	let mem: memio.stream = memio.fixed(src[0:n]);
	let m:   io.stream = &mem.vt;
	let buf: [8]u8;
	let sc:  bufio.scanner = bufio.newscannerbuf(m, buf[0:8]);

	// (wantlen, wantfirst, weof)
	let wl:   [5]i32;
	let wf:   [5]u8;
	let weof: [5]i32;
	wl[0]=0; wf[0]=0u8;   weof[0]=0;
	wl[1]=1; wf[1]=97u8;  weof[1]=0;	// 'a'
	wl[2]=0; wf[2]=0u8;   weof[2]=0;
	wl[3]=1; wf[3]=98u8;  weof[3]=0;	// 'b'
	wl[4]=0; wf[4]=0u8;   weof[4]=1;	// 'c' discarded

	let i: i32 = 0;
	for (i < 5) {
		let r: ([]u8 | io.eof | io.error | errors.overflow) = bufio.scanbytes(&sc, 44u8);	// ','
		match (r) {
		case let v: []u8 => {
			assert(!(weof[i] != 0));
			assert(!(v.len != wl[i]));
			assert(v.cap == v.len);
			assert(!(v.len > 0 && v[0] != wf[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		case let e: io.error => abort();
		case errors.overflow => abort();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

@test fn emptystream() void = {
	let raw: [1]u8;
	let mem: memio.stream = memio.fixed(raw[0:0]);
	let m:   io.stream = &mem.vt;
	let buf: [8]u8;
	let sc:  bufio.scanner = bufio.newscannerbuf(m, buf[0:8]);

	let r1: (u8 | io.eof | io.error | errors.overflow) = bufio.scanbyte(&sc);
	match (r1) {
	case let b: u8 => abort();
	case io.eof => { };
	case let e: io.error => abort();
	case errors.overflow => abort();
	};

	let r2: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc);
	match (r2) {
	case let v: str => abort();
	case io.eof => { };
	case let e: io.error => abort();
	case errors.overflow => abort();
	};

	let r3: ([]u8 | io.eof | io.error | errors.overflow) = bufio.scanbytes(&sc, 10u8);
	match (r3) {
	case let v: []u8 => abort();
	case io.eof => { };
	case let e: io.error => abort();
	case errors.overflow => abort();
	};

	bufio.finish(&sc);
};

@test fn errorsource() void = {
	let m: io.stream = errsource();
	let buf: [8]u8;
	let sc:  bufio.scanner = bufio.newscannerbuf(m, buf[0:8]);

	let r1: (u8 | io.eof | io.error | errors.overflow) = bufio.scanbyte(&sc);
	match (r1) {
	case let b: u8 => abort();
	case io.eof => abort();
	case let e: io.error => { };
	case errors.overflow => abort();
	};

	let r2: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc);
	match (r2) {
	case let v: str => abort();
	case io.eof => abort();
	case let e: io.error => { };
	case errors.overflow => abort();
	};

	let r3: ([]u8 | io.eof | io.error | errors.overflow) = bufio.scanbytes(&sc, 32u8);
	match (r3) {
	case let v: []u8 => abort();
	case io.eof => abort();
	case let e: io.error => { };
	case errors.overflow => abort();
	};

	bufio.finish(&sc);
};

@test fn boundarycases() void = {
	let s1: [16]u8;
	let n1: i32 = putstr("\nfoo\n", s1[0:16], 0);
	let m1mem: memio.stream = memio.fixed(s1[0:n1]);
	let m1:    io.stream = &m1mem.vt;
	let b1: [8]u8;
	let sc1: bufio.scanner = bufio.newscannerbuf(m1, b1[0:8]);

	let r1: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc1);
	match (r1) {
	case let v: str => { assert(!(v.len != 0)); };
	case io.eof => abort();
	case let e: io.error => abort();
	case errors.overflow => abort();
	};
	let r2: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc1);
	match (r2) {
	case let v: str => {
		assert(!(v.len != 3));
		assert(!(v[0] != 102u8));	// 'f'
	};
	case io.eof => abort();
	case let e: io.error => abort();
	case errors.overflow => abort();
	};
	bufio.finish(&sc1);

	let s2: [8]u8;
	let n2: i32 = putstr("ab", s2[0:8], 0);
	let m2mem: memio.stream = memio.fixed(s2[0:n2]);
	let m2:    io.stream = &m2mem.vt;
	let b2: [8]u8;
	let sc2: bufio.scanner = bufio.newscannerbuf(m2, b2[0:8]);

	let t1: ([]u8 | io.eof | io.error | errors.overflow) = bufio.scanbytes(&sc2, 44u8);
	match (t1) {
	case let v: []u8 => abort();
	case io.eof => { };
	case let e: io.error => abort();
	case errors.overflow => abort();
	};
	let t2: ([]u8 | io.eof | io.error | errors.overflow) = bufio.scanbytes(&sc2, 44u8);
	match (t2) {
	case let v: []u8 => abort();
	case io.eof => { };
	case let e: io.error => abort();
	case errors.overflow => abort();
	};
	bufio.finish(&sc2);
};

@test fn multifill() void = {
	let src: [32]u8;
	let n: i32 = putstr("abcd\nxy\n", src[0:32], 0);

	let mem: memio.stream = memio.fixed(src[0:n]);
	let m:   io.stream = &mem.vt;
	let buf: [5]u8;
	let sc:  bufio.scanner = bufio.newscannerbuf(m, buf[0:5]);

	// (wantlen, wantfirst, weof)
	let wl:   [3]i32;
	let wf:   [3]u8;
	let weof: [3]i32;
	wl[0]=4; wf[0]=97u8;  weof[0]=0;	// abcd
	wl[1]=2; wf[1]=120u8; weof[1]=0;	// xy
	wl[2]=0; wf[2]=0u8;   weof[2]=1;	// eof

	let i: i32 = 0;
	for (i < 3) {
		let r: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc);
		match (r) {
		case let v: str => {
			assert(!(weof[i] != 0));
			assert(!(v.len != wl[i]));
			assert(!(v.len > 0 && v[0] != wf[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		case let e: io.error => abort();
		case errors.overflow => abort();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

@test fn scanrunecases() void = {
	// "a" U+0061; "é" U+00E9 (C3 A9); "한" U+D55C (ED 95 9C);
	// "😀" U+1F600 (F0 9F 98 80).
	let raw: [10]u8;
	raw[0] = 97u8;
	raw[1] = 0xC3u8; raw[2] = 0xA9u8;
	raw[3] = 0xEDu8; raw[4] = 0x95u8; raw[5] = 0x9Cu8;
	raw[6] = 0xF0u8; raw[7] = 0x9Fu8; raw[8] = 0x98u8; raw[9] = 0x80u8;

	let mem: memio.stream = memio.fixed(raw[0:10]);
	let m:   io.stream = &mem.vt;
	// 8B window: the trailing 4-byte rune straddles a refill (shift path).
	let buf: [8]u8;
	let sc:  bufio.scanner = bufio.newscannerbuf(m, buf[0:8]);

	// (wantrune, weof)
	let want: [6]u32;
	let weof: [6]i32;
	want[0] = 97u32;     weof[0] = 0;
	want[1] = 233u32;    weof[1] = 0;
	want[2] = 54620u32;  weof[2] = 0;
	want[3] = 128512u32; weof[3] = 0;
	want[4] = 0u32;      weof[4] = 1;	// past end → eof
	want[5] = 0u32;      weof[5] = 1;	// stay at eof

	let i: i32 = 0;
	for (i < 6) {
		let r: (rune | io.eof | io.error | utf8.invalid | errors.overflow) = bufio.scanrune(&sc);
		match (r) {
		case let rn: rune => {
			assert(!(weof[i] != 0));
			assert(!(rn: u32 != want[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		case let e: io.error => abort();
		case utf8.invalid => abort();
		case errors.overflow => abort();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

@test fn scanruneinvalid() void = {
	// Bare continuation byte: utf8sz rejects the initial byte.
	let r1raw: [1]u8;
	r1raw[0] = 0x80u8;
	let mem1: memio.stream = memio.fixed(r1raw[0:1]);
	let m1: io.stream = &mem1.vt;
	let b1: [8]u8;
	let sc1: bufio.scanner = bufio.newscannerbuf(m1, b1[0:8]);
	let r1: (rune | io.eof | io.error | utf8.invalid | errors.overflow) = bufio.scanrune(&sc1);
	match (r1) {
	case let rn: rune => abort();
	case io.eof => abort();
	case let e: io.error => abort();
	case utf8.invalid => { };
	case errors.overflow => abort();
	};
	bufio.finish(&sc1);

	// Truncated 2-byte sequence at EOF: pending < utf8sz → invalid
	// (Hare scanner.ha:272-274).
	let r2raw: [1]u8;
	r2raw[0] = 0xC3u8;
	let mem2: memio.stream = memio.fixed(r2raw[0:1]);
	let m2: io.stream = &mem2.vt;
	let b2: [8]u8;
	let sc2: bufio.scanner = bufio.newscannerbuf(m2, b2[0:8]);
	let r2: (rune | io.eof | io.error | utf8.invalid | errors.overflow) = bufio.scanrune(&sc2);
	match (r2) {
	case let rn: rune => abort();
	case io.eof => abort();
	case let e: io.error => abort();
	case utf8.invalid => { };
	case errors.overflow => abort();
	};
	bufio.finish(&sc2);

	// UTF-16 surrogate encoding (ED A0 80 = U+D800): utf8sz accepts the
	// initial byte, the decode DFA rejects the continuation.
	let r3raw: [3]u8;
	r3raw[0] = 0xEDu8; r3raw[1] = 0xA0u8; r3raw[2] = 0x80u8;
	let mem3: memio.stream = memio.fixed(r3raw[0:3]);
	let m3: io.stream = &mem3.vt;
	let b3: [8]u8;
	let sc3: bufio.scanner = bufio.newscannerbuf(m3, b3[0:8]);
	let r3: (rune | io.eof | io.error | utf8.invalid | errors.overflow) = bufio.scanrune(&sc3);
	match (r3) {
	case let rn: rune => abort();
	case io.eof => abort();
	case let e: io.error => abort();
	case utf8.invalid => { };
	case errors.overflow => abort();
	};
	bufio.finish(&sc3);
};

@test fn scanrunepartialreads() void = {
	// Each read yields one byte, including across a shifted 4-byte rune.
	let raw: [6]u8;
	raw[0] = 0xC3u8; raw[1] = 0xA9u8;
	raw[2] = 0xF0u8; raw[3] = 0x9Fu8;
	raw[4] = 0x98u8; raw[5] = 0x80u8;
	let src: stepstream = newstepstream(raw[0:6], 1, false);
	let buf: [4]u8;
	let sc: bufio.scanner = bufio.newscannerbuf(&src.vt, buf[0:4]);
	checkrune(&sc, 233);
	checkrune(&sc, 128512);
	checkrune(&sc, WANT_EOF);
	assert(!src.badcap);
	assert(src.calls == 7);
	bufio.finish(&sc);
};

@test fn scanrunemalformedprogress() void = {
	// The decoder rejects E0 80 at position 2; the pending ASCII byte
	// beyond that position must remain for the next scan.
	let raw1: [3]u8;
	raw1[0] = 0xE0u8; raw1[1] = 0x80u8; raw1[2] = 65u8;
	let mem1: memio.stream = memio.fixed(raw1[0:3]);
	let buf1: [8]u8;
	let sc1: bufio.scanner = bufio.newscannerbuf(&mem1.vt, buf1[0:8]);
	checkrune(&sc1, WANT_INVALID);
	checkrune(&sc1, 65);
	bufio.finish(&sc1);

	// Impossible F5-F7 leads consume one byte, not their following ASCII.
	let raw2: [4]u8;
	raw2[0] = 0xF5u8; raw2[1] = 65u8;
	raw2[2] = 66u8; raw2[3] = 67u8;
	let mem2: memio.stream = memio.fixed(raw2[0:4]);
	let buf2: [8]u8;
	let sc2: bufio.scanner = bufio.newscannerbuf(&mem2.vt, buf2[0:8]);
	checkrune(&sc2, WANT_INVALID);
	let want: [3]u32;
	want[0] = 65u32; want[1] = 66u32; want[2] = 67u32;
	let i: i32 = 0;
	for (i < 3) {
		checkrune(&sc2, want[i]: i32);
		i += 1;
	};
	bufio.finish(&sc2);

	// A truncated prefix is consumed once; a following call is EOF.
	let raw3: [1]u8;
	raw3[0] = 0xC3u8;
	let mem3: memio.stream = memio.fixed(raw3[0:1]);
	let buf3: [8]u8;
	let sc3: bufio.scanner = bufio.newscannerbuf(&mem3.vt, buf3[0:8]);
	checkrune(&sc3, WANT_INVALID);
	checkrune(&sc3, WANT_EOF);
	bufio.finish(&sc3);
};

@test fn scannerzeroreadiseof() void = {
	let raw: [1]u8;
	raw[0] = 65u8;
	let src: stepstream = newstepstream(raw[0:1], 1, true);
	let buf: [4]u8;
	let sc: bufio.scanner = bufio.newscannerbuf(&src.vt, buf[0:4]);
	let i: i32 = 0;
	for (i < 2) {
		let r: (u8 | io.eof | io.error | errors.overflow) =
			bufio.scanbyte(&sc);
		match (r) {
		case let b: u8 => abort();
		case io.eof => { };
		case let e: io.error => abort();
		case errors.overflow => abort();
		};
		i += 1;
	};
	assert(src.calls == 1);
	assert(src.pos == 0);
	bufio.finish(&sc);
};

@test fn scannermaxreadbound() void = {
	// The token and delimiter exceed maxread. The old growth expression
	// allocated avail+want (8193 here) and incorrectly accepted them.
	let raw: [4099]u8;
	let i: i32 = 0;
	for (i < 4098) { raw[i] = 65u8; i += 1; };
	raw[4098] = 10u8;
	let mem: memio.stream = memio.fixed(raw[0:4099]);
	let sc: bufio.scanner = bufio.newscanner(&mem.vt, 4097);
	let r: (str | io.eof | io.error | errors.overflow) =
		bufio.scanline(&sc);
	match (r) {
	case let s: str => abort();
	case io.eof => abort();
	case let e: io.error => abort();
	case errors.overflow => { };
	};
	assert(sc.cap == 4097);
	assert(sc.avail == 4097);
	assert(sc.owned);
	bufio.finish(&sc);
	assert(sc.ptr == nil);
	assert(sc.cap == 0 && sc.avail == 0 && !sc.owned && sc.eof);
};

@test fn newscannernegativeaborts() void = {
	test.expectabort();
	let sc: bufio.scanner = bufio.newscanner(errsource(), -1);
};

@test fn newscannergrow() void = {
	let src: [16]u8;
	let n: i32 = putstr("hello\nworld\n", src[0:16], 0);

	let mem: memio.stream = memio.fixed(src[0:n]);
	let m:   io.stream = &mem.vt;
	// cap starts at 0; the first readahead grows to min(BUFSZ, maxread).
	let sc: bufio.scanner = bufio.newscanner(m, 1024);

	// (wantlen, wantfirst, weof)
	let wl:   [3]i32;
	let wf:   [3]u8;
	let weof: [3]i32;
	wl[0]=5; wf[0]=104u8; weof[0]=0;	// hello
	wl[1]=5; wf[1]=119u8; weof[1]=0;	// world
	wl[2]=0; wf[2]=0u8;   weof[2]=1;	// eof

	let i: i32 = 0;
	for (i < 3) {
		let r: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc);
		match (r) {
		case let v: str => {
			assert(!(weof[i] != 0));
			assert(!(v.len != wl[i]));
			assert(!(v.len > 0 && v[0] != wf[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		case let e: io.error => abort();
		case errors.overflow => abort();
		};
		i += 1;
	};
	bufio.finish(&sc);

	// scanrune over a fresh newscanner (the regex search() shape).
	let r2raw: [3]u8;
	r2raw[0] = 0xC3u8; r2raw[1] = 0xA9u8;	// é
	r2raw[2] = 122u8;			// 'z'
	let mem2: memio.stream = memio.fixed(r2raw[0:3]);
	let m2: io.stream = &mem2.vt;
	let sc2: bufio.scanner = bufio.newscanner(m2, 1024);

	let want: [3]u32;
	let weof2: [3]i32;
	want[0]=233u32; weof2[0]=0;
	want[1]=122u32; weof2[1]=0;
	want[2]=0u32;   weof2[2]=1;

	i = 0;
	for (i < 3) {
		let r: (rune | io.eof | io.error | utf8.invalid | errors.overflow) = bufio.scanrune(&sc2);
		match (r) {
		case let rn: rune => {
			assert(!(weof2[i] != 0));
			assert(!(rn: u32 != want[i]));
		};
		case io.eof => { assert(!(weof2[i] == 0)); };
		case let e: io.error => abort();
		case utf8.invalid => abort();
		case errors.overflow => abort();
		};
		i += 1;
	};
	bufio.finish(&sc2);
};

@test fn newscanneroverflow() void = {
	let src: [16]u8;
	let n: i32 = putstr("ABCDEFGH\n", src[0:16], 0);

	let mem: memio.stream = memio.fixed(src[0:n]);
	let m:   io.stream = &mem.vt;
	let sc: bufio.scanner = bufio.newscanner(m, 4);	// token (8B) > maxread

	let r: (str | io.eof | io.error | errors.overflow) = bufio.scanline(&sc);
	match (r) {
	case let v: str => abort();
	case io.eof => abort();
	case let e: io.error => abort();
	case errors.overflow => { };
	};
	bufio.finish(&sc);
};

// drain F-B: a scanner that cannot buffer the next byte (zero-cap) makes
// readahead unable to make progress. Pre-fix it fell through silently to
// a zero-length io.read returning 0, so scanbyte spun forever (catB-144)
// and scanrune dereferenced the nil / zero-cap s.ptr[s.start]
// (catB-145). Both entry points must now surface errors.overflow
// (ref/hare/bufio/scanner.ha:179-181). The table crosses the two
// zero-cap constructions — nil-ptr newscanner(,0) and zero-length
// newscannerbuf — with the two single-item entry points; every row is an
// overflow. Because the new code returns promptly, this test terminates
// where the pre-fix scanbyte path would hang.
@test fn readaheadcantgrow() void = {
	let src: [4]u8;
	src[0]=65u8; src[1]=66u8; src[2]=67u8; src[3]=68u8;	// "ABCD"

	// (ctor, entry): ctor 0=newscanner(,0) (nil ptr), 1=newscannerbuf
	// (,[0:0]) (zero-len buffer); entry 0=scanbyte, 1=scanrune.
	let ctor:  [4]i32;
	let entry: [4]i32;
	ctor[0]=0; entry[0]=0;	// newscanner    + scanbyte
	ctor[1]=0; entry[1]=1;	// newscanner    + scanrune
	ctor[2]=1; entry[2]=0;	// newscannerbuf + scanbyte
	ctor[3]=1; entry[3]=1;	// newscannerbuf + scanrune

	let zbuf: [1]u8;	// sliced to [0:0] for the zero-len construction

	let i: i32 = 0;
	for (i < 4) {
		let mem: memio.stream = memio.fixed(src[0:4]);
		let m:   io.stream = &mem.vt;

		let sc: bufio.scanner;
		if (ctor[i] == 0) {
			sc = bufio.newscanner(m, 0);
		} else {
			sc = bufio.newscannerbuf(m, zbuf[0:0]);
		};

		if (entry[i] == 0) {
			let rb: (u8 | io.eof | io.error | errors.overflow) =
				bufio.scanbyte(&sc);
			match (rb) {
			case let b: u8 => abort();
			case io.eof => abort();
			case let e: io.error => abort();
			case errors.overflow => { };
			};
		} else {
			let rr: (rune | io.eof | io.error | utf8.invalid | errors.overflow) =
				bufio.scanrune(&sc);
			match (rr) {
			case let rn: rune => abort();
			case io.eof => abort();
			case let e: io.error => abort();
			case utf8.invalid => abort();
			case errors.overflow => { };
			};
		};

		bufio.finish(&sc);
		i += 1;
	};
};