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

test: cover package and runtime library roots

Browse Source
This commit is contained in:
Hojun-Cho
2026-08-12 15:18:51 +09:00
parent 5a2e4ba28d
commit 470aacef95
2 changed files with 426 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
test/package/package_test.ww
View File

@@ -2190,26 +2190,45 @@ fn workescape(s: str) str = {
@test fn exact_package_tool_argv_stage_parity() void = {
let root: str = fresh();
let source: str = strings.concat(root, "/source tree");
let leaf: str = strings.concat(source, "/leaf");
let dep: str = strings.concat(source, "/dep");
let target: str = strings.concat(source, "/target");
let runtime: str = strings.concat(root, "/runtime library");
let leaf: str = strings.concat(source, "/ww_root_parity_leaf_7f3");
let dep: str = strings.concat(source, "/ww_root_parity_dep_7f3");
let target: str = strings.concat(source, "/ww_root_parity_target_7f3");
let tools: str = strings.concat(root, "/tool wrappers");
assert(os.mkdir(source, 448i32) == 0);
assert(os.mkdir(runtime, 448i32) == 0);
let copyav: []str = ["/bin/cp", "-R", strings.concat(repo(), "/lib/."),
source];
let copyout: commandout;
runcommand(root, "copy-source-library", copyav,
(30i64 * (time.second: i64)): time.duration, &copyout);
expectexit(&copyout, 0);
assert(copyout.stderr.len == 0);
let support: str = strings.concat(source, "/test/run.ww");
let supportbody: str = readfile(support);
assert(os.remove(support) == 0);
writefile(support, strings.concat("// WW_SRCLIB fixture marker\n",
supportbody));
writefile(strings.concat(runtime, "/libwwrt.a"),
readfile(strings.concat(repo(), "/out/lib/libwwrt.a")));
assert(os.mkdir(leaf, 448i32) == 0);
assert(os.mkdir(dep, 448i32) == 0);
assert(os.mkdir(target, 448i32) == 0);
assert(os.mkdir(tools, 448i32) == 0);
writefile(strings.concat(leaf, "/leaf.ww"), strings.concat(
"package leaf;\n",
"package ww_root_parity_leaf_7f3;\n",
"export fn value() i32 = { return 40; };\n"));
writefile(strings.concat(dep, "/dep.ww"), strings.concat(
"package dep;\nimport leaf;\n",
"export fn value() i32 = { return leaf.value() + 2; };\n"));
"package ww_root_parity_dep_7f3;\n",
"import ww_root_parity_leaf_7f3;\n",
"export fn value() i32 = { return ",
"ww_root_parity_leaf_7f3.value() + 2; };\n"));
writefile(strings.concat(target, "/target.ww"), strings.concat(
"package target;\nimport dep;\n",
"fn value() i32 = { return dep.value(); };\n"));
"package ww_root_parity_target_7f3;\n",
"import ww_root_parity_dep_7f3;\n",
"fn value() i32 = { return ww_root_parity_dep_7f3.value(); };\n"));
writefile(strings.concat(target, "/target_test.ww"), strings.concat(
"package target;\n",
"package ww_root_parity_target_7f3;\n",
"@test fn exact_argv() void = { assert(value() == 42); };\n"));
let compilerwrapper: str = strings.concat(tools, "/w6c wrapper.sh");
@@ -2278,10 +2297,12 @@ fn workescape(s: str) str = {
writefile(assemblertrace, "");
writefile(linkertrace, "");
writefile(failuretrace, "");
let env: []str = alloc([], (baseenv.len + 9): u64)!;
let env: []str = alloc([], (baseenv.len + 11): u64)!;
let ei: i32 = 0;
for (ei < baseenv.len) {
if (!strings.hasprefix(baseenv[ei], "WW_W6C=")
if (!strings.hasprefix(baseenv[ei], "WW_SRCLIB=")
&& !strings.hasprefix(baseenv[ei], "WW_LIB=")
&& !strings.hasprefix(baseenv[ei], "WW_W6C=")
&& !strings.hasprefix(baseenv[ei], "WW_W6A=")
&& !strings.hasprefix(baseenv[ei], "WW_W6L=")
&& !strings.hasprefix(baseenv[ei],
@@ -2300,6 +2321,8 @@ fn workescape(s: str) str = {
};
ei += 1;
};
append(env, strings.concat("WW_SRCLIB=", source));
append(env, strings.concat("WW_LIB=", runtime));
append(env, strings.concat("WW_W6C=", compilerwrapper));
append(env, strings.concat("WW_W6A=", assemblerwrapper));
append(env, strings.concat("WW_W6L=", linkerwrapper));
@@ -2314,7 +2337,7 @@ fn workescape(s: str) str = {
driver(linkers[si])));
let av: []str = [driver(stages[si]), "test", "-c", "-o", bin,
"-I", source, target];
target];
let out: commandout;
runcommandenv(root, strings.concat("exact-argv-", tags[si]), av, env,
(120i64 * (time.second: i64)): time.duration, &out);
@@ -2322,14 +2345,21 @@ fn workescape(s: str) str = {
assert(out.stderr.len == 0);
let rootunit: str = readfile(strings.concat(work,
"__ww-test-000-same.unit.ww"));
let depunit: str = readfile(strings.concat(work, "dep.unit.ww"));
assert(has(rootunit, "//ww:module dep\n"));
assert(!has(rootunit, "//ww:module leaf\n"));
assert(has(depunit, "//ww:module leaf\n"));
assert(os.exists(strings.concat(work, "leaf.wwi")));
assert(os.exists(strings.concat(work, "leaf.a")));
assert(os.exists(strings.concat(work, "dep.wwi")));
assert(os.exists(strings.concat(work, "dep.a")));
let depunit: str = readfile(strings.concat(work,
"ww_root_parity_dep_7f3.unit.ww"));
assert(has(rootunit, "//ww:module ww_root_parity_dep_7f3\n"));
assert(!has(rootunit, "//ww:module ww_root_parity_leaf_7f3\n"));
assert(has(depunit, "//ww:module ww_root_parity_leaf_7f3\n"));
assert(os.exists(strings.concat(work,
"ww_root_parity_leaf_7f3.wwi")));
assert(os.exists(strings.concat(work,
"ww_root_parity_leaf_7f3.a")));
assert(os.exists(strings.concat(work,
"ww_root_parity_dep_7f3.wwi")));
assert(os.exists(strings.concat(work,
"ww_root_parity_dep_7f3.a")));
assert(has(readfile(strings.concat(work, "test.unit.ww")),
"// WW_SRCLIB fixture marker\n"));
assert(!os.exists(strings.concat(work,
"__ww-test-000-same.wwi")));
assert(!os.exists(strings.concat(work,
@@ -2340,30 +2370,41 @@ fn workescape(s: str) str = {
let atrace: str = readfile(assemblertrace);
let ltrace: str = readfile(linkertrace);
assert(occurrences(ctrace, strings.concat("<", work,
"leaf.unit.ww>")) == 1);
"ww_root_parity_leaf_7f3.unit.ww>")) == 1);
assert(occurrences(ctrace, strings.concat("<", work,
"dep.unit.ww>")) == 1);
"ww_root_parity_dep_7f3.unit.ww>")) == 1);
assert(occurrences(ctrace, strings.concat("<", work,
"__ww-test-000-same.unit.ww>")) == 1);
assert(pos(ctrace, strings.concat("<", work, "leaf.unit.ww>"))
< pos(ctrace, strings.concat("<", work, "dep.unit.ww>")));
assert(pos(ctrace, strings.concat("<", work, "dep.unit.ww>"))
assert(pos(ctrace, strings.concat("<", work,
"ww_root_parity_leaf_7f3.unit.ww>"))
< pos(ctrace, strings.concat("<", work,
"ww_root_parity_dep_7f3.unit.ww>")));
assert(pos(ctrace, strings.concat("<", work,
"ww_root_parity_dep_7f3.unit.ww>"))
< pos(ctrace, strings.concat("<", work,
"__ww-test-000-same.unit.ww>")));
assert(has(ctrace, strings.concat("BEGIN<-c><-I><", work,
"dep.wwi><-o><", work, "dep.s><", work, "dep.unit.ww>")));
"ww_root_parity_dep_7f3.wwi><-o><", work,
"ww_root_parity_dep_7f3.s><", work,
"ww_root_parity_dep_7f3.unit.ww>")));
assert(has(ctrace, strings.concat(
"BEGIN<-T><--test-support-module><test><-c><-o><", work,
"__ww-test-000-same.s><", work,
"__ww-test-000-same.unit.ww>")));
assert(has(atrace, strings.concat("BEGIN<-o><", work,
"dep.o><", work, "dep.s>")));
"ww_root_parity_dep_7f3.o><", work,
"ww_root_parity_dep_7f3.s>")));
assert(occurrences(ltrace, "\n") == 1);
assert(has(ltrace, strings.concat("BEGIN<-o><", bin, "><", work,
"__ww-test-000-same.o>")));
assert(has(ltrace, strings.concat("<", work, "dep.a>")));
assert(has(ltrace, strings.concat("<", work, "leaf.a>")));
assert(has(ltrace, strings.concat("<", work,
"ww_root_parity_dep_7f3.a>")));
assert(has(ltrace, strings.concat("<", work,
"ww_root_parity_leaf_7f3.a>")));
assert(has(ltrace, strings.concat("<", work, "test.a>")));
assert(has(ltrace, strings.concat("<", runtime, "/libwwrt.a>")));
assert(!has(ltrace, strings.concat("<", repo(),
"/out/lib/libwwrt.a>")));
assert(!has(ltrace, ".wwi>"));
let runav: []str = [bin];
@@ -2374,9 +2415,9 @@ fn workescape(s: str) str = {
if (si == 0) {
referenceunit = strings.dup(rootunit);
referencewwi = strings.dup(readfile(strings.concat(work,
"dep.wwi")));
"ww_root_parity_dep_7f3.wwi")));
referencearchive = strings.dup(readfile(strings.concat(work,
"dep.a")));
"ww_root_parity_dep_7f3.a")));
referencebin = strings.dup(readfile(bin));
referencecompiler = strings.dup(ctrace);
referenceassembler = strings.dup(atrace);
@@ -2386,9 +2427,11 @@ fn workescape(s: str) str = {
} else {
assert(same(referenceunit, rootunit));
assert(same(referencewwi,
readfile(strings.concat(work, "dep.wwi"))));
readfile(strings.concat(work,
"ww_root_parity_dep_7f3.wwi"))));
assert(same(referencearchive,
readfile(strings.concat(work, "dep.a"))));
readfile(strings.concat(work,
"ww_root_parity_dep_7f3.a"))));
assert(same(referencebin, readfile(bin)));
assert(same(referencecompiler, ctrace));
assert(same(referenceassembler, atrace));
@@ -2414,9 +2457,10 @@ fn workescape(s: str) str = {
runcommandenv(root, strings.concat("exact-argv-fail-", tags[si]), av,
failenv, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 1);
assert(has(out.stderr, "ww: w6c failed for leaf\n"));
assert(has(out.stderr,
"ww: w6c failed for ww_root_parity_leaf_7f3\n"));
assert(has(readfile(failuretrace), strings.concat("<-I><", work,
"leaf.wwi>")));
"ww_root_parity_leaf_7f3.wwi>")));
if (si == 0) { referencefailure = strings.dup(out.stderr); }
else { assert(same(referencefailure, out.stderr)); };
clean(workroot);

347
test/sep/localbuild_test.ww
View File

@@ -41,6 +41,43 @@ fn build(dir: str, driver: str, tag: str, target: str, out: str) i32 = {
return code(dir, strings.concat("build_", tag), av);
};
fn roottraceenv(source: str, runtime: str,
compiler: str, assembler: str, linker: str,
compilertrace: str, assemblertrace: str, linkertrace: str,
realcompiler: str, realassembler: str, reallinker: str) []str = {
let base: []str = os.getenvs();
let env: []str = alloc([], (base.len + 11): u64)!;
let i: i32 = 0;
for (i < base.len) {
if (!strings.hasprefix(base[i], "WW_SRCLIB=")
&& !strings.hasprefix(base[i], "WW_LIB=")
&& !strings.hasprefix(base[i], "WW_W6C=")
&& !strings.hasprefix(base[i], "WW_W6A=")
&& !strings.hasprefix(base[i], "WW_W6L=")
&& !strings.hasprefix(base[i], "WW_ROOT_COMPILER_TRACE=")
&& !strings.hasprefix(base[i], "WW_ROOT_ASSEMBLER_TRACE=")
&& !strings.hasprefix(base[i], "WW_ROOT_LINKER_TRACE=")
&& !strings.hasprefix(base[i], "WW_ROOT_REAL_COMPILER=")
&& !strings.hasprefix(base[i], "WW_ROOT_REAL_ASSEMBLER=")
&& !strings.hasprefix(base[i], "WW_ROOT_REAL_LINKER=")) {
append(env, base[i]);
};
i += 1;
};
append(env, strings.concat("WW_SRCLIB=", source));
append(env, strings.concat("WW_LIB=", runtime));
append(env, strings.concat("WW_W6C=", compiler));
append(env, strings.concat("WW_W6A=", assembler));
append(env, strings.concat("WW_W6L=", linker));
append(env, strings.concat("WW_ROOT_COMPILER_TRACE=", compilertrace));
append(env, strings.concat("WW_ROOT_ASSEMBLER_TRACE=", assemblertrace));
append(env, strings.concat("WW_ROOT_LINKER_TRACE=", linkertrace));
append(env, strings.concat("WW_ROOT_REAL_COMPILER=", realcompiler));
append(env, strings.concat("WW_ROOT_REAL_ASSEMBLER=", realassembler));
append(env, strings.concat("WW_ROOT_REAL_LINKER=", reallinker));
return env;
};
fn diagnosticbody(s: str) str = {
let p: i32 = testenv.pos(s, ": error: ");
// Driver-owned graph diagnostics have no source-location prefix. Compare
@@ -455,6 +492,316 @@ fn writediamond(td: str, reverse: bool) str = {
testenv.clean(td);
};
@test fn toolchain_library_root_stage_parity() void = {
let td: str = testenv.fresh();
let source: str = strings.concat(td, "/source library");
let app: str = strings.concat(source, "/app");
let dep: str = strings.concat(source, "/dep");
let leaf: str = strings.concat(source, "/leaf");
let runtime: str = strings.concat(td, "/runtime library");
let decoy: str = strings.concat(runtime, "/app");
let tools: str = strings.concat(td, "/tool wrappers");
let cwd: str = strings.concat(td, "/isolated cwd");
let defaultapp: str = strings.concat(td, "/default app");
let fallbackbuf: []u8 = alloc([], os.PATH_MAX: u64)!;
fallbackbuf.len = os.PATH_MAX;
let fi: i32 = 0;
for (fi < fallbackbuf.len) { fallbackbuf[fi] = 120u8; fi += 1; };
let fallback: str = strings.frombytes(fallbackbuf);
mkdir(source); mkdir(app); mkdir(dep); mkdir(leaf);
mkdir(runtime); mkdir(decoy); mkdir(tools); mkdir(cwd); mkdir(defaultapp);
testenv.writefile(strings.concat(leaf, "/leaf.ww"), strings.concat(
"package leaf;\n",
"export fn value() i32 = { return 40; };\n"));
testenv.writefile(strings.concat(dep, "/dep.ww"), strings.concat(
"package dep;\nimport leaf;\n",
"export fn value() i32 = { return leaf.value() + 2; };\n"));
testenv.writefile(strings.concat(app, "/app.ww"), strings.concat(
"package main;\nimport dep;\n",
"fn main() i32 = { return dep.value(); };\n"));
testenv.writefile(strings.concat(decoy, "/app.ww"),
"package main;\nfn main() i32 = { return 7; };\n");
testenv.writefile(strings.concat(defaultapp, "/main.ww"), strings.concat(
"package main;\nimport types;\n",
"fn main() i32 = { return (types.I8_MAX: i32) - 85; };\n"));
testenv.writefile(strings.concat(runtime, "/libwwrt.a"),
testenv.readfile(strings.concat(testenv.repo(), "/out/lib/libwwrt.a")));
let compiler: str = strings.concat(tools, "/w6c wrapper.sh");
let assembler: str = strings.concat(tools, "/w6a wrapper.sh");
let linker: str = strings.concat(tools, "/w6l wrapper.sh");
testenv.writeexecutable(compiler, strings.concat(
"#!/bin/sh\n",
"printf 'BEGIN' >> \"$WW_ROOT_COMPILER_TRACE\"\n",
"for arg in \"$@\"; do printf '<%s>' \"$arg\" >> ",
"\"$WW_ROOT_COMPILER_TRACE\"; done\n",
"printf '\\n' >> \"$WW_ROOT_COMPILER_TRACE\"\n",
"exec \"$WW_ROOT_REAL_COMPILER\" \"$@\"\n"));
testenv.writeexecutable(assembler, strings.concat(
"#!/bin/sh\n",
"printf 'BEGIN' >> \"$WW_ROOT_ASSEMBLER_TRACE\"\n",
"for arg in \"$@\"; do printf '<%s>' \"$arg\" >> ",
"\"$WW_ROOT_ASSEMBLER_TRACE\"; done\n",
"printf '\\n' >> \"$WW_ROOT_ASSEMBLER_TRACE\"\n",
"exec \"$WW_ROOT_REAL_ASSEMBLER\" \"$@\"\n"));
testenv.writeexecutable(linker, strings.concat(
"#!/bin/sh\n",
"printf 'BEGIN' >> \"$WW_ROOT_LINKER_TRACE\"\n",
"for arg in \"$@\"; do printf '<%s>' \"$arg\" >> ",
"\"$WW_ROOT_LINKER_TRACE\"; done\n",
"printf '\\n' >> \"$WW_ROOT_LINKER_TRACE\"\n",
"exec \"$WW_ROOT_REAL_LINKER\" \"$@\"\n"));
let stages: []str = ["ww", "ww_ww"];
let compilers: []str = ["w6c", "w6c_ww"];
let assemblers: []str = ["w6a", "w6a_ww"];
let linkers: []str = ["w6l", "w6l_ww"];
let tags: []str = ["c", "ww"];
let modes: []str = ["archive", "overlong-fallback"];
let runtimes: []str = [runtime, fallback];
let bin: str = strings.concat(td, "/published binary");
let workroot: str = strings.concat(bin, ".sepwork");
let work: str = strings.concat(workroot, "/");
let mi: i32 = 0;
for (mi < modes.len) {
let referenceunit: str = "";
let referencewwi: str = "";
let referencearchive: str = "";
let referencebin: str = "";
let referencecompiler: str = "";
let referenceassembler: str = "";
let referencelinker: str = "";
let si: i32 = 0;
for (si < stages.len) {
let prefix: str = strings.concat(modes[mi], "-", tags[si]);
let compilertrace: str = strings.concat(td, "/", prefix,
" compiler trace");
let assemblertrace: str = strings.concat(td, "/", prefix,
" assembler trace");
let linkertrace: str = strings.concat(td, "/", prefix,
" linker trace");
testenv.writefile(compilertrace, "");
testenv.writefile(assemblertrace, "");
testenv.writefile(linkertrace, "");
let env: []str = roottraceenv(source, runtimes[mi],
compiler, assembler, linker,
compilertrace, assemblertrace, linkertrace,
testenv.driver(compilers[si]),
testenv.driver(assemblers[si]),
testenv.driver(linkers[si]));
let av: []str = [testenv.driver(stages[si]), "build", "-o", bin,
"app"];
let out: testenv.commandout;
testenv.runcommandenv(cwd, td, strings.concat("library-root-", prefix),
av, env, tmo(), &out);
if (out.termination != exec.termination.EXIT || out.code != 0
|| out.stderr.len != 0) {
fail("library-roots", strings.concat(prefix, " build failed: ",
out.stderr));
};
let rootunit: str = testenv.readfile(strings.concat(work,
"__root.unit.ww"));
let depunit: str = testenv.readfile(strings.concat(work,
"dep.unit.ww"));
if (!testenv.has(rootunit, "//ww:module dep\n")
|| testenv.has(rootunit, "//ww:module leaf\n")
|| !testenv.has(depunit, "//ww:module leaf\n")) {
fail("library-roots", "compiler inputs crossed the direct-export boundary");
};
if (!testenv.exists(strings.concat(work, "leaf.wwi"))
|| !testenv.exists(strings.concat(work, "leaf.a"))
|| !testenv.exists(strings.concat(work, "dep.wwi"))
|| !testenv.exists(strings.concat(work, "dep.a"))
|| !testenv.exists(strings.concat(work, "__root.o"))
|| testenv.exists(strings.concat(work, "__root.wwi"))
|| testenv.exists(strings.concat(work, "__root.a"))) {
fail("library-roots", "package artifacts do not match root ownership");
};
let ctrace: str = testenv.readfile(compilertrace);
let atrace: str = testenv.readfile(assemblertrace);
let ltrace: str = testenv.readfile(linkertrace);
if (testenv.occurrences(ctrace, strings.concat("<", work,
"leaf.unit.ww>")) != 1
|| testenv.occurrences(ctrace, strings.concat("<", work,
"dep.unit.ww>")) != 1
|| testenv.occurrences(ctrace, strings.concat("<", work,
"__root.unit.ww>")) != 1
|| testenv.pos(ctrace, strings.concat("<", work,
"leaf.unit.ww>")) >= testenv.pos(ctrace, strings.concat("<",
work, "dep.unit.ww>"))
|| testenv.pos(ctrace, strings.concat("<", work,
"dep.unit.ww>")) >= testenv.pos(ctrace, strings.concat("<",
work, "__root.unit.ww>"))) {
fail("library-roots", "compiler actions were not deterministic postorder");
};
if (!testenv.has(ctrace, strings.concat(
"BEGIN<-c><-I><", work, "dep.wwi><-o><", work,
"dep.s><", work, "dep.unit.ww>"))
|| testenv.occurrences(atrace, "\n") != 3
|| !testenv.has(atrace, strings.concat("BEGIN<-o><", work,
"dep.o><", work, "dep.s>"))) {
fail("library-roots", "compiler or assembler argv changed");
};
if (testenv.occurrences(ltrace, "\n") != 1
|| !testenv.has(ltrace, strings.concat("BEGIN<-o><", bin, "><",
work, "__root.o>"))
|| testenv.pos(ltrace, strings.concat("<", work, "dep.a>")) < 0
|| testenv.pos(ltrace, strings.concat("<", work, "leaf.a>"))
< testenv.pos(ltrace, strings.concat("<", work, "dep.a>"))
|| testenv.has(ltrace, ".wwi>")) {
fail("library-roots", "linker did not receive the reachable archive closure");
};
if (mi == 0) {
if (!testenv.has(ltrace, strings.concat("<", runtime,
"/libwwrt.a>"))
|| testenv.has(ltrace, strings.concat("<", testenv.repo(),
"/out/lib/libwwrt.a>"))) {
fail("library-roots", "WW_LIB did not select the runtime archive");
};
} else {
if (!testenv.has(ltrace, strings.concat("<", testenv.repo(),
"/out/bin/../obj/rt/start.o>"))
|| !testenv.has(ltrace, strings.concat("<", testenv.repo(),
"/out/bin/../obj/rt/syscall.o>"))) {
fail("library-roots", "missing runtime archive did not use object fallback");
};
};
let runav: []str = [bin];
if (code(cwd, strings.concat("run-library-root-", prefix), runav)
!= 42) {
fail("library-roots", "WW_SRCLIB did not win over the WW_LIB decoy");
};
if (si == 0) {
referenceunit = strings.dup(rootunit);
referencewwi = strings.dup(testenv.readfile(strings.concat(work,
"dep.wwi")));
referencearchive = strings.dup(testenv.readfile(strings.concat(work,
"dep.a")));
referencebin = strings.dup(testenv.readfile(bin));
referencecompiler = strings.dup(ctrace);
referenceassembler = strings.dup(atrace);
referencelinker = strings.dup(ltrace);
} else {
if (!testenv.same(referenceunit, rootunit)
|| !testenv.same(referencewwi, testenv.readfile(strings.concat(
work, "dep.wwi")))
|| !testenv.same(referencearchive, testenv.readfile(strings.concat(
work, "dep.a")))
|| !testenv.same(referencebin, testenv.readfile(bin))
|| !testenv.same(referencecompiler, ctrace)
|| !testenv.same(referenceassembler, atrace)
|| !testenv.same(referencelinker, ltrace)) {
fail("library-roots", "Cstage and WWstage products or argv differ");
};
};
if (mi == 0) {
let missing: []str = [testenv.driver(stages[si]), "build", "-o",
strings.concat(td, "/missing binary"), "absent"];
testenv.runcommandenv(cwd, td, strings.concat("library-missing-",
tags[si]), missing, env, tmo(), &out);
if (out.termination != exec.termination.EXIT || out.code != 1
|| !testenv.same(out.stderr,
"ww build: cannot find module absent\n")) {
fail("library-roots", "bare-target diagnostic differs by stage");
};
};
testenv.clean(workroot);
assert(os.remove(bin) == 0);
si += 1;
};
mi += 1;
};
let emptyunitreference: str = "";
let emptywwireference: str = "";
let emptyarchivereference: str = "";
let emptybinreference: str = "";
let emptycompilerreference: str = "";
let emptyassemblerreference: str = "";
let emptylinkerreference: str = "";
let emptyout: str = strings.concat(td, "/empty published binary");
let si: i32 = 0;
for (si < stages.len) {
let outpath: str = emptyout;
let emptyworkroot: str = strings.concat(outpath, ".sepwork");
let emptywork: str = strings.concat(emptyworkroot, "/");
let compilertrace: str = strings.concat(td, "/empty-", tags[si],
" compiler trace");
let assemblertrace: str = strings.concat(td, "/empty-", tags[si],
" assembler trace");
let linkertrace: str = strings.concat(td, "/empty-", tags[si],
" linker trace");
testenv.writefile(compilertrace, "");
testenv.writefile(assemblertrace, "");
testenv.writefile(linkertrace, "");
let emptyenv: []str = roottraceenv("", "",
compiler, assembler, linker,
compilertrace, assemblertrace, linkertrace,
testenv.driver(compilers[si]),
testenv.driver(assemblers[si]),
testenv.driver(linkers[si]));
let av: []str = [testenv.driver(stages[si]), "build", "-o", outpath,
defaultapp];
let out: testenv.commandout;
testenv.runcommandenv(cwd, td, strings.concat("empty-library-",
tags[si]), av, emptyenv, tmo(), &out);
let rootunit: str = testenv.readfile(strings.concat(emptywork,
"__root.unit.ww"));
let ctrace: str = testenv.readfile(compilertrace);
let atrace: str = testenv.readfile(assemblertrace);
let ltrace: str = testenv.readfile(linkertrace);
let runav: []str = [outpath];
if (out.termination != exec.termination.EXIT || out.code != 0
|| out.stderr.len != 0
|| code(cwd, strings.concat("run-empty-library-", tags[si]),
runav) != 42) {
fail("library-roots", "empty override did not use default roots");
};
if (!testenv.has(rootunit, "//ww:module types\n")
|| !testenv.exists(strings.concat(emptywork, "types.wwi"))
|| !testenv.exists(strings.concat(emptywork, "types.a"))
|| testenv.occurrences(ctrace, strings.concat("<", emptywork,
"types.unit.ww>")) != 1
|| testenv.occurrences(atrace, "\n") != 2) {
fail("library-roots", "empty WW_SRCLIB did not use the default source root");
};
if (testenv.occurrences(ltrace, "\n") != 1
|| !testenv.has(ltrace, strings.concat("<", emptywork, "types.a>"))
|| !testenv.has(ltrace, strings.concat("<", testenv.repo(),
"/out/bin/../lib/libwwrt.a>"))
|| testenv.has(ltrace, "/../obj/rt/start.o>")
|| testenv.has(ltrace, "/../obj/rt/syscall.o>")) {
fail("library-roots", "empty WW_LIB did not use the default runtime archive");
};
if (si == 0) {
emptyunitreference = strings.dup(rootunit);
emptywwireference = strings.dup(testenv.readfile(strings.concat(
emptywork, "types.wwi")));
emptyarchivereference = strings.dup(testenv.readfile(strings.concat(
emptywork, "types.a")));
emptybinreference = strings.dup(testenv.readfile(outpath));
emptycompilerreference = strings.dup(ctrace);
emptyassemblerreference = strings.dup(atrace);
emptylinkerreference = strings.dup(ltrace);
} else { if (!testenv.same(emptyunitreference, rootunit)
|| !testenv.same(emptywwireference, testenv.readfile(strings.concat(
emptywork, "types.wwi")))
|| !testenv.same(emptyarchivereference, testenv.readfile(
strings.concat(emptywork, "types.a")))
|| !testenv.same(emptybinreference, testenv.readfile(outpath))
|| !testenv.same(emptycompilerreference, ctrace)
|| !testenv.same(emptyassemblerreference, atrace)
|| !testenv.same(emptylinkerreference, ltrace)) {
fail("library-roots", "empty-root fallback changed stage output or argv");
}; };
testenv.clean(emptyworkroot);
assert(os.remove(outpath) == 0);
si += 1;
};
testenv.clean(td);
};
@test fn builtin_type_precedence() void = {
let td: str = testenv.fresh();
let dep: str = strings.concat(td, "/builtinshadow"); mkdir(dep);