Hojun-Cho
b45f7c40ac
61 over-annotations dropped where the rhs unambiguously infers the declared type: 22 overflow:bool comparison binds in checked.ww, and the mem/s/sl memio.stream/io.stream/log.stdlogger triplet across 13 @test sites in logtest.ww. Sub-word res:/fullres: binds with casts or truncation are kept. Byte-identical asm in both stages, both files non-embedded.
263 lines
7.5 KiB
Plaintext
263 lines
7.5 KiB
Plaintext
// 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;
|
|
|
|
import fmt;
|
|
import io;
|
|
import log;
|
|
import memio;
|
|
import os;
|
|
|
|
// signalled — bumped before each scenario so a failing exit code
|
|
// pinpoints the offending case.
|
|
let signalled: i32 = 0;
|
|
|
|
fn fail() void = { os.exit(signalled + 10); };
|
|
|
|
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
|
|
|
|
if (log.silent == nil) { fail(); };
|
|
if (log.default == nil) { fail(); };
|
|
if (log.global == nil) { fail(); };
|
|
if (log.global != log.default) { fail(); };
|
|
};
|
|
|
|
// ---- 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);
|
|
|
|
if (!streq(memio.string(&mem), "hello 42\n")) { fail(); };
|
|
};
|
|
|
|
// ---- 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");
|
|
|
|
if (!streq(memio.string(&mem), "only\n")) { fail(); };
|
|
};
|
|
|
|
// ---- 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);
|
|
|
|
if (!streq(memio.string(&mem), "\n")) { fail(); };
|
|
};
|
|
|
|
// ---- silent: lprintln through log.silent writes no bytes --------------
|
|
|
|
// The silent logger's callback discards args without touching fmt or
|
|
// any sink. Verified indirectly: we wire a memio.stream and never
|
|
// pass it to log.silent — but the @test fn calling log.new first
|
|
// triggers [[log.ensureinit]] so log.silent is non-nil here. Then
|
|
// lprintln(silent, ...) must not crash and the memio sink must stay
|
|
// empty (silent has no path to it anyway).
|
|
@test fn silentwritesnothing() void = {
|
|
let buf: [16]u8;
|
|
let mem = memio.fixed(buf[0:16]);
|
|
let s = &mem.vt;
|
|
|
|
let sl = log.new(s); // triggers log.ensureinit; populates log.silent
|
|
|
|
if (log.silent == nil) { fail(); };
|
|
|
|
log.lprintln(log.silent, "ignored", 1i64, true);
|
|
|
|
if (mem.pos != 0) { fail(); };
|
|
};
|
|
|
|
// ---- 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");
|
|
if (!streq(memio.string(&mem1), "first\n")) { fail(); };
|
|
if (mem2.pos != 0) { fail(); };
|
|
|
|
log.setlogger(&sl2.logger);
|
|
log.println("second");
|
|
if (!streq(memio.string(&mem2), "second\n")) { fail(); };
|
|
// mem1 must be unchanged.
|
|
if (!streq(memio.string(&mem1), "first\n")) { fail(); };
|
|
|
|
log.setlogger(log.silent);
|
|
log.println("dropped");
|
|
// Both sinks unchanged.
|
|
if (!streq(memio.string(&mem1), "first\n")) { fail(); };
|
|
if (!streq(memio.string(&mem2), "second\n")) { fail(); };
|
|
};
|
|
|
|
// ---- 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");
|
|
|
|
if (!streq(memio.string(&mem), "x=42 y=hi\n")) { fail(); };
|
|
};
|
|
|
|
// ---- 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);
|
|
if (!streq(memio.string(&mem1), "v=7\n")) { fail(); };
|
|
if (mem2.pos != 0) { fail(); };
|
|
};
|
|
|
|
// ---- silent.printfln writes nothing ---------------------------------
|
|
|
|
// The silent logger's printfln callback discards args without touching
|
|
// fmt or any sink. Same pattern as [[silentwritesnothing]] for the
|
|
// bare-args path.
|
|
@test fn silentignoresprintfln() void = {
|
|
let buf: [16]u8;
|
|
let mem = memio.fixed(buf[0:16]);
|
|
let s = &mem.vt;
|
|
|
|
let sl = log.new(s); // triggers log.ensureinit; populates log.silent
|
|
|
|
if (log.silent == nil) { fail(); };
|
|
|
|
log.lprintfln(log.silent, "ignored={}", 1i64);
|
|
|
|
if (mem.pos != 0) { fail(); };
|
|
};
|
|
|
|
// ---- 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");
|
|
|
|
if (!streq(memio.string(&mem), "b a\n")) { fail(); };
|
|
};
|
|
|
|
// ---- 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);
|
|
|
|
if (!streq(memio.string(&mem), " 42\n")) { fail(); };
|
|
};
|
|
|
|
// 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.
|
|
|
|
export fn main() i32 = {
|
|
signalled = 1; defaultwiredtoglobal();
|
|
signalled = 2; lprintlnbasic();
|
|
signalled = 3; lprintlnsingle();
|
|
signalled = 4; lprintlnempty();
|
|
signalled = 5; silentwritesnothing();
|
|
signalled = 6; setloggerswap();
|
|
signalled = 7; lprintflnbasic();
|
|
signalled = 8; printflnglobal();
|
|
signalled = 9; silentignoresprintfln();
|
|
signalled = 10; lprintflnindexed();
|
|
signalled = 11; lprintflnmods();
|
|
return 0;
|
|
};
|