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

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);