ww/test/package/package_test.ww

package package_test;

// Native end-to-end checks for the first single-directory package route.
// Make builds and invokes this one binary; discovery, subprocess ownership,
// output interpretation, and assertions remain WW code.

import os;
import os.exec;
import strings;
import temp;
import time;

type commandout = struct {
	termination: exec.termination,
	code: i32,
	stdout: str,
	stderr: str,
};

fn envrequired(name: str) str = {
	match (os.getenv(name)) {
	case let value: str => {
		assert(value.len != 0);
		return strings.dup(value);
	};
	case void => abort("missing package-test environment");
	};
};

fn repo() str = { return envrequired("WW_PACKAGE_REPO"); };

fn driver(name: str) str = {
	return strings.concat(repo(), "/out/bin/", name);
};

fn readfile(path: str) str = {
	let fd: i32 = os.open(path, os.flag.RDONLY, 0i32);
	assert(fd >= 0);
	let sr: (i64 | os.oserror) = os.filesize(fd);
	let n: i64 = -1i64;
	match (sr) {
	case let v: i64 => n = v;
	case let e: os.oserror => abort("filesize failed");
	};
	assert(n >= 0i64);
	let b: []u8 = alloc([], (n + 1i64): u64)!;
	b.len = (n + 1i64): i32;
	let rr: (i64 | os.oserror) = os.readall(fd, b.ptr, n: u64);
	os.close(fd);
	let got: i64 = -1i64;
	match (rr) {
	case let v: i64 => got = v;
	case let e: os.oserror => abort("read failed");
	};
	assert(got == n);
	let ni: i32 = n: i32;
	b[ni] = 0u8;
	let out: str;
	out.ptr = b.ptr;
	out.len = n: i32;
	return out;
};

fn writefile(path: str, content: str) void = {
	let fd: i32 = os.open(path,
		os.flag.WRONLY | os.flag.CREATE | os.flag.EXCL, 384i32);
	assert(fd >= 0);
	match (os.writeall(fd, content.ptr, content.len: u64)) {
	case let n: i64 => assert(n == content.len: i64);
	case let e: os.oserror => abort("write failed");
	};
	assert(os.close(fd) == 0);
};

fn runcommand(root: str, name: str, argv: []str,
	lifetime: time.duration, out: *commandout) void = {
	let c: exec.command;
	c.path = argv[0];
	c.argv = argv;
	c.env = os.getenvs();
	c.dir = repo();
	c.stdoutpath = strings.concat(root, "/", name, ".stdout");
	c.stderrpath = strings.concat(root, "/", name, ".stderr");
	c.deadline = time.add(time.now(time.clock.monotonic), lifetime);
	c.grace = (100i64 * (time.millisecond: i64)): time.duration;
	let r: exec.result;
	exec.run(&c, &r);
	assert(r.errno == 0 && r.cleanuperrno == 0);
	out.termination = r.termination;
	out.code = r.code;
	out.stdout = readfile(c.stdoutpath);
	out.stderr = readfile(c.stderrpath);
};

fn clean(root: str) void = {
	let av: []str = ["/bin/rm", "-rf", "--", root];
	let c: exec.command;
	c.path = av[0];
	c.argv = av;
	c.env = os.getenvs();
	c.dir = "/";
	c.stdoutpath = strings.concat(root, ".cleanup.stdout");
	c.stderrpath = strings.concat(root, ".cleanup.stderr");
	c.deadline = time.add(time.now(time.clock.monotonic), time.second);
	c.grace = (50i64 * (time.millisecond: i64)): time.duration;
	let r: exec.result;
	exec.run(&c, &r);
	assert(r.termination == exec.termination.EXIT && r.code == 0);
	assert(os.remove(c.stdoutpath) == 0);
	assert(os.remove(c.stderrpath) == 0);
};

fn fresh() str = { return strings.dup(temp.dir()); };

fn pos(haystack: str, needle: str) i32 = {
	match (strings.index(haystack, needle)) {
	case let n: i32 => return n;
	case void => return -1;
	};
};

fn has(haystack: str, needle: str) bool = {
	return pos(haystack, needle) >= 0;
};

fn same(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;
};

fn occurrences(haystack: str, needle: str) i32 = {
	if (needle.len == 0 || haystack.len < needle.len) { return 0; };
	let count: i32 = 0;
	let i: i32 = 0;
	for (i + needle.len <= haystack.len) {
		let matches: bool = true;
		let j: i32 = 0;
		for (j < needle.len) {
			if (haystack[i + j] != needle[j]) { matches = false; break; };
			j += 1;
		};
		if (matches) { count += 1; i += needle.len; }
		else { i += 1; };
	};
	return count;
};

fn expectexit(out: *commandout, code: i32) void = {
	assert(out.termination == exec.termination.EXIT);
	assert(out.code == code);
};

fn packagepath(relative: str) str = {
	return strings.concat(repo(), "/test/package/", relative);
};

@test fn deterministic_routing_and_filters() void = {
	let root: str = fresh();
	let target: str = packagepath("routing");
	let av: []str = [driver("ww"), "test", "-list", target];
	let out: commandout;
	runcommand(root, "list", av, (30i64 * (time.second: i64)): time.duration,
		&out);
	expectexit(&out, 0);
	let first: i32 = pos(out.stdout, "routing.private_helper_first\n");
	let second: i32 = pos(out.stdout, "routing.same_package\n");
	let third: i32 = pos(out.stdout, "routing_test.external_package\n");
	assert(first >= 0 && first < second && second < third);
	assert(occurrences(out.stdout, "routing.private_helper_first\n") == 1);
	assert(occurrences(out.stdout, "routing.same_package\n") == 1);
	assert(occurrences(out.stdout, "routing_test.external_package\n") == 1);

	let rav: []str = [driver("ww"), "test", target];
	runcommand(root, "run", rav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout, "routing.private_helper_first ... ok\n"));
	assert(has(out.stdout, "routing.same_package ... ok\n"));
	assert(has(out.stdout, "routing_test.external_package ... ok\n"));
	assert(has(out.stdout,
		"2 passed, 0 failed, 0 skipped, 0 harness errors\n"));
	assert(has(out.stdout,
		"1 passed, 0 failed, 0 skipped, 0 harness errors\n"));

	let fav: []str = [driver("ww"), "test", "-run",
		"routing.private_helper_first", "-filter", "external_package",
		target];
	runcommand(root, "filters", fav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout, "routing.private_helper_first ... ok\n"));
	assert(!has(out.stdout, "routing.same_package ..."));
	assert(has(out.stdout, "routing_test.external_package ... ok\n"));

	let nav: []str = [driver("ww"), "test", "-run", "no-such-*", target];
	runcommand(root, "nomatch", nav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(occurrences(out.stdout, "[no matches]\n") == 2);
	assert(occurrences(out.stdout,
		"1 discovered, 0 selected, 0 started, 0 completed\n") == 1);
	assert(occurrences(out.stdout,
		"2 discovered, 0 selected, 0 started, 0 completed\n") == 1);

	let lnav: []str = [driver("ww"), "test", "-list", "-run",
		"no-such-*", target];
	runcommand(root, "list-nomatch", lnav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(occurrences(out.stdout, "[no matches]\n") == 2);
	clean(root);
};

@test fn imported_dependency_tests_do_not_leak() void = {
	let root: str = fresh();
	let base: str = packagepath("dependency");
	let av: []str = [driver("ww"), "test", "-I", base,
		strings.concat(base, "/root")];
	let out: commandout;
	runcommand(root, "dependency", av,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout, "root.imported_production_only ... ok\n"));
	assert(!has(out.stdout, "imported_dependency_test_must_not_leak"));
	assert(has(out.stdout,
		"1 discovered, 1 selected, 1 started, 1 completed\n"));
	clean(root);
};

@test fn empty_and_invalid_package_classes() void = {
	let root: str = fresh();
	let av: []str = [driver("ww"), "test", packagepath("no_tests")];
	let out: commandout;
	runcommand(root, "notests", av,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout, " [no tests]\n"));
	assert(!has(out.stdout, " ... ok"));

	let bad: []str = [driver("ww"), "test", packagepath("bad_external")];
	runcommand(root, "badexternal", bad,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stderr,
		"test package must match production package or <package>_test"));

	let empty: str = strings.concat(root, "/empty");
	assert(os.mkdir(empty, 448i32) == 0);
	let emptyav: []str = [driver("ww"), "test", empty];
	runcommand(root, "emptydir", emptyav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stderr, "directory contains no WW package sources"));
	clean(root);
};

@test fn symlink_package_is_rejected() void = {
	let root: str = fresh();
	let real: str = strings.concat(root, "/real");
	let link: str = strings.concat(root, "/link");
	assert(os.mkdir(real, 448i32) == 0);
	writefile(strings.concat(real, "/real.ww"),
		"package real;\nexport fn value() int = { return 1; };\n");
	let lav: []str = ["/bin/ln", "-s", real, link];
	let out: commandout;
	runcommand(root, "link", lav, time.second, &out);
	expectexit(&out, 0);
	let av: []str = [driver("ww"), "test", link];
	runcommand(root, "reject", av,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stderr, "symlink traversal is not allowed"));
	clean(root);
};

@test fn pass_skip_and_expected_abort() void = {
	let root: str = fresh();
	let av: []str = [driver("ww"), "test", packagepath("cases/pass")];
	let out: commandout;
	runcommand(root, "pass", av,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout, "pass_test.alpha_pass ... ok\n"));
	assert(has(out.stdout,
		"pass_test.beta_skip ... SKIP: synthetic unavailable feature\n"));
	assert(has(out.stdout, "pass_test.gamma_expected_abort ... ok\n"));
	assert(has(out.stdout, "pass_test.delta_pass ... ok\n"));
	assert(has(out.stdout,
		"3 passed, 0 failed, 1 skipped, 0 harness errors\n"));
	assert(has(out.stdout,
		"4 discovered, 4 selected, 4 started, 4 completed\n"));
	clean(root);
};

@test fn failures_are_distinct_and_clamped() void = {
	let root: str = fresh();
	let out: commandout;
	let av: []str = [driver("ww"), "test",
		packagepath("cases/assert_failure")];
	runcommand(root, "assert", av,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"assert_failure_test.assertion_failure ... FAIL (exit 1)\n"));
	assert(!has(out.stderr, "captures:"));

	let nonzeroav: []str = [driver("ww"), "test",
		packagepath("cases/nonzero")];
	runcommand(root, "nonzero", nonzeroav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"nonzero_test.deliberate_nonzero_exit ... FAIL (exit 7)\n"));

	let prematureav: []str = [driver("ww"), "test",
		packagepath("cases/premature")];
	runcommand(root, "premature", prematureav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"premature_test.clean_exit_without_completion ... HARNESS (incomplete result)\n"));

	let signalav: []str = [driver("ww"), "test",
		packagepath("cases/signal")];
	runcommand(root, "signal", signalav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"signal_test.signal_is_not_exit ... FAIL (signal 15)\n"));

	let multiav: []str = [driver("ww"), "test",
		packagepath("cases/multi_fail")];
	runcommand(root, "multifail", multiav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"1 passed, 2 failed, 0 skipped, 0 harness errors\n"));
	assert(has(out.stdout,
		"3 discovered, 3 selected, 3 started, 3 completed\n"));
	clean(root);
};

@test fn timeout_and_descendant_cleanup() void = {
	let root: str = fresh();
	let av: []str = [driver("ww"), "test", "-timeout-ms=100",
		packagepath("cases/timeout")];
	let out: commandout;
	runcommand(root, "timeout", av,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"timeout_test.timeout_clears_term_resistant_descendant ... FAIL(timeout)\n"));
	assert(has(out.stdout,
		"1 discovered, 1 selected, 1 started, 1 completed\n"));

	let descendantav: []str = [driver("ww"), "test",
		packagepath("cases/descendant")];
	runcommand(root, "descendant", descendantav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout,
		"descendant_test.normal_return_clears_descendant ... ok\n"));
	assert(!has(out.stdout, "HARNESS"));
	clean(root);
};

@test fn cstage_wwstage_behavior_and_assembly_match() void = {
	let root: str = fresh();
	writefile(strings.concat(root, "/route.ww"),
		"package route;\nexport fn value() int = { return 7; };\n");
	writefile(strings.concat(root, "/a_test.ww"),
		"package route;\n@test fn white() void = { assert(value() == 7); };\n");
	writefile(strings.concat(root, "/z_test.ww"),
		"package route_test;\nimport route;\n@test fn external() void = { assert(route.value() == 7); };\n");

	let outc: commandout;
	let outw: commandout;
	let listc: []str = [driver("ww"), "test", "-list", root];
	let listw: []str = [driver("ww_ww"), "test", "-list", root];
	runcommand(root, "list-c", listc,
		(30i64 * (time.second: i64)): time.duration, &outc);
	runcommand(root, "list-ww", listw,
		(30i64 * (time.second: i64)): time.duration, &outw);
	expectexit(&outc, 0);
	expectexit(&outw, 0);
	assert(same(outc.stdout, outw.stdout));
	assert(same(outc.stderr, outw.stderr));

	let misusec: []str = [driver("ww"), "test", "-run"];
	let misusew: []str = [driver("ww_ww"), "test", "-run"];
	runcommand(root, "misuse-c", misusec, time.second, &outc);
	runcommand(root, "misuse-ww", misusew, time.second, &outw);
	expectexit(&outc, 2);
	expectexit(&outw, 2);
	assert(same(outc.stdout, outw.stdout));
	assert(same(outc.stderr, outw.stderr));
	assert(has(outc.stderr, "ww test: -run needs an argument\n"));

	let timeoutc: []str = [driver("ww"), "test",
		"-timeout-ms=4000000", root];
	let timeoutw: []str = [driver("ww_ww"), "test",
		"-timeout-ms=4000000", root];
	runcommand(root, "timeout-misuse-c", timeoutc, time.second, &outc);
	runcommand(root, "timeout-misuse-ww", timeoutw, time.second, &outw);
	expectexit(&outc, 2);
	expectexit(&outw, 2);
	assert(same(outc.stdout, outw.stdout));
	assert(same(outc.stderr, outw.stderr));
	assert(has(outc.stderr, "usage: wwtest package"));

	let cc: []str = [driver("ww"), "test", "-c", root];
	runcommand(root, "compile-c", cc,
		(30i64 * (time.second: i64)): time.duration, &outc);
	expectexit(&outc, 0);
	assert(has(outc.stdout, strings.concat(" -> ", root, "/route.test\n")));
	assert(has(outc.stdout,
		strings.concat(" -> ", root, "/route_test.test\n")));
	let cwhite: str = readfile(strings.concat(root,
		"/route.test.sepwork/__root.s"));
	let cexternal: str = readfile(strings.concat(root,
		"/route_test.test.sepwork/__root.s"));
	// The explicit package `-c` outputs are caller-owned artifacts. Release
	// the two exact C-stage trees before asking the WW driver to acquire the
	// same stems; the driver never deletes a pre-existing `.sepwork` path.
	clean(strings.concat(root, "/route.test.sepwork"));
	clean(strings.concat(root, "/route_test.test.sepwork"));

	let wc: []str = [driver("ww_ww"), "test", "-c", root];
	runcommand(root, "compile-ww", wc,
		(30i64 * (time.second: i64)): time.duration, &outw);
	expectexit(&outw, 0);
	assert(same(outc.stdout, outw.stdout));
	assert(same(outc.stderr, outw.stderr));
	assert(same(cwhite, readfile(strings.concat(root,
		"/route.test.sepwork/__root.s"))));
	assert(same(cexternal, readfile(strings.concat(root,
		"/route_test.test.sepwork/__root.s"))));
	clean(root);
};

// Invalid @test attribute shapes reject at build with stable text on
// BOTH frontends (the -T synth checker owns them; the fixture corpus
// cannot reach -T, so these rows live here). Fragments only — the
// stages' error-line prefixes legitimately differ (file:line:col vs
// file:).
@test fn invalid_test_shapes_reject() void = {
	let root: str = fresh();
	let shapes: []str = [
		"@test export fn t() void = { };",
		"@test fn t() void;",
		"@test fn t(x: i32) void = { };",
		"@test fn t() i32 = { return 0; };",
		"@test @test fn t() void = { };",
	];
	let frags: []str = [
		"@test fn 't' cannot be exported",
		"@test fn 't' needs a body",
		"@test fn 't' must be fn() void",
		"@test fn 't' must be fn() void",
		"duplicate @test on fn 't'",
	];
	let digits: []str = ["0", "1", "2", "3", "4"];
	let outc: commandout;
	let outw: commandout;
	let i: i32 = 0;
	for (i < shapes.len) {
		let dir: str = strings.concat(root, "/shape", digits[i]);
		assert(os.mkdir(dir, 448i32) == 0);
		let src: str = strings.concat(dir, "/bad_test.ww");
		writefile(src, strings.concat("package main;\n",
			shapes[i], "\n"));
		let avc: []str = [driver("ww"), "test", src];
		let avw: []str = [driver("ww_ww"), "test", src];
		runcommand(root, strings.concat("shape-c", digits[i]), avc,
			(30i64 * (time.second: i64)): time.duration, &outc);
		runcommand(root, strings.concat("shape-ww", digits[i]), avw,
			(30i64 * (time.second: i64)): time.duration, &outw);
		expectexit(&outc, 1);
		expectexit(&outw, 1);
		assert(has(outc.stderr, frags[i]));
		assert(has(outw.stderr, frags[i]));
		i += 1;
	};
	clean(root);
};

// Go's ./... parity: a trailing "..." element walks the tree, one package
// run per test-bearing directory, dot- and underscore-prefixed directory
// names excluded. The excluded sentinels hold failing tests so a wrong
// descent turns the whole run red rather than passing silently.
@test fn recursive_tree_discovery() void = {
	let root: str = fresh();
	let tree: str = strings.concat(root, "/tree");
	assert(os.mkdir(tree, 448i32) == 0);
	assert(os.mkdir(strings.concat(tree, "/alpha"), 448i32) == 0);
	assert(os.mkdir(strings.concat(tree, "/beta"), 448i32) == 0);
	assert(os.mkdir(strings.concat(tree, "/beta/inner"), 448i32) == 0);
	assert(os.mkdir(strings.concat(tree, "/gamma"), 448i32) == 0);
	assert(os.mkdir(strings.concat(tree, "/.hidden"), 448i32) == 0);
	assert(os.mkdir(strings.concat(tree, "/_skip"), 448i32) == 0);
	writefile(strings.concat(tree, "/alpha/alpha.ww"),
		"package alpha;\nexport fn value() int = { return 7; };\n");
	writefile(strings.concat(tree, "/alpha/alpha_test.ww"),
		"package alpha_test;\nimport alpha;\n@test fn treealpha() void = { assert(alpha.value() == 7); };\n");
	writefile(strings.concat(tree, "/beta/inner/inner_test.ww"),
		"package inner;\n@test fn treeinner() void = { assert(1 == 1); };\n");
	writefile(strings.concat(tree, "/gamma/gamma.ww"),
		"package gamma;\nexport fn g() int = { return 1; };\n");
	writefile(strings.concat(tree, "/.hidden/hid_test.ww"),
		"package hid;\n@test fn hidden() void = { assert(false); };\n");
	writefile(strings.concat(tree, "/_skip/skip_test.ww"),
		"package skip;\n@test fn skipped() void = { assert(false); };\n");

	let spec: str = strings.concat(tree, "/...");
	let outc: commandout;
	let outw: commandout;
	let treec: []str = [driver("ww"), "test", spec];
	let treew: []str = [driver("ww_ww"), "test", spec];
	runcommand(root, "tree-c", treec,
		(30i64 * (time.second: i64)): time.duration, &outc);
	runcommand(root, "tree-ww", treew,
		(30i64 * (time.second: i64)): time.duration, &outw);
	expectexit(&outc, 0);
	expectexit(&outw, 0);
	assert(same(outc.stdout, outw.stdout));
	assert(same(outc.stderr, outw.stderr));
	assert(has(outc.stdout, strings.concat("ok   ", tree,
		"/alpha [alpha_test, external]\n")));
	assert(has(outc.stdout, strings.concat("ok   ", tree,
		"/beta/inner [inner, same-package]\n")));
	assert(has(outc.stdout, strings.concat("?    ", tree,
		"/gamma [no tests]\n")));
	assert(!has(outc.stdout, ".hidden"));
	assert(!has(outc.stdout, "_skip"));

	// Concurrent scheduling must not reorder the emitted byte stream.
	let seq: str = strings.dup(outc.stdout);
	let j4: []str = [driver("ww"), "test", "-j", "4", spec];
	runcommand(root, "tree-j4", j4,
		(30i64 * (time.second: i64)): time.duration, &outc);
	expectexit(&outc, 0);
	assert(same(outc.stdout, seq));

	let j0: []str = [driver("ww"), "test", "-j", "0", spec];
	runcommand(root, "tree-j0", j0, time.second, &outc);
	expectexit(&outc, 2);
	assert(has(outc.stderr, "usage: wwtest package"));

	let patc: []str = [driver("ww"), "test", spec, "glob*"];
	let patw: []str = [driver("ww_ww"), "test", spec, "glob*"];
	runcommand(root, "tree-pattern-c", patc, time.second, &outc);
	runcommand(root, "tree-pattern-ww", patw, time.second, &outw);
	expectexit(&outc, 2);
	expectexit(&outw, 2);
	assert(same(outc.stderr, outw.stderr));
	assert(has(outc.stderr, "ww test: pattern needs a single test file\n"));

	let oc: []str = [driver("ww"), "test", "-o",
		strings.concat(root, "/stem"), spec];
	let ow: []str = [driver("ww_ww"), "test", "-o",
		strings.concat(root, "/stem"), spec];
	runcommand(root, "tree-o-c", oc, time.second, &outc);
	runcommand(root, "tree-o-ww", ow, time.second, &outw);
	expectexit(&outc, 2);
	expectexit(&outw, 2);
	assert(same(outc.stderr, outw.stderr));
	assert(has(outc.stderr,
		"ww test: -o needs -c for a package target\n"));

	// -w on a package target forwards to the coordinator: one
	// persistent driver workdir per package group under the root,
	// reuse owned by the driver's content-identity contract. The
	// byte stream must match the plain run, cold and warm.
	let wdroot: str = strings.concat(root, "/wd");
	assert(os.mkdir(wdroot, 448i32) == 0);
	let wdc: []str = [driver("ww"), "test", "-w", wdroot, spec];
	let wdw: []str = [driver("ww_ww"), "test", "-w", wdroot, spec];
	runcommand(root, "tree-w-c", wdc,
		(30i64 * (time.second: i64)): time.duration, &outc);
	runcommand(root, "tree-w-ww", wdw,
		(30i64 * (time.second: i64)): time.duration, &outw);
	expectexit(&outc, 0);
	expectexit(&outw, 0);
	assert(same(outc.stdout, outw.stdout));
	assert(same(outc.stdout, seq));
	runcommand(root, "tree-w-warm", wdc,
		(30i64 * (time.second: i64)): time.duration, &outc);
	expectexit(&outc, 0);
	assert(same(outc.stdout, seq));
	// -c publishes caller-owned artifacts; a persistent workdir is a
	// different ownership contract — the coordinator rejects the mix.
	let wcc: []str = [driver("ww"), "test", "-c", "-w", wdroot, spec];
	let wcw: []str = [driver("ww_ww"), "test", "-c", "-w", wdroot, spec];
	runcommand(root, "tree-wc-c", wcc, time.second, &outc);
	runcommand(root, "tree-wc-ww", wcw, time.second, &outw);
	expectexit(&outc, 2);
	expectexit(&outw, 2);
	assert(same(outc.stderr, outw.stderr));
	assert(has(outc.stderr, "wwtest package: -w conflicts with -c\n"));

	let bare: str = strings.concat(root, "/bare");
	assert(os.mkdir(bare, 448i32) == 0);
	assert(os.mkdir(strings.concat(bare, "/sub"), 448i32) == 0);
	let barec: []str = [driver("ww"), "test",
		strings.concat(bare, "/...")];
	let barew: []str = [driver("ww_ww"), "test",
		strings.concat(bare, "/...")];
	runcommand(root, "tree-bare-c", barec,
		(10i64 * (time.second: i64)): time.duration, &outc);
	runcommand(root, "tree-bare-ww", barew,
		(10i64 * (time.second: i64)): time.duration, &outw);
	expectexit(&outc, 1);
	expectexit(&outw, 1);
	assert(same(outc.stderr, outw.stderr));
	assert(has(outc.stderr, "directory contains no WW package sources\n"));
	clean(root);
};

fn runtimepath(relative: str) str = {
	return strings.concat(repo(), "/test/package/runtime/", relative);
};

// The single-FILE `ww test <file>` route wraps the same in-binary test
// runtime as the directory-package route (cases/*), but through the
// driver's single-file leg. One row per outcome class keeps that leg's
// wiring honest; the runtime-internal classifications themselves are
// owned by the cases/* tests above.
@test fn singlefile_runtime_outcomes() void = {
	let root: str = fresh();
	let out: commandout;
	let successav: []str = [driver("ww"), "test",
		runtimepath("success_test.ww")];
	runcommand(root, "sf-success", successav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout, "alpha_pass ... ok\n"));
	assert(has(out.stdout,
		"beta_skip ... SKIP: synthetic unavailable feature\n"));
	assert(has(out.stdout, "gamma_expected_abort ... ok\n"));
	assert(has(out.stdout, "delta_pass ... ok\n"));
	assert(has(out.stdout,
		"3 passed, 0 failed, 1 skipped, 0 harness errors\n"));
	assert(has(out.stdout,
		"4 discovered, 4 selected, 4 started, 4 completed\n"));

	let failav: []str = [driver("ww"), "test",
		runtimepath("fail_test.ww")];
	runcommand(root, "sf-fail", failav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout, "assertion_failure ... FAIL (exit 1)\n"));

	let multiav: []str = [driver("ww"), "test",
		runtimepath("multiple_fail_test.ww")];
	runcommand(root, "sf-multi", multiav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"0 passed, 2 failed, 0 skipped, 0 harness errors\n"));

	let unmetav: []str = [driver("ww"), "test",
		runtimepath("expected_abort_return_test.ww")];
	runcommand(root, "sf-unmet", unmetav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"expected_abort_must_happen ... FAIL (expected abort)\n"));

	let premav: []str = [driver("ww"), "test",
		runtimepath("premature_exit_test.ww")];
	runcommand(root, "sf-premature", premav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout,
		"clean_exit_without_completion ... HARNESS (incomplete result)\n"));

	let sigav: []str = [driver("ww"), "test",
		runtimepath("signal_test.ww")];
	runcommand(root, "sf-signal", sigav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout, "signal_is_not_exit ... FAIL (signal 15)\n"));

	// Record-and-continue past every fault class: the runner reports
	// hardware faults with their literal signal numbers and still
	// reaches the trailing test (retired 911_attest_record).
	let recav: []str = [driver("ww"), "test",
		runtimepath("record_continue_test.ww")];
	runcommand(root, "sf-record", recav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout, "rec_pass_a ... ok\n"));
	assert(has(out.stdout, "rec_assert ... FAIL (exit 1)\n"));
	assert(has(out.stdout, "rec_segv ... FAIL (signal 11)\n"));
	assert(has(out.stdout, "rec_div0 ... FAIL (signal 8)\n"));
	assert(has(out.stdout, "rec_pass_b ... ok\n"));
	assert(has(out.stdout,
		"2 passed, 3 failed, 0 skipped, 0 harness errors\n"));
	assert(has(out.stdout,
		"5 discovered, 5 selected, 5 started, 5 completed\n"));
	clean(root);
};

// The published test binary's OWN command surface: repeated glob args,
// -list (with and without a glob), and -timeout-ms. Only a direct
// invocation of the `-c` artifact proves these; every driver route
// parses its flags before the binary sees them.
@test fn published_binary_cli() void = {
	let root: str = fresh();
	let out: commandout;
	let stem: str = strings.concat(root, "/rtsuccess");
	let cav: []str = [driver("ww"), "test", "-c", "-o", stem,
		runtimepath("success_test.ww")];
	runcommand(root, "publish", cav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);

	let gav: []str = [stem, "alpha*", "delta*"];
	runcommand(root, "globs", gav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout, "alpha_pass ... ok\n"));
	assert(has(out.stdout, "delta_pass ... ok\n"));
	assert(has(out.stdout,
		"2 passed, 0 failed, 0 skipped, 0 harness errors\n"));
	assert(has(out.stdout,
		"4 discovered, 2 selected, 2 started, 2 completed\n"));

	let lav: []str = [stem, "-list"];
	runcommand(root, "list", lav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(same(out.stdout,
		"alpha_pass\nbeta_skip\ngamma_expected_abort\ndelta_pass\n"));

	let lgav: []str = [stem, "-list", "gamma*"];
	runcommand(root, "list-glob", lgav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(same(out.stdout, "gamma_expected_abort\n"));

	let tav: []str = [stem, "-timeout-ms=50", "alpha*"];
	runcommand(root, "cli-timeout", tav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout,
		"1 passed, 0 failed, 0 skipped, 0 harness errors\n"));
	clean(root);
};

// Direct-binary timeout classification and descendant handling. The
// runcommand deadline bounds the no-hang claims: a runner waiting on a
// SIGTERM-blocking or process-group-escaped pipe writer would trip it.
@test fn direct_binary_timeout_and_descendants() void = {
	let root: str = fresh();
	let out: commandout;
	let tstem: str = strings.concat(root, "/rttimeout");
	let tcav: []str = [driver("ww"), "test", "-c", "-o", tstem,
		runtimepath("timeout_test.ww")];
	runcommand(root, "publish-timeout", tcav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	let trun: []str = [tstem, "-timeout-ms=50"];
	runcommand(root, "run-timeout", trun,
		(20i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 1);
	assert(has(out.stdout, "hang_times_out ... FAIL(timeout)\n"));

	let lstem: str = strings.concat(root, "/rtlinger");
	let lcav: []str = [driver("ww"), "test", "-c", "-o", lstem,
		runtimepath("lingering_descendant_test.ww")];
	runcommand(root, "publish-linger", lcav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	let lrun: []str = [lstem, "-timeout-ms=250"];
	runcommand(root, "run-linger", lrun,
		(20i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout,
		"returning_test_clears_descendant ... ok\n"));

	let estem: str = strings.concat(root, "/rtescaped");
	let ecav: []str = [driver("ww"), "test", "-c", "-o", estem,
		runtimepath("escaped_descendant_test.ww")];
	runcommand(root, "publish-escaped", ecav,
		(30i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	let erun: []str = [estem, "-timeout-ms=250"];
	runcommand(root, "run-escaped", erun,
		(20i64 * (time.second: i64)): time.duration, &out);
	expectexit(&out, 0);
	assert(has(out.stdout,
		"escaped_writer_does_not_hold_runner ... ok\n"));
	clean(root);
};

// The package-level -o contract: -c -o names the single package's
// artifact in place of the fixed <package>.test stem; -o without -c
// has nothing to name (runs execute from the temp root); one name
// cannot fan out over multiple packages (Go's `go test -o` rule).
@test fn compile_artifact_naming() void = {
	let root: str = fresh();
	let pdir: str = strings.concat(root, "/pkg");
	assert(os.mkdir(pdir, 493i32) == 0);
	writefile(strings.concat(pdir, "/pkg.ww"),
		"package pkg;\nexport fn v() i32 = { return 7; };\n");
	writefile(strings.concat(pdir, "/pkg_test.ww"), strings.concat(
		"package pkg_test;\nimport pkg;\n",
		"@test fn seven() void = { assert(pkg.v() == 7); };\n"));
	let adir: str = strings.concat(root, "/a");
	assert(os.mkdir(adir, 493i32) == 0);
	// '_'-prefixed: the tree walk skips it, so the artifacts and
	// their .sepwork trees never pollute the multi-package discovery.
	let outdir: str = strings.concat(root, "/_out");
	assert(os.mkdir(outdir, 493i32) == 0);
	writefile(strings.concat(adir, "/a.ww"),
		"package a;\nexport fn v() i32 = { return 1; };\n");
	writefile(strings.concat(adir, "/a_test.ww"), strings.concat(
		"package a_test;\nimport a;\n",
		"@test fn one() void = { assert(a.v() == 1); };\n"));
	let out: commandout;
	let drvs: []str = ["ww", "ww_ww"];
	let i: i32 = 0;
	for (i < 2) {
		let named: str = strings.concat(outdir, "/out_", drvs[i],
			".bin");
		let coav: []str = [driver(drvs[i]), "test", "-c", "-o",
			named, pdir];
		runcommand(root, strings.concat("nameco_", drvs[i]), coav,
			(30i64 * (time.second: i64)): time.duration, &out);
		expectexit(&out, 0);
		let fi: os.filestat;
		match (os.stat(&fi, named)) {
		case void => void;
		case let e: os.oserror => abort("-c -o artifact missing");
		};
		match (os.stat(&fi, strings.concat(pdir, "/pkg.test"))) {
		case void => abort("-c -o still published the fixed stem");
		case let e: os.oserror => void;
		};
		let runav: []str = [named];
		runcommand(root, strings.concat("namerun_", drvs[i]), runav,
			(30i64 * (time.second: i64)): time.duration, &out);
		expectexit(&out, 0);
		assert(has(out.stdout, "seven ... ok"));

		let nocav: []str = [driver(drvs[i]), "test", "-o", named,
			pdir];
		runcommand(root, strings.concat("noc_", drvs[i]), nocav,
			(30i64 * (time.second: i64)): time.duration, &out);
		expectexit(&out, 2);
		assert(has(out.stderr, "-o needs -c for a package target"));

		let mulav: []str = [driver(drvs[i]), "test", "-c", "-o",
			named, strings.concat(root, "/...")];
		runcommand(root, strings.concat("multi_", drvs[i]), mulav,
			(30i64 * (time.second: i64)): time.duration, &out);
		expectexit(&out, 2);
		assert(has(out.stderr,
			"cannot use -o with multiple packages"));
		i += 1;
	};
	clean(root);
};