// bufiotest — exercises lib/bufio. Run with `out/bin/ww run lib/bufio/bufiotest.ww`.
//
// The scanner @tests enumerate parallel `[N]T` arrays of inputs and
// expectations, then iterate one body across them. The stream @tests
// are one scenario per fn. #94 fold-eFinal: the unified value-return
// surface — `let st = memio.fixed(buf); &st.vt` into the scanner/stream
// init, io.read/write/close return size/io.error.

package bufio;

import bufio;
import bytes;
import io;
import memio;

// Direct exit(2) binding rather than `use os;` — os exports
// read/write/close, which collide with io.read/write/close under
// the driver's flat-scope concat.
@symbol("rt_syscall") fn syscall1ww(num: i64, a: i64) i64;
fn doexit(code: i32) void = {
	syscall1ww(60i64, code: i64);
};

// signalled — bumped by main before each test so a failing exit code
// pinpoints the offending case.
let signalled: i32 = 0;

fn fail() void = { doexit(signalled + 10); };

// putstr — copy the bytes of `s` into `into` starting at `off`,
// returning the new offset.
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;
};

// ---- an error-returning stream for the io.error surfacing test --------
//
// Replaces the OLD io.closed source. errvt is module-static; its
// reader/writer return a nomem-widened io.error.
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;
};

// ---- scanbyte: drain four bytes through a 2-byte window ---------------

@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) = bufio.scanbyte(&sc);
		match (r) {
		case let b: u8 => {
			if (weof[i] != 0) { fail(); };
			if (b != want[i]) { fail(); };
		};
		case io.eof => { if (weof[i] == 0) { fail(); }; };
		case let e: io.error => fail();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

// ---- scanline: 3 lines + tail fragment + extra calls stay at EOF ------

@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 | bufio.overflow) = bufio.scanline(&sc);
		match (r) {
		case let v: str => {
			if (weof[i] != 0) { fail(); };
			if (wovr[i] != 0) { fail(); };
			if (v.len != wl[i]) { fail(); };
			if (v.len > 0 && v[0] != wf[i]) { fail(); };
		};
		case io.eof => { if (weof[i] == 0) { fail(); }; };
		case let e: io.error => fail();
		case bufio.overflow => { if (wovr[i] == 0) { fail(); }; };
		};
		i += 1;
	};

	bufio.finish(&sc);
};

// ---- scanline: line longer than buffer → overflow --------------------

@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 | bufio.overflow) = bufio.scanline(&sc);
	match (r) {
	case let v: str => fail();
	case io.eof => fail();
	case let e: io.error => fail();
	case bufio.overflow => { };
	};

	bufio.finish(&sc);
};

// ---- scanbytes: multi-delim hit, delim-at-start, EOF before delim ----

@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 | bufio.overflow) = bufio.scanbytes(&sc, 44u8);	// ','
		match (r) {
		case let v: []u8 => {
			if (weof[i] != 0) { fail(); };
			if (v.len != wl[i]) { fail(); };
			if (v.len > 0 && v[0] != wf[i]) { fail(); };
		};
		case io.eof => { if (weof[i] == 0) { fail(); }; };
		case let e: io.error => fail();
		case bufio.overflow => fail();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

// ---- empty stream: every variant returns eof immediately --------------

@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) = bufio.scanbyte(&sc);
	match (r1) {
	case let b: u8 => fail();
	case io.eof => { };
	case let e: io.error => fail();
	};

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

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

	bufio.finish(&sc);
};

// ---- io.error surfacing on a stream that returns error ----------------

@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) = bufio.scanbyte(&sc);
	match (r1) {
	case let b: u8 => fail();
	case io.eof => fail();
	case let e: io.error => { };
	};

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

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

	bufio.finish(&sc);
};

// ---- boundary: empty line + idempotent EOF on scanbytes --------------

@test fn boundarycases() void = {
	// ---- empty line via scanline -----------------------------------
	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 | bufio.overflow) = bufio.scanline(&sc1);
	match (r1) {
	case let v: str => { if (v.len != 0) { fail(); }; };
	case io.eof => fail();
	case let e: io.error => fail();
	case bufio.overflow => fail();
	};
	let r2: (str | io.eof | io.error | bufio.overflow) = bufio.scanline(&sc1);
	match (r2) {
	case let v: str => {
		if (v.len != 3) { fail(); };
		if (v[0] != 102u8) { fail(); };	// 'f'
	};
	case io.eof => fail();
	case let e: io.error => fail();
	case bufio.overflow => fail();
	};
	bufio.finish(&sc1);

	// ---- scanbytes idempotent EOF ---------------------------------
	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 | bufio.overflow) = bufio.scanbytes(&sc2, 44u8);
	match (t1) {
	case let v: []u8 => fail();
	case io.eof => { };
	case let e: io.error => fail();
	case bufio.overflow => fail();
	};
	let t2: ([]u8 | io.eof | io.error | bufio.overflow) = bufio.scanbytes(&sc2, 44u8);
	match (t2) {
	case let v: []u8 => fail();
	case io.eof => { };
	case let e: io.error => fail();
	case bufio.overflow => fail();
	};
	bufio.finish(&sc2);
};

// ---- multi-fill: window smaller than longest token, shift path --------

@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 | bufio.overflow) = bufio.scanline(&sc);
		match (r) {
		case let v: str => {
			if (weof[i] != 0) { fail(); };
			if (v.len != wl[i]) { fail(); };
			if (v.len > 0 && v[0] != wf[i]) { fail(); };
		};
		case io.eof => { if (weof[i] == 0) { fail(); }; };
		case let e: io.error => fail();
		case bufio.overflow => fail();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

// ---- stream init + flush round-trip ---------------------------------

@test fn streamsmallwrite() void = {
	let raw: [16]u8;
	let mem: memio.stream = memio.fixed(raw[0:16]);
	let m:   io.stream = &mem.vt;

	let rb: [8]u8;
	let wb: [8]u8;
	let b: bufio.stream = bufio.init(m, rb[0:8], wb[0:8]);

	// Write under the buffer limit — nothing reaches src.
	let buf: [5]u8;
	let z: i32 = putstr("hello", buf[0:5], 0);
	let p: io.stream = &b.vt;
	let r: (size | io.error) = io.write(p, buf[0:5]);
	match (r) {
	case let n: size => { if (n: i32 != 5) { fail(); }; };
	case let e: io.error => fail();
	};
	if (mem.pos != 0) { fail(); };

	let fr: (void | io.error) = bufio.flush(&b);
	match (fr) {
	case void => { };
	case let e: io.error => fail();
	};
	if (mem.pos != 5) { fail(); };
	if (raw[0] != 104u8) { fail(); };
	if (raw[4] != 111u8) { fail(); };
};

// ---- write larger than wbuf → auto-flush -----------------------------

@test fn streamautoflush() void = {
	let raw: [32]u8;
	let mem: memio.stream = memio.fixed(raw[0:32]);
	let m:   io.stream = &mem.vt;

	let rb: [4]u8;
	let wb: [4]u8;
	let b: bufio.stream = bufio.init(m, rb[0:4], wb[0:4]);

	// 10B payload through a 4B wbuf: bwrite must flush twice mid-write.
	let buf: [10]u8;
	let z: i32 = putstr("abcdefghij", buf[0:10], 0);
	let p: io.stream = &b.vt;
	let r: (size | io.error) = io.write(p, buf[0:10]);
	match (r) {
	case let n: size => { if (n: i32 != 10) { fail(); }; };
	case let e: io.error => fail();
	};
	// Two full flushes happened (8B); 2B still pending.
	if (mem.pos != 8) { fail(); };

	let fr: (void | io.error) = bufio.flush(&b);
	match (fr) {
	case void => { };
	case let e: io.error => fail();
	};
	if (mem.pos != 10) { fail(); };
	if (raw[0] != 97u8) { fail(); };	// 'a'
	if (raw[9] != 106u8) { fail(); };	// 'j'
};

// ---- default flush byte-set: '\n' in payload triggers flush ---------

@test fn streamlineflush() void = {
	let raw: [32]u8;
	let mem: memio.stream = memio.fixed(raw[0:32]);
	let m:   io.stream = &mem.vt;

	let rb: [4]u8;
	let wb: [16]u8;
	let b: bufio.stream = bufio.init(m, rb[0:4], wb[0:16]);

	let p: io.stream = &b.vt;

	// First write: no '\n', stays buffered.
	let h: [5]u8;
	let zh: i32 = putstr("hello", h[0:5], 0);
	let r1: (size | io.error) = io.write(p, h[0:5]);
	match (r1) {
	case let n: size => { if (n: i32 != 5) { fail(); }; };
	case let e: io.error => fail();
	};
	if (mem.pos != 0) { fail(); };

	// Second write: '\n' present, triggers flush of everything (6B).
	let nl: [1]u8;
	nl[0] = 10u8;
	let r2: (size | io.error) = io.write(p, nl[0:1]);
	match (r2) {
	case let n: size => { if (n: i32 != 1) { fail(); }; };
	case let e: io.error => fail();
	};
	if (mem.pos != 6) { fail(); };
	if (raw[0] != 104u8) { fail(); };
	if (raw[5] != 10u8) { fail(); };
};

// ---- explicit-flush-per-write: caller drives the drain ---------------

@test fn streamflushonwrite() void = {
	let raw: [32]u8;
	let mem: memio.stream = memio.fixed(raw[0:32]);
	let m:   io.stream = &mem.vt;

	let rb: [4]u8;
	let wb: [16]u8;
	let b: bufio.stream = bufio.init(m, rb[0:4], wb[0:16]);
	let nilbs: [1]u8;
	bufio.setflush(&b, nilbs[0:0]);

	let p: io.stream = &b.vt;
	let h: [2]u8;
	h[0] = 65u8; h[1] = 66u8;	// "AB"
	let r1: (size | io.error) = io.write(p, h[0:2]);
	match (r1) {
	case let n: size => { if (n: i32 != 2) { fail(); }; };
	case let e: io.error => fail();
	};
	let f1: (void | io.error) = bufio.flush(&b);
	match (f1) {
	case void => { };
	case let e: io.error => fail();
	};
	if (mem.pos != 2) { fail(); };
	if (raw[0] != 65u8) { fail(); };

	let r2: (size | io.error) = io.write(p, h[0:1]);
	match (r2) {
	case let n: size => { if (n: i32 != 1) { fail(); }; };
	case let e: io.error => fail();
	};
	let f2: (void | io.error) = bufio.flush(&b);
	match (f2) {
	case void => { };
	case let e: io.error => fail();
	};
	if (mem.pos != 3) { fail(); };
	if (raw[2] != 65u8) { fail(); };
};

// ---- isbuffered: stream → true, plain memio → false -----------------

@test fn streamisbuffered() void = {
	let raw: [8]u8;
	let mem: memio.stream = memio.fixed(raw[0:8]);
	let m:   io.stream = &mem.vt;

	let rb: [4]u8;
	let wb: [4]u8;
	let b: bufio.stream = bufio.init(m, rb[0:4], wb[0:4]);

	if (!bufio.isbuffered(&b.vt)) { fail(); };
	if (bufio.isbuffered(m)) { fail(); };
};

// ---- bread + unread: pushed-back bytes come out first ----------------

@test fn streamunread() void = {
	let raw: [8]u8;
	let n: i32 = putstr("ABCDEFGH", raw[0:8], 0);

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

	let rb: [8]u8;
	let wb: [4]u8;
	let b: bufio.stream = bufio.init(m, rb[0:8], wb[0:4]);

	let p: io.stream = &b.vt;

	// Pull 3 bytes through bread — fills rbuf from src (8B), serves 3.
	let out: [4]u8;
	let r1: (size | io.eof | io.error) = io.read(p, out[0:3]);
	match (r1) {
	case let z: size => { if (z: i32 != 3) { fail(); }; };
	case io.eof => fail();
	case let e: io.error => fail();
	};
	if (out[0] != 65u8) { fail(); };	// 'A'
	if (out[2] != 67u8) { fail(); };	// 'C'

	// Push back 2 bytes; next read returns them first.
	let push: [2]u8;
	push[0] = 88u8; push[1] = 89u8;	// "XY"
	bufio.unread(&b, push[0:2]);

	let r2: (size | io.eof | io.error) = io.read(p, out[0:2]);
	match (r2) {
	case let z: size => { if (z: i32 != 2) { fail(); }; };
	case io.eof => fail();
	case let e: io.error => fail();
	};
	if (out[0] != 88u8) { fail(); };	// 'X'
	if (out[1] != 89u8) { fail(); };	// 'Y'

	// Subsequent read returns the original tail.
	let r3: (size | io.eof | io.error) = io.read(p, out[0:4]);
	match (r3) {
	case let z: size => { if (z: i32 != 4) { fail(); }; };
	case io.eof => fail();
	case let e: io.error => fail();
	};
	if (out[0] != 68u8) { fail(); };	// 'D'
	if (out[3] != 71u8) { fail(); };	// 'G'
};

// ---- scanner over a stream-wrapped src: pre-read unread + scanline --

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

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

	let rb: [16]u8;
	let wb: [4]u8;
	let b: bufio.stream = bufio.init(m, rb[0:16], wb[0:4]);

	let push: [3]u8;
	push[0] = 88u8; push[1] = 89u8; push[2] = 90u8;	// "XYZ"
	bufio.unread(&b, push[0:3]);

	let p: io.stream = &b.vt;
	let sbuf: [32]u8;
	let sc:   bufio.scanner = bufio.newscannerbuf(p, sbuf[0:32]);

	let lr: (str | io.eof | io.error | bufio.overflow) = bufio.scanline(&sc);
	match (lr) {
	case let v: str => {
		if (v.len != 8) { fail(); };	// "XYZhello"
		if (v[0] != 88u8) { fail(); };	// 'X'
		if (v[7] != 111u8) { fail(); };	// 'o'
	};
	case io.eof => fail();
	case let e: io.error => fail();
	case bufio.overflow => fail();
	};
	bufio.finish(&sc);
};

// ---- flush() on empty wbuf is a no-op --------------------------------

@test fn streamflushempty() void = {
	let raw: [8]u8;
	let mem: memio.stream = memio.fixed(raw[0:8]);
	let m:   io.stream = &mem.vt;

	let rb: [4]u8;
	let wb: [4]u8;
	let b: bufio.stream = bufio.init(m, rb[0:4], wb[0:4]);

	let r: (void | io.error) = bufio.flush(&b);
	match (r) {
	case void => { };
	case let e: io.error => fail();
	};
	if (mem.pos != 0) { fail(); };
};

// ---- bclose drains pending wbuf then forwards close to src ----------

@test fn streamcloseflushes() void = {
	let raw: [8]u8;
	let mem: memio.stream = memio.fixed(raw[0:8]);
	let m:   io.stream = &mem.vt;

	let rb: [4]u8;
	let wb: [4]u8;
	let b: bufio.stream = bufio.init(m, rb[0:4], wb[0:4]);
	let nilbs: [1]u8;
	bufio.setflush(&b, nilbs[0:0]);	// suppress the default '\n' detector

	let p: io.stream = &b.vt;
	let h: [2]u8;
	h[0] = 80u8; h[1] = 81u8;	// "PQ"
	let r: (size | io.error) = io.write(p, h[0:2]);
	match (r) {
	case let n: size => { if (n: i32 != 2) { fail(); }; };
	case let e: io.error => fail();
	};
	if (mem.pos != 0) { fail(); };	// still buffered

	let cr: (void | io.error) = io.close(p);
	match (cr) {
	case void => { };
	case let e: io.error => fail();
	};
	if (mem.pos != 2) { fail(); };
	if (raw[0] != 80u8) { fail(); };
	if (raw[1] != 81u8) { fail(); };
};

// ---- setflush with a custom non-empty byte-set -----------------------

@test fn streamsetflushcustom() void = {
	let raw: [16]u8;
	let mem: memio.stream = memio.fixed(raw[0:16]);
	let m:   io.stream = &mem.vt;

	let rb: [4]u8;
	let wb: [16]u8;
	let b: bufio.stream = bufio.init(m, rb[0:4], wb[0:16]);
	let bs: [1]u8;
	bs[0] = 32u8;	// ' '
	bufio.setflush(&b, bs[0:1]);

	let p: io.stream = &b.vt;
	let buf: [5]u8;
	let z: i32 = putstr("ab cd", buf[0:5], 0);
	let r: (size | io.error) = io.write(p, buf[0:5]);
	match (r) {
	case let n: size => { if (n: i32 != 5) { fail(); }; };
	case let e: io.error => fail();
	};
	// Space at index 2 triggers post-copy flush of all 5 bytes.
	if (mem.pos != 5) { fail(); };
	if (raw[2] != 32u8) { fail(); };
	if (raw[4] != 100u8) { fail(); };	// 'd'
};

export fn main() i32 = {
	signalled = 1;  scanbytecases();
	signalled = 2;  scanlinecases();
	signalled = 3;  scanlineoverflow();
	signalled = 4;  scanbytescases();
	signalled = 5;  emptystream();
	signalled = 6;  errorsource();
	signalled = 7;  boundarycases();
	signalled = 8;  multifill();
	signalled = 9;  streamsmallwrite();
	signalled = 10; streamautoflush();
	signalled = 11; streamlineflush();
	signalled = 12; streamflushonwrite();
	signalled = 13; streamisbuffered();
	signalled = 14; streamunread();
	signalled = 15; streamscannerunread();
	signalled = 16; streamflushempty();
	signalled = 17; streamcloseflushes();
	signalled = 18; streamsetflushcustom();
	return 0;
};