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

lib+test: bufio rename bstream → stream

Browse Source 
Validates the #15 same-leaf-name cross-module type fix (9d85aa4):
`bufio.stream` and `io.stream` now coexist on a `use bufio; use io;`
surface — bufiotest.ww references both in the same scope (e.g.
`let m: io.stream; let b: bufio.stream;`) and compiles clean.

Lifts the bufio-side workaround that bstream existed to dodge.
@test fns rename in lockstep (bstreamsmallwrite → streamsmallwrite,
etc.). Also tidies the stale "until #21 lands" parenthetical in
test/wcc/696_modtype_leaf_collision.c, since #21 is this commit.

make test: 54/54; bootstrap fixed-point 990–997 holds.
This commit is contained in:
Hojun-Cho
2026-05-15 14:16:53 +09:00
parent e7f173cde0
commit 86de58bc6c
4 changed files with 64 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
lib/bufio/bufiotest.ww
View File

@@ -3,7 +3,7 @@
// The scanner @tests enumerate parallel `[N]T` arrays of inputs and
// expectations, then iterate one body across them. Parallel arrays
// (rather than `[N]struct{...}`) match the same cgen workaround
// memiotest leans on. The bstream @tests are one scenario per fn
// memiotest leans on. The stream @tests are one scenario per fn
// (the ww-stdlib idiom): the "table" is the fn list in main, not
// a row array.
@@ -402,15 +402,15 @@ fn closedstream(s: *io.stream) void = {
bufio.finish(&sc);
};
// ---- bstream init + flush round-trip ---------------------------------
// ---- stream init + flush round-trip ---------------------------------
@test fn bstreamsmallwrite() void = {
@test fn streamsmallwrite() void = {
let raw: [16]u8;
let mem: memio.state;
let m: io.stream;
memio.fixed(&mem, &m, raw[0:16]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [8]u8;
let wb: [8]u8;
bufio.init(&b, &m, rb[0:8], wb[0:8]);
@@ -438,13 +438,13 @@ fn closedstream(s: *io.stream) void = {
// ---- write larger than wbuf → auto-flush -----------------------------
@test fn bstreamautoflush() void = {
@test fn streamautoflush() void = {
let raw: [32]u8;
let mem: memio.state;
let m: io.stream;
memio.fixed(&mem, &m, raw[0:32]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [4]u8;
let wb: [4]u8;
bufio.init(&b, &m, rb[0:4], wb[0:4]);
@@ -478,13 +478,13 @@ fn closedstream(s: *io.stream) void = {
// the payload contains any byte from b.flush. No setflush call —
// this exercises the default. Mirrors Hare's flag::NONE default
// (ref/hare/bufio/stream.ha:75 + 100).
@test fn bstreamlineflush() void = {
@test fn streamlineflush() void = {
let raw: [32]u8;
let mem: memio.state;
let m: io.stream;
memio.fixed(&mem, &m, raw[0:32]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [4]u8;
let wb: [16]u8;
bufio.init(&b, &m, rb[0:4], wb[0:16]);
@@ -520,13 +520,13 @@ fn closedstream(s: *io.stream) void = {
// to drain after every write is a manual flush call. Setflush to
// an empty byte-set first so the default '\n' detector doesn't
// shadow what we're testing.
@test fn bstreamflushonwrite() void = {
@test fn streamflushonwrite() void = {
let raw: [32]u8;
let mem: memio.state;
let m: io.stream;
memio.fixed(&mem, &m, raw[0:32]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [4]u8;
let wb: [16]u8;
bufio.init(&b, &m, rb[0:4], wb[0:16]);
@@ -563,15 +563,15 @@ fn closedstream(s: *io.stream) void = {
if (raw[2] != 65u8) { fail(); };
};
// ---- isbuffered: bstream → true, plain memio → false -----------------
// ---- isbuffered: stream → true, plain memio → false -----------------
@test fn bstreamisbuffered() void = {
@test fn streamisbuffered() void = {
let raw: [8]u8;
let mem: memio.state;
let m: io.stream;
memio.fixed(&mem, &m, raw[0:8]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [4]u8;
let wb: [4]u8;
bufio.init(&b, &m, rb[0:4], wb[0:4]);
@@ -582,7 +582,7 @@ fn closedstream(s: *io.stream) void = {
// ---- bread + unread: pushed-back bytes come out first ----------------
@test fn bstreamunread() void = {
@test fn streamunread() void = {
let raw: [8]u8;
let n: i32 = putstr("ABCDEFGH", raw[0:8], 0);
@@ -590,7 +590,7 @@ fn closedstream(s: *io.stream) void = {
let m: io.stream;
memio.fixed(&mem, &m, raw[0:n]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [8]u8;
let wb: [4]u8;
bufio.init(&b, &m, rb[0:8], wb[0:4]);
@@ -634,14 +634,14 @@ fn closedstream(s: *io.stream) void = {
if (out[3] != 71u8) { fail(); }; // 'G'
};
// ---- scanner over a bstream-wrapped src: pre-read unread + scanline --
// ---- scanner over a stream-wrapped src: pre-read unread + scanline --
// Push three bytes into a freshly-init'd bstream (rstart=rend=rbuf.len
// Push three bytes into a freshly-init'd stream (rstart=rend=rbuf.len
// post-init, per Hare bufio/stream.ha:101 — the unread budget before
// the first read is the full rbuf), then scan a line through the
// bstream. The scanner pulls "XYZ" from rbuf first, refills "hello\n"
// stream. The scanner pulls "XYZ" from rbuf first, refills "hello\n"
// from src, and scanline returns "XYZhello".
@test fn bstreamscannerunread() void = {
@test fn streamscannerunread() void = {
let raw: [16]u8;
let n: i32 = putstr("hello\n", raw[0:16], 0);
@@ -649,7 +649,7 @@ fn closedstream(s: *io.stream) void = {
let m: io.stream;
memio.fixed(&mem, &m, raw[0:n]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [16]u8;
let wb: [4]u8;
bufio.init(&b, &m, rb[0:16], wb[0:4]);
@@ -679,13 +679,13 @@ fn closedstream(s: *io.stream) void = {
// ---- flush() on empty wbuf is a no-op --------------------------------
@test fn bstreamflushempty() void = {
@test fn streamflushempty() void = {
let raw: [8]u8;
let mem: memio.state;
let m: io.stream;
memio.fixed(&mem, &m, raw[0:8]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [4]u8;
let wb: [4]u8;
bufio.init(&b, &m, rb[0:4], wb[0:4]);
@@ -700,16 +700,16 @@ fn closedstream(s: *io.stream) void = {
// ---- bclose drains pending wbuf then forwards close to src ----------
// io.close on the bstream vtable must run the flush path (Hare
// io.close on the stream vtable must run the flush path (Hare
// stream.ha:188-202). Buffer two bytes, route io.close through the
// bstream, and confirm both reach src.
@test fn bstreamcloseflushes() void = {
// stream, and confirm both reach src.
@test fn streamcloseflushes() void = {
let raw: [8]u8;
let mem: memio.state;
let m: io.stream;
memio.fixed(&mem, &m, raw[0:8]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [4]u8;
let wb: [4]u8;
bufio.init(&b, &m, rb[0:4], wb[0:4]);
@@ -741,13 +741,13 @@ fn closedstream(s: *io.stream) void = {
// setflush installs a fresh byte-set (not just clears it). Use ' '
// (space) as the trigger; "ab cd" must flush at the space, leaving
// "cd" pending.
@test fn bstreamsetflushcustom() void = {
@test fn streamsetflushcustom() void = {
let raw: [16]u8;
let mem: memio.state;
let m: io.stream;
memio.fixed(&mem, &m, raw[0:16]);
let b: bufio.bstream;
let b: bufio.stream;
let rb: [4]u8;
let wb: [16]u8;
bufio.init(&b, &m, rb[0:4], wb[0:16]);
@@ -780,15 +780,15 @@ export fn main() i32 = {
signalled = 6; closedsource();
signalled = 7; boundarycases();
signalled = 8; multifill();
signalled = 9; bstreamsmallwrite();
signalled = 10; bstreamautoflush();
signalled = 11; bstreamlineflush();
signalled = 12; bstreamflushonwrite();
signalled = 13; bstreamisbuffered();
signalled = 14; bstreamunread();
signalled = 15; bstreamscannerunread();
signalled = 16; bstreamflushempty();
signalled = 17; bstreamcloseflushes();
signalled = 18; bstreamsetflushcustom();
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;
};