// Every @test enumerates parallel `[N]T` arrays of inputs and
// expectations, then iterates one body across them. Parallel arrays
// (rather than `[N]struct{...}`) sidestep the cstage cgen's chained
// `arr[i].field` store gap (task #6). #94 fold-eFinal: the unified
// value-return surface (`let st = memio.fixed(buf); &st.vt` into the
// io dispatchers; io.read/write/close return size/io.error).

package memio_test;

import bytes;
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;
};

@test fn fixedread() void = {
	let arr: [8]u8;
	arr[0] = 1u8; arr[1] = 2u8; arr[2] = 3u8; arr[3] = 4u8;
	arr[4] = 5u8; arr[5] = 6u8; arr[6] = 7u8; arr[7] = 8u8;

	// (request, wantn, wantfirst, wantlast, weof)
	// 5 rows: under-remaining, full slot, last-byte-only, post-end, 0-len-at-end.
	let req:   [5]i32;
	let wantn: [5]i32;
	let wantf: [5]u8;
	let wantl: [5]u8;
	let weof:  [5]i32;
	req[0]=3; wantn[0]=3; wantf[0]=1u8; wantl[0]=3u8; weof[0]=0;
	req[1]=4; wantn[1]=4; wantf[1]=4u8; wantl[1]=7u8; weof[1]=0;
	req[2]=5; wantn[2]=1; wantf[2]=8u8; wantl[2]=8u8; weof[2]=0;
	req[3]=1; wantn[3]=0; wantf[3]=0u8; wantl[3]=0u8; weof[3]=1;
	req[4]=0; wantn[4]=0; wantf[4]=0u8; wantl[4]=0u8; weof[4]=1;

	let st: memio.stream = memio.fixed(arr[0:8]);
	let s: io.stream = &st.vt;

	let out: [8]u8;
	let i: i32 = 0;
	for (i < 5) {
		// Clear out so spot checks read real data, not stale bytes.
		let k: i32 = 0;
		for (k < 8) { out[k] = 0u8; k += 1; };

		let r: (size | io.eof | io.error) = io.read(s, out[0:req[i]]);
		match (r) {
		case let nz: size => {
			let n: i32 = nz: i32;
			assert(!(weof[i] != 0));
			assert(!(n != wantn[i]));
			assert(!(n > 0 && out[0] != wantf[i]));
			assert(!(n > 0 && out[n - 1] != wantl[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		case let e: io.error => abort();
		};
		i += 1;
	};

	// fixed stream has no closer → io.close returns void.
	let c: (void | io.error) = io.close(s);
	match (c) { case void => {}; case let e: io.error => abort(); };
};

@test fn fixedreadoverlap() void = {
	let arr: [4]u8;
	let _: i32 = putstr("ABCD", arr[0:4], 0);
	let st: memio.stream = memio.fixed(arr[0:4]);
	let r: (size | io.eof | io.error) = io.read(&st.vt, arr[1:4]);
	match (r) {
	case let n: size => assert(n: i32 == 3);
	case io.eof => abort();
	case let e: io.error => abort();
	};
	let want: [4]u8;
	let _: i32 = putstr("AABC", want[0:4], 0);
	assert(bytes.equal(arr[0:4], want[0:4]));
};

@test fn fixedwritecases() void = {
	let dst: [16]u8;
	let st: memio.stream = memio.fixed(dst[0:16]);
	let s: io.stream = &st.vt;

	// One flat source; rows index into it via (off, len). Sequence:
	// "hello " (6), "world!!" (7), "XXXXXXX" (7), "Y" (1).
	let src: [32]u8;
	let _: i32 = putstr("hello world!!XXXXXXXY", src[0:32], 0);

	// (srcoff, inlen, wantn, wantnomem) — wantn diverges from inlen on
	// the partial row; the overflow row writes into a now-full sink and
	// returns nomem (ref/hare/memio/stream.ha:161).
	let off:       [4]i32;
	let ln:        [4]i32;
	let wantn:     [4]i32;
	let wantnomem: [4]bool;
	off[0]=0;  ln[0]=6; wantn[0]=6; wantnomem[0]=false;	// full fit
	off[1]=6;  ln[1]=7; wantn[1]=7; wantnomem[1]=false;	// exact-fills cap (pos=13)
	off[2]=13; ln[2]=7; wantn[2]=3; wantnomem[2]=false;	// partial: 3 free
	off[3]=20; ln[3]=1; wantn[3]=0; wantnomem[3]=true;	// overflow: full sink → nomem

	let i: i32 = 0;
	for (i < 4) {
		let lo: i32 = off[i];
		let hi: i32 = lo + ln[i];
		let r: (size | io.error) = io.write(s, src[lo:hi]);
		match (r) {
		case let n: size => {
			assert(!wantnomem[i]);
			assert(!(n: i32 != wantn[i]));
		};
		case let e: io.error => {
			assert(wantnomem[i]);
			assert(e is nomem);
		};
		};
		i += 1;
	};

	let want: [16]u8;
	let _: i32 = putstr("hello world!!XXX", want[0:16], 0);
	assert(!(!bytes.equal(dst[0:16], want[0:16])));

	// 0-byte write is always 0 with no side effects.
	let r0: (size | io.error) = io.write(s, src[0:0]);
	match (r0) {
	case let n: size => { assert(!(n != 0: size)); };
	case let e: io.error => abort();
	};

	let c: (void | io.error) = io.close(s);
	match (c) { case void => {}; case let e: io.error => abort(); };
};

// A write that exactly fills the sink succeeds; any further non-empty
// write into the full sink returns nomem, not a 0-byte success
// (ref/hare/memio/stream.ha:161). A zero-length sink is full from the
// start, so its first non-empty write is already nomem.

@test fn fixedwritefull() void = {
	let buf: [4]u8;
	let st: memio.stream = memio.fixed(buf[0:4]);
	let s: io.stream = &st.vt;

	let src: [4]u8;
	let _: i32 = putstr("abcd", src[0:4], 0);

	let r4: (size | io.error) = io.write(s, src[0:4]);	// exact fill
	match (r4) {
	case let n: size => { assert(!(n != 4: size)); };
	case let e: io.error => abort();
	};

	let r1: (size | io.error) = io.write(s, src[0:1]);	// full sink
	match (r1) {
	case let n: size => abort();
	case let e: io.error => { assert(e is nomem); };
	};

	let ze: memio.stream = memio.fixed(buf[0:0]);
	let zs: io.stream = &ze.vt;
	let rz: (size | io.error) = io.write(zs, src[0:1]);	// zero-len sink
	match (rz) {
	case let n: size => abort();
	case let e: io.error => { assert(e is nomem); };
	};
};

@test fn fixedwriteoverlap() void = {
	let arr: [4]u8;
	let _: i32 = putstr("ABCD", arr[0:4], 0);
	let st: memio.stream = memio.fixed(arr[0:4]);
	let sk: (io.off | io.error) = io.seek(&st.vt, 1, io.whence.SET);
	match (sk) { case let o: io.off => {}; case let e: io.error => abort(); };
	let r: (size | io.error) = io.write(&st.vt, arr[0:3]);
	match (r) {
	case let n: size => assert(n: i32 == 3);
	case let e: io.error => abort();
	};
	let want: [4]u8;
	let _: i32 = putstr("AABC", want[0:4], 0);
	assert(bytes.equal(arr[0:4], want[0:4]));
};

// Drive grow 0 → 8 → 16 → 32 by writing sized chunks. Verify
// accumulated `pos` after each step.
@test fn dynamicgrowcases() void = {
	let st: memio.stream = memio.dynamic();
	let s: io.stream = &st.vt;

	let src: [32]u8;
	let _: i32 = putstr("abcdefghijklmnopqrstuvwxyz012345", src[0:32], 0);

	// (chunkn, totaln) — cap transitions: 0→8 at row 0; 8→16 at row 2;
	// 16→32 at row 4.
	let chunk: [5]i32;
	let total: [5]i32;
	chunk[0]=3;  total[0]=3;
	chunk[1]=5;  total[1]=8;
	chunk[2]=1;  total[2]=9;
	chunk[3]=7;  total[3]=16;
	chunk[4]=10; total[4]=26;

	let off: i32 = 0;
	let i:   i32 = 0;
	for (i < 5) {
		let lo: i32 = off;
		let hi: i32 = lo + chunk[i];
		let r: (size | io.error) = io.write(s, src[lo:hi]);
		match (r) {
		case let n: size => { assert(!(n: i32 != chunk[i])); };
		case let e: io.error => abort();
		};
		assert(!(memio.buffer(&st).len != total[i]));
		off += chunk[i];
		i += 1;
	};

	assert(!(!bytes.equal(memio.buffer(&st), src[0:26])));

	let c: (void | io.error) = io.close(s);
	match (c) { case void => {}; case let e: io.error => abort(); };
};

@test fn dynamicgrowaliasedwrite() void = {
	let seed: []u8;
	seed.ptr = nil; seed.len = 0; seed.cap = 0;
	append(seed, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H');
	let st: memio.stream = memio.dynamicfrom(seed);
	let sk: (io.off | io.error) = io.seek(&st.vt, 0, io.whence.END);
	match (sk) { case let o: io.off => {}; case let e: io.error => abort(); };
	let alias: []u8 = memio.buffer(&st);
	let r: (size | io.error) = io.write(&st.vt, alias);
	match (r) {
	case let n: size => assert(n: i32 == 8);
	case let e: io.error => abort();
	};
	let want: [16]u8;
	let _: i32 = putstr("ABCDEFGHABCDEFGH", want[0:16], 0);
	assert(alias.ptr != memio.buffer(&st).ptr);
	assert(bytes.equal(memio.buffer(&st), want[0:16]));
	let c: (void | io.error) = io.close(&st.vt);
	match (c) { case void => {}; case let e: io.error => abort(); };
};

@test fn dynamicwriteoverflow() void = {
	let st: memio.stream = memio.dynamic();
	let one: [1]u8;
	one[0] = 1u8;
	let first: (size | io.error) = io.write(&st.vt, one[0:1]);
	match (first) { case let n: size => {}; case let e: io.error => abort(); };
	let huge: []u8;
	huge.ptr = nil;
	huge.len = 2147483647;
	huge.cap = huge.len;
	let r: (size | io.error) = io.write(&st.vt, huge);
	match (r) {
	case let n: size => abort();
	case let e: io.error => assert(e is nomem);
	};
	assert(memio.buffer(&st).len == 1);
	let c: (void | io.error) = io.close(&st.vt);
	match (c) { case void => {}; case let e: io.error => abort(); };
};

// op=0 writes `ln` bytes from a rolling source; op=1 resets and ignores
// ln. After each row the accumulated len must equal `want`.
@test fn dynamicreset() void = {
	let st: memio.stream = memio.dynamic();
	let s: io.stream = &st.vt;

	let src: [16]u8;
	src[0]=10u8; src[1]=20u8; src[2]=30u8; src[3]=40u8;
	src[4]=50u8; src[5]=60u8; src[6]=70u8; src[7]=80u8;

	let op:   [6]i32;
	let ln:   [6]i32;
	let want: [6]i32;
	op[0]=0; ln[0]=5; want[0]=5;	// initial write
	op[1]=1; ln[1]=0; want[1]=0;	// reset (after writes)
	op[2]=0; ln[2]=3; want[2]=3;	// refill from 0
	op[3]=0; ln[3]=2; want[3]=5;	// continue
	op[4]=1; ln[4]=0; want[4]=0;	// reset (after partial)
	op[5]=0; ln[5]=8; want[5]=8;	// larger refill

	let off: i32 = 0;
	let i:   i32 = 0;
	for (i < 6) {
		if (op[i] == 1) {
			memio.reset(&st);
			off = 0;
		} else {
			let lo: i32 = off;
			let hi: i32 = lo + ln[i];
			let r: (size | io.error) = io.write(s, src[lo:hi]);
			match (r) {
			case let n: size => { assert(!(n: i32 != ln[i])); };
			case let e: io.error => abort();
			};
			off += ln[i];
		};
		assert(!(memio.buffer(&st).len != want[i]));
		i += 1;
	};

	assert(!(!bytes.equal(memio.buffer(&st), src[0:8])));

	let c: (void | io.error) = io.close(s);
	match (c) { case void => {}; case let e: io.error => abort(); };
};

@test fn borrowedreadcases() void = {
	let arr: [6]u8;
	arr[0]=0u8; arr[1]=1u8; arr[2]=2u8; arr[3]=3u8; arr[4]=4u8; arr[5]=5u8;

	let st: memio.stream = memio.fixed(arr[0:6]);

	// (amt, wantfirst, wantlast, weof)
	let amt:  [4]i32;
	let wf:   [4]u8;
	let wl:   [4]u8;
	let weof: [4]i32;
	amt[0]=4; wf[0]=0u8; wl[0]=3u8; weof[0]=0;	// under remaining
	amt[1]=2; wf[1]=4u8; wl[1]=5u8; weof[1]=0;	// exact remaining
	amt[2]=1; wf[2]=0u8; wl[2]=0u8; weof[2]=1;	// past end → eof
	amt[3]=0; wf[3]=0u8; wl[3]=0u8; weof[3]=0;	// 0-byte view always ok

	let i: i32 = 0;
	for (i < 4) {
		let r: ([]u8 | io.eof) = memio.borrowedread(&st, amt[i]);
		match (r) {
		case let v: []u8 => {
			assert(!(weof[i] != 0));
			assert(!(v.len != amt[i]));
			assert(v.cap == v.len);
			assert(!(v.len > 0 && v[0] != wf[i]));
			assert(!(v.len > 0 && v[v.len - 1] != wl[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		};
		i += 1;
	};
};

@test fn borrowedreadnegativeaborts() void = {
	test.expectabort();
	let arr: [1]u8;
	let st: memio.stream = memio.fixed(arr[0:1]);
	let r: ([]u8 | io.eof) = memio.borrowedread(&st, -1);
};

@test fn stringview() void = {
	let st: memio.stream = memio.dynamic();
	let s: io.stream = &st.vt;

	assert(!(memio.string(&st).len != 0));

	let src: [32]u8;
	let _: i32 = putstr("hello world!!", src[0:32], 0);

	// (srcoff, inlen, wantacc, wantfirst, wantlast)
	let off:  [3]i32;
	let ln:   [3]i32;
	let want: [3]i32;
	let wf:   [3]u8;
	let wl:   [3]u8;
	off[0]=0;  ln[0]=5; want[0]=5;  wf[0]=104u8; wl[0]=111u8;	// "hello"   h..o
	off[1]=5;  ln[1]=6; want[1]=11; wf[1]=104u8; wl[1]=100u8;	// +" world" h..d
	off[2]=11; ln[2]=2; want[2]=13; wf[2]=104u8; wl[2]=33u8;	// +"!!"     h..!

	let i: i32 = 0;
	for (i < 3) {
		let lo: i32 = off[i];
		let hi: i32 = lo + ln[i];
		let r: (size | io.error) = io.write(s, src[lo:hi]);
		match (r) { case let n: size => {}; case let e: io.error => abort(); };
		let v: str = memio.string(&st);
		assert(!(v.len != want[i]));
		assert(v.cap == v.len);
		assert(memio.buffer(&st).cap == v.len);
		assert(!(v[0] != wf[i]));
		assert(!(v[v.len - 1] != wl[i]));
		i += 1;
	};

	let c: (void | io.error) = io.close(s);
	match (c) { case void => {}; case let e: io.error => abort(); };
};

@test fn dynamicfromseed() void = {
	// Build a heap-allocated seed via append (rt_ensure path), then
	// hand ownership to memio. dynamicclose then frees `seed.cap`
	// bytes — the regression that motivated the `cap = buf.cap` fix.
	let seed: []u8;
	seed.ptr = nil; seed.len = 0; seed.cap = 0;
	append(seed, 100u8, 101u8, 102u8, 103u8);

	let st: memio.stream = memio.dynamicfrom(seed);
	let s: io.stream = &st.vt;

	// (readn, wantbyte, weof)
	let rn:   [5]i32;
	let want: [5]u8;
	let weof: [5]i32;
	rn[0]=1; want[0]=100u8; weof[0]=0;
	rn[1]=1; want[1]=101u8; weof[1]=0;
	rn[2]=1; want[2]=102u8; weof[2]=0;
	rn[3]=1; want[3]=103u8; weof[3]=0;
	rn[4]=1; want[4]=0u8;   weof[4]=1;	// past seed end → eof

	let out: [4]u8;
	let i: i32 = 0;
	for (i < 5) {
		let r: (size | io.eof | io.error) = io.read(s, out[0:rn[i]]);
		match (r) {
		case let nz: size => {
			let n: i32 = nz: i32;
			assert(!(weof[i] != 0));
			assert(!(n != rn[i]));
			assert(!(out[0] != want[i]));
		};
		case io.eof => { assert(!(weof[i] == 0)); };
		case let e: io.error => abort();
		};
		i += 1;
	};

	// Now write extends past the seed; grow path runs and close
	// must free the (post-grow) cap, not the seed cap.
	let extra: [4]u8;
	extra[0]=200u8; extra[1]=201u8; extra[2]=202u8; extra[3]=203u8;
	let w: (size | io.error) = io.write(s, extra[0:4]);
	match (w) {
	case let n: size => { assert(!(n: i32 != 4)); };
	case let e: io.error => abort();
	};

	let c: (void | io.error) = io.close(s);
	match (c) { case void => {}; case let e: io.error => abort(); };
};

// Sequential rows over one 8-byte fixed stream; CUR rows depend on the
// cursor left by earlier rows. want = resulting pos for valid rows,
// -1 = errors.invalid expected. After EVERY row an io.tell readback
// checks the cursor against a shadow `pos` — invalid rows must leave
// it untouched (ref/hare/memio/stream.ha:122-140 returns before the
// pos store).
@test fn seekcases() void = {
	let arr: [8]u8;
	arr[0]=10u8; arr[1]=11u8; arr[2]=12u8; arr[3]=13u8;
	arr[4]=14u8; arr[5]=15u8; arr[6]=16u8; arr[7]=17u8;

	// (whence, off, want)
	let wh:   [12]i32;	// 0 SET / 1 CUR / 2 END
	let off:  [12]i64;
	let want: [12]i64;
	wh[0] =0; off[0] =3;  want[0] =3;	// SET forward
	wh[1] =1; off[1] =2;  want[1] =5;	// CUR forward
	wh[2] =1; off[2] =-5; want[2] =0;	// CUR back to start
	wh[3] =2; off[3] =0;  want[3] =8;	// END exact end
	wh[4] =2; off[4] =-8; want[4] =0;	// END back to start
	wh[5] =0; off[5] =9;  want[5] =-1;	// SET past end
	wh[6] =1; off[6] =-1; want[6] =-1;	// CUR before start
	wh[7] =2; off[7] =1;  want[7] =-1;	// END past end
	wh[8] =2; off[8] =-9; want[8] =-1;	// END before start
	wh[9] =0; off[9] =8;  want[9] =8;	// SET end exact
	wh[10]=1; off[10]=0;  want[10]=8;	// CUR no-op at end
	wh[11]=0; off[11]=0;  want[11]=0;	// SET rewind

	let st: memio.stream = memio.fixed(arr[0:8]);
	let s: io.stream = &st.vt;

	let pos: i64 = 0;
	let i: i32 = 0;
	for (i < 12) {
		let w: io.whence = wh[i]: io.whence;
		let r: (io.off | io.error) = io.seek(s, off[i], w);
		match (r) {
		case let o: io.off => {
			assert(!(want[i] < 0));
			assert(!((o: i64) != want[i]));
			pos = o: i64;
		};
		case let e: io.error => {
			assert(!(want[i] >= 0));
			match (e) {
			case errors.invalid => {};
			case => abort();
			};
		};
		};
		let t: (io.off | io.error) = io.tell(s);
		match (t) {
		case let o: io.off => { assert(!((o: i64) != pos)); };
		case let e: io.error => abort();
		};
		i += 1;
	};

	// Data readback through the repositioned cursor: SET 5 then read
	// drains bytes 5..7, then eof.
	let r: (io.off | io.error) = io.seek(s, 5, io.whence.SET);
	match (r) {
	case let o: io.off => { assert(!((o: i64) != 5)); };
	case let e: io.error => abort();
	};
	let out: [8]u8;
	let rd: (size | io.eof | io.error) = io.read(s, out[0:8]);
	match (rd) {
	case let nz: size => {
		assert(!(nz: i32 != 3));
		assert(!(out[0] != 15u8));
		assert(!(out[2] != 17u8));
	};
	case io.eof => abort();
	case let e: io.error => abort();
	};
	let rd2: (size | io.eof | io.error) = io.read(s, out[0:8]);
	match (rd2) {
	case io.eof => {};
	case let nz: size => abort();
	case let e: io.error => abort();
	};
};

@test fn seekminleavescursor() void = {
	let arr: [8]u8;
	let st: memio.stream = memio.fixed(arr[0:8]);
	let set: (io.off | io.error) = io.seek(&st.vt, 3, io.whence.SET);
	match (set) { case let o: io.off => {}; case let e: io.error => abort(); };
	let min: i64 = -9223372036854775807i64 - 1i64;
	let r: (io.off | io.error) = io.seek(&st.vt, min, io.whence.CUR);
	match (r) {
	case let o: io.off => abort();
	case let e: io.error => assert(e is errors.invalid);
	};
	let pos: (io.off | io.error) = io.tell(&st.vt);
	match (pos) {
	case let o: io.off => assert((o: i64) == 3);
	case let e: io.error => abort();
	};
};

@test fn emptyseek() void = {
	let arr: [1]u8;
	arr[0] = 0u8;
	let st: memio.stream = memio.fixed(arr[0:0]);
	let s: io.stream = &st.vt;

	let wh:   [5]i32;
	let off:  [5]i64;
	let want: [5]i64;
	wh[0]=0; off[0]=0;  want[0]=0;	// SET 0 — only valid target
	wh[1]=2; off[1]=0;  want[1]=0;	// END 0 == start
	wh[2]=0; off[2]=1;  want[2]=-1;
	wh[3]=1; off[3]=-1; want[3]=-1;
	wh[4]=2; off[4]=-1; want[4]=-1;

	let i: i32 = 0;
	for (i < 5) {
		let w: io.whence = wh[i]: io.whence;
		let r: (io.off | io.error) = io.seek(s, off[i], w);
		match (r) {
		case let o: io.off => {
			assert(!(want[i] < 0));
			assert(!((o: i64) != want[i]));
		};
		case let e: io.error => {
			assert(!(want[i] >= 0));
			match (e) {
			case errors.invalid => {};
			case => abort();
			};
		};
		};
		i += 1;
	};
};

// The dynamic vtable wires the same seekfn; bounds run against the
// LOGICAL length (m.len), not capacity (Hare: len(s.buf),
// ref/hare/memio/stream.ha:131,136).
@test fn dynamicseek() void = {
	let st: memio.stream = memio.dynamic();
	let s: io.stream = &st.vt;

	let src: [5]u8;
	src[0]=30u8; src[1]=31u8; src[2]=32u8; src[3]=33u8; src[4]=34u8;
	let wr: (size | io.error) = io.write(s, src[0:5]);
	match (wr) {
	case let n: size => { assert(!(n: i32 != 5)); };
	case let e: io.error => abort();
	};

	// END 0 → 5 (logical length); cap is 8 post-grow, so END 1 must
	// still be invalid even though capacity would fit it.
	let r: (io.off | io.error) = io.seek(s, 0, io.whence.END);
	match (r) {
	case let o: io.off => { assert(!((o: i64) != 5)); };
	case let e: io.error => abort();
	};
	let r1: (io.off | io.error) = io.seek(s, 1, io.whence.END);
	match (r1) {
	case let o: io.off => abort();
	case let e: io.error => {
		match (e) {
		case errors.invalid => {};
		case => abort();
		};
	};
	};

	// CUR -2 → 3; read drains 33,34 then eof.
	let r2: (io.off | io.error) = io.seek(s, -2, io.whence.CUR);
	match (r2) {
	case let o: io.off => { assert(!((o: i64) != 3)); };
	case let e: io.error => abort();
	};
	let out: [4]u8;
	let rd: (size | io.eof | io.error) = io.read(s, out[0:4]);
	match (rd) {
	case let nz: size => {
		assert(!(nz: i32 != 2));
		assert(!(out[0] != 33u8));
		assert(!(out[1] != 34u8));
	};
	case io.eof => abort();
	case let e: io.error => abort();
	};
	let rd2: (size | io.eof | io.error) = io.read(s, out[0:4]);
	match (rd2) {
	case io.eof => {};
	case let nz: size => abort();
	case let e: io.error => abort();
	};

	let c: (void | io.error) = io.close(s);
	match (c) { case void => {}; case let e: io.error => abort(); };
};