// 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.