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

lib: split log tests into funcs+global per ref/hare/log

Browse Source 
Pure move: log_test.ww dissolves along its banner seams into
funcs_test.ww (the six logger-arg rows — lprintlnbasic/single/empty,
lprintflnbasic/indexed/mods — plus the fatal-family subprocess TODO;
ref/hare/log/funcs.ha owns lprintln/lprintfln and the fatal/lfatal
forms) and global_test.ww (defaultwiredtoglobal, setloggerswap,
printflnglobal; ref/hare/log/global.ha owns default/global/setlogger).
Moved blocks are byte-identical; the 9 banner lines are deleted.
Imports minimized per file (log + memio; the stale fmt/io imports
drop).

Helper inventory: streq spans both halves (all six funcs rows;
setloggerswap + printflnglobal on the global side), so it is
duplicated under per-file names per the sanctioned strconv
streq/fstreq precedent — fstreq in funcs_test.ww (decl + 6 call
sites), gstreq in global_test.ww (decl + 6 call sites); bodies
byte-identical apart from the name. Line-multiset diff old-vs-concat
(heads/banners excluded, names normalized): the only residue is the
9-line streq helper counted twice.

Order-safety, proven on the composed run: dir-mode executes
declaration order per file, files byte-lexicographic (funcs_test <
global_test < silent_test). Observed order: lprintlnbasic,
lprintlnsingle, lprintlnempty, lprintflnbasic, lprintflnindexed,
lprintflnmods, defaultwiredtoglobal, setloggerswap, printflnglobal,
silentwritesnothing, silentignoresprintfln — defaultwiredtoglobal
still precedes every log.setlogger caller (setloggerswap and
printflnglobal, both later in its own file; funcs and silent rows
never call setlogger).

Consumers: Makefile LIBRARY_TESTS replaces the log_test.ww entry with
the two new entries in place; test/byteid/libbyteid_test.ww roster row
becomes two fx rows, NENTEXPECT 59->60.

Validation: standalone ww test lib/log/funcs_test.ww (6 passed) and
lib/log/global_test.ww (3 passed); dir mode ww test lib/log (11
passed, no duplicate symbols); byteid compile-only build exit 0, 60
roster appends == NENTEXPECT.
This commit is contained in:
Hojun-Cho
2026-08-08 17:34:00 +09:00
parent 291860ddef
commit 53919b3404
5 changed files with 205 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@@ -496,7 +496,8 @@ LIBRARY_TESTS = lib/errors/errno_test.ww lib/ascii/ascii_test.ww \
lib/bufio/stream_test.ww lib/bufio/scanner_test.ww \ lib/bufio/stream_test.ww lib/bufio/scanner_test.ww \
lib/math/random/random_test.ww \ lib/math/random/random_test.ww \
lib/math/checked/checked_test.ww lib/fmt/fmt_test.ww \ lib/math/checked/checked_test.ww lib/fmt/fmt_test.ww \
lib/log/log_test.ww lib/log/silent_test.ww lib/fnmatch/fnmatch_test.ww \ lib/log/funcs_test.ww lib/log/global_test.ww \
lib/log/silent_test.ww lib/fnmatch/fnmatch_test.ww \
lib/shlex/shlex_test.ww lib/time/arithm_test.ww \ lib/shlex/shlex_test.ww lib/time/arithm_test.ww \
lib/time/duration_test.ww lib/time/instant_test.ww \ lib/time/duration_test.ww lib/time/instant_test.ww \
lib/encoding/hex/hex_test.ww lib/memio/memio_test.ww \ lib/encoding/hex/hex_test.ww lib/memio/memio_test.ww \

104
lib/log/funcs_test.ww Normal file
View File

@@ -0,0 +1,104 @@
// funcstest — exercises the logger-arg print family (lprintln /
// lprintfln) per ref/hare/log/funcs.ha ownership. Each scenario
// constructs a stdlogger over a memio.stream and asserts the bytes
// the logger produced. No row here touches log.setlogger, so these
// rows are order-independent of the global-wiring rows in
// global_test.ww.
package log_test;
import log;
import memio;
fn fstreq(a: str, b: str) bool = {
if (a.len != b.len) { return false; };
let i: i32 = 0;
for (i < a.len) {
if (a[i] != b[i]) { return false; };
i += 1;
};
return true;
};
@test fn lprintlnbasic() void = {
let buf: [32]u8;
let mem = memio.fixed(buf[0:32]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintln(&sl.logger, "hello", 42i64);
assert(!(!fstreq(memio.string(&mem), "hello 42\n")));
};
@test fn lprintlnsingle() void = {
let buf: [16]u8;
let mem = memio.fixed(buf[0:16]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintln(&sl.logger, "only");
assert(!(!fstreq(memio.string(&mem), "only\n")));
};
@test fn lprintlnempty() void = {
let buf: [4]u8;
let mem = memio.fixed(buf[0:4]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintln(&sl.logger);
assert(!(!fstreq(memio.string(&mem), "\n")));
};
@test fn lprintflnbasic() void = {
let buf: [32]u8;
let mem = memio.fixed(buf[0:32]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintfln(&sl.logger, "x={} y={}", 42i64, "hi");
assert(!(!fstreq(memio.string(&mem), "x=42 y=hi\n")));
};
// The fmt parser proper is covered in fmttest; this pins that log's
// variadic forwarding propagates argv order so indexed placeholders
// resolve correctly.
@test fn lprintflnindexed() void = {
let buf: [16]u8;
let mem = memio.fixed(buf[0:16]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintfln(&sl.logger, "{1} {0}", "a", "b");
assert(!(!fstreq(memio.string(&mem), "b a\n")));
};
// Pins that mod-bearing placeholders flow through log's forwarding
// intact (parser proper covered in fmttest).
@test fn lprintflnmods() void = {
let buf: [16]u8;
let mem = memio.fixed(buf[0:16]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintfln(&sl.logger, "{:5}", 42i64);
assert(!(!fstreq(memio.string(&mem), " 42\n")));
};
// TODO subprocess: log.fatal / log.lfatal / log.fatalf / log.lfatalf
// exit(255). Verifying them needs a fork+wait fixture so the parent
// can assert WEXITSTATUS == 255 without the test process itself
// terminating. lib/os doesn't ship process spawning yet; revisit
// when that lands.

95
lib/log/global_test.ww Normal file
View File

@@ -0,0 +1,95 @@
// globaltest — exercises the global-logger wiring (default / global /
// setlogger) per ref/hare/log/global.ha ownership. Each scenario
// constructs stdloggers over memio.streams and asserts the bytes the
// global dispatch produced. defaultwiredtoglobal must stay the first
// @test row: it pins the pristine global == default wiring that every
// later setlogger caller mutates. Composed dir-mode execution is
// declaration order per file, files in byte-lexicographic order
// (funcs_test < global_test < silent_test), and no funcs/silent row
// calls setlogger.
package log_test;
import log;
import memio;
fn gstreq(a: str, b: str) bool = {
if (a.len != b.len) { return false; };
let i: i32 = 0;
for (i < a.len) {
if (a[i] != b[i]) { return false; };
i += 1;
};
return true;
};
// log.default writes to stderr through the private stderrsink — we
// can't easily capture stderr from inside the test, so this scenario
// verifies the initial wiring only: after lazy [[ensureinit]] runs,
// [[log.default]] / [[log.silent]] are non-nil and [[log.global]]
// equals [[log.default]]. The check is order-sensitive: any later
// scenario that calls [[log.setlogger]] mutates the global, so this
// scenario must run before [[setloggerswap]].
@test fn defaultwiredtoglobal() void = {
let buf: [4]u8;
let mem = memio.fixed(buf[0:4]);
let s = &mem.vt;
let sl = log.new(s); // triggers ensureinit
assert(!(log.silent == nil));
assert(!(log.default == nil));
assert(!(log.global == nil));
assert(!(log.global != log.default));
};
// Three-phase: install sl1 as global, println writes there; swap to
// sl2, println writes there only; swap to silent, println discards.
// Each memio sink starts empty and is asserted at each phase to pin
// the swap semantics.
@test fn setloggerswap() void = {
let buf1: [32]u8;
let mem1 = memio.fixed(buf1[0:32]);
let s1 = &mem1.vt;
let sl1 = log.new(s1);
let buf2: [32]u8;
let mem2 = memio.fixed(buf2[0:32]);
let s2 = &mem2.vt;
let sl2 = log.new(s2);
log.setlogger(&sl1.logger);
log.println("first");
assert(!(!gstreq(memio.string(&mem1), "first\n")));
assert(!(mem2.pos != 0));
log.setlogger(&sl2.logger);
log.println("second");
assert(!(!gstreq(memio.string(&mem2), "second\n")));
// mem1 must be unchanged.
assert(!(!gstreq(memio.string(&mem1), "first\n")));
log.setlogger(log.silent);
log.println("dropped");
// Both sinks unchanged.
assert(!(!gstreq(memio.string(&mem1), "first\n")));
assert(!(!gstreq(memio.string(&mem2), "second\n")));
};
// Mirrors [[setloggerswap]] but exercises the format-string path:
// install sl1 as global, printfln writes there; mem2 stays empty.
@test fn printflnglobal() void = {
let buf1: [32]u8;
let mem1 = memio.fixed(buf1[0:32]);
let s1 = &mem1.vt;
let sl1 = log.new(s1);
let buf2: [32]u8;
let mem2 = memio.fixed(buf2[0:32]);
let s2 = &mem2.vt;
let sl2 = log.new(s2);
log.setlogger(&sl1.logger);
log.printfln("v={}", 7i64);
assert(!(!gstreq(memio.string(&mem1), "v=7\n")));
assert(!(mem2.pos != 0));
};

199
lib/log/log_test.ww
View File

@@ -1,199 +0,0 @@
// logtest — exercises lib/log. Run with `out/bin/ww run lib/log/logtest.ww`.
//
// One scenario per @test fn (the ww-stdlib idiom): each scenario
// constructs a stdlogger over a memio.stream and asserts the bytes
// the logger produced. The test surface mirrors what drew called out
// in the design read: lprintln-to-memio, silent-writes-nothing, and
// setlogger-swap. The process-terminating arm ([[log.fatal]] /
// [[log.lfatal]]) needs a subprocess to verify exit(255) without
// killing the test driver — left as a TODO until the project grows
// a subprocess fixture.
package log_test;
import fmt;
import io;
import log;
import memio;
fn streq(a: str, b: str) bool = {
if (a.len != b.len) { return false; };
let i: i32 = 0;
for (i < a.len) {
if (a[i] != b[i]) { return false; };
i += 1;
};
return true;
};
// ---- default points at global after init (must run first) ------------
// log.default writes to stderr through the private stderrsink — we
// can't easily capture stderr from inside the test, so this scenario
// verifies the initial wiring only: after lazy [[ensureinit]] runs,
// [[log.default]] / [[log.silent]] are non-nil and [[log.global]]
// equals [[log.default]]. The check is order-sensitive: any later
// scenario that calls [[log.setlogger]] mutates the global, so this
// scenario must run before [[setloggerswap]].
@test fn defaultwiredtoglobal() void = {
let buf: [4]u8;
let mem = memio.fixed(buf[0:4]);
let s = &mem.vt;
let sl = log.new(s); // triggers ensureinit
assert(!(log.silent == nil));
assert(!(log.default == nil));
assert(!(log.global == nil));
assert(!(log.global != log.default));
};
// ---- lprintln to a memio sink: exact-byte assertion -------------------
@test fn lprintlnbasic() void = {
let buf: [32]u8;
let mem = memio.fixed(buf[0:32]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintln(&sl.logger, "hello", 42i64);
assert(!(!streq(memio.string(&mem), "hello 42\n")));
};
// ---- lprintln single-arg: no leading space, just trailing newline -----
@test fn lprintlnsingle() void = {
let buf: [16]u8;
let mem = memio.fixed(buf[0:16]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintln(&sl.logger, "only");
assert(!(!streq(memio.string(&mem), "only\n")));
};
// ---- lprintln zero args: bare newline ---------------------------------
@test fn lprintlnempty() void = {
let buf: [4]u8;
let mem = memio.fixed(buf[0:4]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintln(&sl.logger);
assert(!(!streq(memio.string(&mem), "\n")));
};
// ---- setlogger swap: global redirects to a new sink, then to silent --
// Three-phase: install sl1 as global, println writes there; swap to
// sl2, println writes there only; swap to silent, println discards.
// Each memio sink starts empty and is asserted at each phase to pin
// the swap semantics.
@test fn setloggerswap() void = {
let buf1: [32]u8;
let mem1 = memio.fixed(buf1[0:32]);
let s1 = &mem1.vt;
let sl1 = log.new(s1);
let buf2: [32]u8;
let mem2 = memio.fixed(buf2[0:32]);
let s2 = &mem2.vt;
let sl2 = log.new(s2);
log.setlogger(&sl1.logger);
log.println("first");
assert(!(!streq(memio.string(&mem1), "first\n")));
assert(!(mem2.pos != 0));
log.setlogger(&sl2.logger);
log.println("second");
assert(!(!streq(memio.string(&mem2), "second\n")));
// mem1 must be unchanged.
assert(!(!streq(memio.string(&mem1), "first\n")));
log.setlogger(log.silent);
log.println("dropped");
// Both sinks unchanged.
assert(!(!streq(memio.string(&mem1), "first\n")));
assert(!(!streq(memio.string(&mem2), "second\n")));
};
// ---- lprintfln: {n}-placeholder render into a memio sink -------------
@test fn lprintflnbasic() void = {
let buf: [32]u8;
let mem = memio.fixed(buf[0:32]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintfln(&sl.logger, "x={} y={}", 42i64, "hi");
assert(!(!streq(memio.string(&mem), "x=42 y=hi\n")));
};
// ---- printfln through global: setlogger then dispatch ---------------
// Mirrors [[setloggerswap]] but exercises the format-string path:
// install sl1 as global, printfln writes there; mem2 stays empty.
@test fn printflnglobal() void = {
let buf1: [32]u8;
let mem1 = memio.fixed(buf1[0:32]);
let s1 = &mem1.vt;
let sl1 = log.new(s1);
let buf2: [32]u8;
let mem2 = memio.fixed(buf2[0:32]);
let s2 = &mem2.vt;
let sl2 = log.new(s2);
log.setlogger(&sl1.logger);
log.printfln("v={}", 7i64);
assert(!(!streq(memio.string(&mem1), "v=7\n")));
assert(!(mem2.pos != 0));
};
// ---- lprintfln: indexed {N} placeholder across log → fmt seam -------
// The fmt parser proper is covered in fmttest; this pins that log's
// variadic forwarding propagates argv order so indexed placeholders
// resolve correctly.
@test fn lprintflnindexed() void = {
let buf: [16]u8;
let mem = memio.fixed(buf[0:16]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintfln(&sl.logger, "{1} {0}", "a", "b");
assert(!(!streq(memio.string(&mem), "b a\n")));
};
// ---- lprintfln: {:mods} modifier across log → fmt seam --------------
// Pins that mod-bearing placeholders flow through log's forwarding
// intact (parser proper covered in fmttest).
@test fn lprintflnmods() void = {
let buf: [16]u8;
let mem = memio.fixed(buf[0:16]);
let s = &mem.vt;
let sl = log.new(s);
log.lprintfln(&sl.logger, "{:5}", 42i64);
assert(!(!streq(memio.string(&mem), " 42\n")));
};
// TODO subprocess: log.fatal / log.lfatal / log.fatalf / log.lfatalf
// exit(255). Verifying them needs a fork+wait fixture so the parent
// can assert WEXITSTATUS == 255 without the test process itself
// terminating. lib/os doesn't ship process spawning yet; revisit
// when that lands.

7
test/byteid/libbyteid_test.ww
View File

@@ -43,7 +43,7 @@ import time;
def MID: i32 = 0; def MID: i32 = 0;
def MDIVERGE: i32 = 1; def MDIVERGE: i32 = 1;
def MWWREJECT: i32 = 2; def MWWREJECT: i32 = 2;
def NENTEXPECT: i32 = 59; def NENTEXPECT: i32 = 60;
type ent = struct { type ent = struct {
fixture: str, // repo-relative .ww; "" -> probe entry fixture: str, // repo-relative .ww; "" -> probe entry
@@ -83,7 +83,7 @@ fn pri(p: str, inc: str, sentinel: str, moddir: str) ent = {
return e; return e;
}; };
// The 59-unit roster. Graduation history lives in git (the retired C // The 60-unit roster. Graduation history lives in git (the retired C
// carrier's table comments); cites are kept only where a non-ID pin // carrier's table comments); cites are kept only where a non-ID pin
// would need them. // would need them.
fn corpus() []ent = { fn corpus() []ent = {
@@ -155,7 +155,8 @@ fn corpus() []ent = {
append(es, fx("lib/ascii/ascii_test.ww")); append(es, fx("lib/ascii/ascii_test.ww"));
append(es, fx("lib/encoding/base64/base64_test.ww")); append(es, fx("lib/encoding/base64/base64_test.ww"));
append(es, fx("lib/errors/errno_test.ww")); append(es, fx("lib/errors/errno_test.ww"));
append(es, fx("lib/log/log_test.ww")); append(es, fx("lib/log/funcs_test.ww"));
append(es, fx("lib/log/global_test.ww"));
append(es, fx("lib/log/silent_test.ww")); append(es, fx("lib/log/silent_test.ww"));
append(es, fx("lib/os/stat_test.ww")); append(es, fx("lib/os/stat_test.ww"));
// toktest/asttest resolve `import syntax` via -I lib/ww, cf 905 // toktest/asttest resolve `import syntax` via -I lib/ww, cf 905