Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lib/io tests: hand-main plumbing -> assert (@test conversion B5)

Browse Source
This commit is contained in:
Hojun-Cho
2026-06-10 18:52:53 +09:00
parent 612e6d149c
commit e8096e68e1
5 changed files with 492 additions and 531 deletions
Download Patch File Download Diff File Expand all files Collapse all files

366
lib/bufio/bufiotest.ww
View File

@@ -14,20 +14,6 @@ import encoding.utf8;
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 = {
@@ -83,11 +69,11 @@ fn errsource() io.stream = {
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(); };
assert(!(weof[i] != 0));
assert(!(b != want[i]));
};
case io.eof => { if (weof[i] == 0) { fail(); }; };
case let e: io.error => fail();
case io.eof => { assert(!(weof[i] == 0)); };
case let e: io.error => abort();
};
i += 1;
};
@@ -122,14 +108,14 @@ fn errsource() io.stream = {
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(); };
assert(!(weof[i] != 0));
assert(!(wovr[i] != 0));
assert(!(v.len != wl[i]));
assert(!(v.len > 0 && v[0] != wf[i]));
};
case io.eof => { if (weof[i] == 0) { fail(); }; };
case let e: io.error => fail();
case bufio.overflow => { if (wovr[i] == 0) { fail(); }; };
case io.eof => { assert(!(weof[i] == 0)); };
case let e: io.error => abort();
case bufio.overflow => { assert(!(wovr[i] == 0)); };
};
i += 1;
};
@@ -152,9 +138,9 @@ fn errsource() io.stream = {
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 let v: str => abort();
case io.eof => abort();
case let e: io.error => abort();
case bufio.overflow => { };
};
@@ -188,13 +174,13 @@ fn errsource() io.stream = {
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(); };
assert(!(weof[i] != 0));
assert(!(v.len != wl[i]));
assert(!(v.len > 0 && v[0] != wf[i]));
};
case io.eof => { if (weof[i] == 0) { fail(); }; };
case let e: io.error => fail();
case bufio.overflow => fail();
case io.eof => { assert(!(weof[i] == 0)); };
case let e: io.error => abort();
case bufio.overflow => abort();
};
i += 1;
};
@@ -213,25 +199,25 @@ fn errsource() io.stream = {
let r1: (u8 | io.eof | io.error) = bufio.scanbyte(&sc);
match (r1) {
case let b: u8 => fail();
case let b: u8 => abort();
case io.eof => { };
case let e: io.error => fail();
case let e: io.error => abort();
};
let r2: (str | io.eof | io.error | bufio.overflow) = bufio.scanline(&sc);
match (r2) {
case let v: str => fail();
case let v: str => abort();
case io.eof => { };
case let e: io.error => fail();
case bufio.overflow => fail();
case let e: io.error => abort();
case bufio.overflow => abort();
};
let r3: ([]u8 | io.eof | io.error | bufio.overflow) = bufio.scanbytes(&sc, 10u8);
match (r3) {
case let v: []u8 => fail();
case let v: []u8 => abort();
case io.eof => { };
case let e: io.error => fail();
case bufio.overflow => fail();
case let e: io.error => abort();
case bufio.overflow => abort();
};
bufio.finish(&sc);
@@ -246,25 +232,25 @@ fn errsource() io.stream = {
let r1: (u8 | io.eof | io.error) = bufio.scanbyte(&sc);
match (r1) {
case let b: u8 => fail();
case io.eof => fail();
case let b: u8 => abort();
case io.eof => abort();
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 v: str => abort();
case io.eof => abort();
case let e: io.error => { };
case bufio.overflow => fail();
case bufio.overflow => abort();
};
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 v: []u8 => abort();
case io.eof => abort();
case let e: io.error => { };
case bufio.overflow => fail();
case bufio.overflow => abort();
};
bufio.finish(&sc);
@@ -283,20 +269,20 @@ fn errsource() io.stream = {
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();
case let v: str => { assert(!(v.len != 0)); };
case io.eof => abort();
case let e: io.error => abort();
case bufio.overflow => abort();
};
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'
assert(!(v.len != 3));
assert(!(v[0] != 102u8)); // 'f'
};
case io.eof => fail();
case let e: io.error => fail();
case bufio.overflow => fail();
case io.eof => abort();
case let e: io.error => abort();
case bufio.overflow => abort();
};
bufio.finish(&sc1);
@@ -310,17 +296,17 @@ fn errsource() io.stream = {
let t1: ([]u8 | io.eof | io.error | bufio.overflow) = bufio.scanbytes(&sc2, 44u8);
match (t1) {
case let v: []u8 => fail();
case let v: []u8 => abort();
case io.eof => { };
case let e: io.error => fail();
case bufio.overflow => fail();
case let e: io.error => abort();
case bufio.overflow => abort();
};
let t2: ([]u8 | io.eof | io.error | bufio.overflow) = bufio.scanbytes(&sc2, 44u8);
match (t2) {
case let v: []u8 => fail();
case let v: []u8 => abort();
case io.eof => { };
case let e: io.error => fail();
case bufio.overflow => fail();
case let e: io.error => abort();
case bufio.overflow => abort();
};
bufio.finish(&sc2);
};
@@ -349,13 +335,13 @@ fn errsource() io.stream = {
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(); };
assert(!(weof[i] != 0));
assert(!(v.len != wl[i]));
assert(!(v.len > 0 && v[0] != wf[i]));
};
case io.eof => { if (weof[i] == 0) { fail(); }; };
case let e: io.error => fail();
case bufio.overflow => fail();
case io.eof => { assert(!(weof[i] == 0)); };
case let e: io.error => abort();
case bufio.overflow => abort();
};
i += 1;
};
@@ -380,19 +366,19 @@ fn errsource() io.stream = {
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();
case let n: size => { assert(!(n: i32 != 5)); };
case let e: io.error => abort();
};
if (mem.pos != 0) { fail(); };
assert(!(mem.pos != 0));
let fr: (void | io.error) = bufio.flush(&b);
match (fr) {
case void => { };
case let e: io.error => fail();
case let e: io.error => abort();
};
if (mem.pos != 5) { fail(); };
if (raw[0] != 104u8) { fail(); };
if (raw[4] != 111u8) { fail(); };
assert(!(mem.pos != 5));
assert(!(raw[0] != 104u8));
assert(!(raw[4] != 111u8));
};
// ---- write larger than wbuf → auto-flush -----------------------------
@@ -412,20 +398,20 @@ fn errsource() io.stream = {
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();
case let n: size => { assert(!(n: i32 != 10)); };
case let e: io.error => abort();
};
// Two full flushes happened (8B); 2B still pending.
if (mem.pos != 8) { fail(); };
assert(!(mem.pos != 8));
let fr: (void | io.error) = bufio.flush(&b);
match (fr) {
case void => { };
case let e: io.error => fail();
case let e: io.error => abort();
};
if (mem.pos != 10) { fail(); };
if (raw[0] != 97u8) { fail(); }; // 'a'
if (raw[9] != 106u8) { fail(); }; // 'j'
assert(!(mem.pos != 10));
assert(!(raw[0] != 97u8)); // 'a'
assert(!(raw[9] != 106u8)); // 'j'
};
// ---- default flush byte-set: '\n' in payload triggers flush ---------
@@ -446,22 +432,22 @@ fn errsource() io.stream = {
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();
case let n: size => { assert(!(n: i32 != 5)); };
case let e: io.error => abort();
};
if (mem.pos != 0) { fail(); };
assert(!(mem.pos != 0));
// 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();
case let n: size => { assert(!(n: i32 != 1)); };
case let e: io.error => abort();
};
if (mem.pos != 6) { fail(); };
if (raw[0] != 104u8) { fail(); };
if (raw[5] != 10u8) { fail(); };
assert(!(mem.pos != 6));
assert(!(raw[0] != 104u8));
assert(!(raw[5] != 10u8));
};
// ---- explicit-flush-per-write: caller drives the drain ---------------
@@ -482,29 +468,29 @@ fn errsource() io.stream = {
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();
case let n: size => { assert(!(n: i32 != 2)); };
case let e: io.error => abort();
};
let f1: (void | io.error) = bufio.flush(&b);
match (f1) {
case void => { };
case let e: io.error => fail();
case let e: io.error => abort();
};
if (mem.pos != 2) { fail(); };
if (raw[0] != 65u8) { fail(); };
assert(!(mem.pos != 2));
assert(!(raw[0] != 65u8));
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();
case let n: size => { assert(!(n: i32 != 1)); };
case let e: io.error => abort();
};
let f2: (void | io.error) = bufio.flush(&b);
match (f2) {
case void => { };
case let e: io.error => fail();
case let e: io.error => abort();
};
if (mem.pos != 3) { fail(); };
if (raw[2] != 65u8) { fail(); };
assert(!(mem.pos != 3));
assert(!(raw[2] != 65u8));
};
// ---- isbuffered: stream → true, plain memio → false -----------------
@@ -518,8 +504,8 @@ fn errsource() io.stream = {
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(); };
assert(!(!bufio.isbuffered(&b.vt)));
assert(!(bufio.isbuffered(m)));
};
// ---- bread + unread: pushed-back bytes come out first ----------------
@@ -541,12 +527,12 @@ fn errsource() io.stream = {
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();
case let z: size => { assert(!(z: i32 != 3)); };
case io.eof => abort();
case let e: io.error => abort();
};
if (out[0] != 65u8) { fail(); }; // 'A'
if (out[2] != 67u8) { fail(); }; // 'C'
assert(!(out[0] != 65u8)); // 'A'
assert(!(out[2] != 67u8)); // 'C'
// Push back 2 bytes; next read returns them first.
let push: [2]u8;
@@ -555,22 +541,22 @@ fn errsource() io.stream = {
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();
case let z: size => { assert(!(z: i32 != 2)); };
case io.eof => abort();
case let e: io.error => abort();
};
if (out[0] != 88u8) { fail(); }; // 'X'
if (out[1] != 89u8) { fail(); }; // 'Y'
assert(!(out[0] != 88u8)); // 'X'
assert(!(out[1] != 89u8)); // '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();
case let z: size => { assert(!(z: i32 != 4)); };
case io.eof => abort();
case let e: io.error => abort();
};
if (out[0] != 68u8) { fail(); }; // 'D'
if (out[3] != 71u8) { fail(); }; // 'G'
assert(!(out[0] != 68u8)); // 'D'
assert(!(out[3] != 71u8)); // 'G'
};
// ---- scanner over a stream-wrapped src: pre-read unread + scanline --
@@ -597,13 +583,13 @@ fn errsource() io.stream = {
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'
assert(!(v.len != 8)); // "XYZhello"
assert(!(v[0] != 88u8)); // 'X'
assert(!(v[7] != 111u8)); // 'o'
};
case io.eof => fail();
case let e: io.error => fail();
case bufio.overflow => fail();
case io.eof => abort();
case let e: io.error => abort();
case bufio.overflow => abort();
};
bufio.finish(&sc);
};
@@ -622,9 +608,9 @@ fn errsource() io.stream = {
let r: (void | io.error) = bufio.flush(&b);
match (r) {
case void => { };
case let e: io.error => fail();
case let e: io.error => abort();
};
if (mem.pos != 0) { fail(); };
assert(!(mem.pos != 0));
};
// ---- bclose drains pending wbuf then forwards close to src ----------
@@ -645,19 +631,19 @@ fn errsource() io.stream = {
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();
case let n: size => { assert(!(n: i32 != 2)); };
case let e: io.error => abort();
};
if (mem.pos != 0) { fail(); }; // still buffered
assert(!(mem.pos != 0)); // still buffered
let cr: (void | io.error) = io.close(p);
match (cr) {
case void => { };
case let e: io.error => fail();
case let e: io.error => abort();
};
if (mem.pos != 2) { fail(); };
if (raw[0] != 80u8) { fail(); };
if (raw[1] != 81u8) { fail(); };
assert(!(mem.pos != 2));
assert(!(raw[0] != 80u8));
assert(!(raw[1] != 81u8));
};
// ---- setflush with a custom non-empty byte-set -----------------------
@@ -679,13 +665,13 @@ fn errsource() io.stream = {
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();
case let n: size => { assert(!(n: i32 != 5)); };
case let e: io.error => abort();
};
// 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'
assert(!(mem.pos != 5));
assert(!(raw[2] != 32u8));
assert(!(raw[4] != 100u8)); // 'd'
};
// ---- scanrune: ASCII + 2/3/4-byte UTF-8 + idempotent EOF --------------
@@ -720,12 +706,12 @@ fn errsource() io.stream = {
let r: (rune | io.eof | io.error | utf8.invalid) = bufio.scanrune(&sc);
match (r) {
case let rn: rune => {
if (weof[i] != 0) { fail(); };
if (rn: u32 != want[i]) { fail(); };
assert(!(weof[i] != 0));
assert(!(rn: u32 != want[i]));
};
case io.eof => { if (weof[i] == 0) { fail(); }; };
case let e: io.error => fail();
case utf8.invalid => fail();
case io.eof => { assert(!(weof[i] == 0)); };
case let e: io.error => abort();
case utf8.invalid => abort();
};
i += 1;
};
@@ -745,9 +731,9 @@ fn errsource() io.stream = {
let sc1: bufio.scanner = bufio.newscannerbuf(m1, b1[0:8]);
let r1: (rune | io.eof | io.error | utf8.invalid) = bufio.scanrune(&sc1);
match (r1) {
case let rn: rune => fail();
case io.eof => fail();
case let e: io.error => fail();
case let rn: rune => abort();
case io.eof => abort();
case let e: io.error => abort();
case utf8.invalid => { };
};
bufio.finish(&sc1);
@@ -762,9 +748,9 @@ fn errsource() io.stream = {
let sc2: bufio.scanner = bufio.newscannerbuf(m2, b2[0:8]);
let r2: (rune | io.eof | io.error | utf8.invalid) = bufio.scanrune(&sc2);
match (r2) {
case let rn: rune => fail();
case io.eof => fail();
case let e: io.error => fail();
case let rn: rune => abort();
case io.eof => abort();
case let e: io.error => abort();
case utf8.invalid => { };
};
bufio.finish(&sc2);
@@ -779,9 +765,9 @@ fn errsource() io.stream = {
let sc3: bufio.scanner = bufio.newscannerbuf(m3, b3[0:8]);
let r3: (rune | io.eof | io.error | utf8.invalid) = bufio.scanrune(&sc3);
match (r3) {
case let rn: rune => fail();
case io.eof => fail();
case let e: io.error => fail();
case let rn: rune => abort();
case io.eof => abort();
case let e: io.error => abort();
case utf8.invalid => { };
};
bufio.finish(&sc3);
@@ -811,13 +797,13 @@ fn errsource() io.stream = {
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(); };
assert(!(weof[i] != 0));
assert(!(v.len != wl[i]));
assert(!(v.len > 0 && v[0] != wf[i]));
};
case io.eof => { if (weof[i] == 0) { fail(); }; };
case let e: io.error => fail();
case bufio.overflow => fail();
case io.eof => { assert(!(weof[i] == 0)); };
case let e: io.error => abort();
case bufio.overflow => abort();
};
i += 1;
};
@@ -842,12 +828,12 @@ fn errsource() io.stream = {
let r: (rune | io.eof | io.error | utf8.invalid) = bufio.scanrune(&sc2);
match (r) {
case let rn: rune => {
if (weof2[i] != 0) { fail(); };
if (rn: u32 != want[i]) { fail(); };
assert(!(weof2[i] != 0));
assert(!(rn: u32 != want[i]));
};
case io.eof => { if (weof2[i] == 0) { fail(); }; };
case let e: io.error => fail();
case utf8.invalid => fail();
case io.eof => { assert(!(weof2[i] == 0)); };
case let e: io.error => abort();
case utf8.invalid => abort();
};
i += 1;
};
@@ -866,36 +852,36 @@ fn errsource() io.stream = {
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 let v: str => abort();
case io.eof => abort();
case let e: io.error => abort();
case bufio.overflow => { };
};
bufio.finish(&sc);
};
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();
signalled = 19; scanrunecases();
signalled = 20; scanruneinvalid();
signalled = 21; newscannergrow();
signalled = 22; newscanneroverflow();
scanbytecases();
scanlinecases();
scanlineoverflow();
scanbytescases();
emptystream();
errorsource();
boundarycases();
multifill();
streamsmallwrite();
streamautoflush();
streamlineflush();
streamflushonwrite();
streamisbuffered();
streamunread();
streamscannerunread();
streamflushempty();
streamcloseflushes();
streamsetflushcustom();
scanrunecases();
scanruneinvalid();
newscannergrow();
newscanneroverflow();
return 0;
};