ww/lib/log/logtest.ww

// 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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:4]);
	let sl: log.stdlogger;
	log.new(&sl, &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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:32]);

	let sl: log.stdlogger;
	log.new(&sl, &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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:16]);

	let sl: log.stdlogger;
	log.new(&sl, &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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:4]);

	let sl: log.stdlogger;
	log.new(&sl, &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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:16]);

	let sl: log.stdlogger;
	log.new(&sl, &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.state;
	let s1:   io.stream;
	memio.fixed(&mem1, &s1, buf1[0:32]);
	let sl1: log.stdlogger;
	log.new(&sl1, &s1);

	let buf2: [32]u8;
	let mem2: memio.state;
	let s2:   io.stream;
	memio.fixed(&mem2, &s2, buf2[0:32]);
	let sl2: log.stdlogger;
	log.new(&sl2, &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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:32]);

	let sl: log.stdlogger;
	log.new(&sl, &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.state;
	let s1:   io.stream;
	memio.fixed(&mem1, &s1, buf1[0:32]);
	let sl1: log.stdlogger;
	log.new(&sl1, &s1);

	let buf2: [32]u8;
	let mem2: memio.state;
	let s2:   io.stream;
	memio.fixed(&mem2, &s2, buf2[0:32]);
	let sl2: log.stdlogger;
	log.new(&sl2, &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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:16]);

	let sl: log.stdlogger;
	log.new(&sl, &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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:16]);

	let sl: log.stdlogger;
	log.new(&sl, &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.state;
	let s:   io.stream;
	memio.fixed(&mem, &s, buf[0:16]);

	let sl: log.stdlogger;
	log.new(&sl, &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;
};