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

build: pass direct exports to package compilers

Browse Source
This commit is contained in:
Hojun-Cho
2026-08-12 18:42:22 +09:00
parent b373c445bd
commit edd3f4ee83
13 changed files with 678 additions and 611 deletions
Download Patch File Download Diff File Expand all files Collapse all files

446
test/package/package_test.ww
View File

@@ -726,8 +726,9 @@ fn workescape(s: str) str = {
let prodwork: str = strings.concat(prodout, ".sepwork/");
let produnit: str = readfile(strings.concat(prodwork,
"pkg.unit.ww"));
assert(has(produnit, "//ww:module api\n"));
assert(!has(produnit, "//ww:module implementation\n"));
assert(has(produnit, "//ww:module-reset pkg\n"));
assert(!has(produnit, "//ww:module "));
assert(!has(produnit, "IMPLEMENTATION_SOURCE"));
assert(!has(produnit, "__same"));
assert(!has(produnit, "__external"));
assert(!os.exists(strings.concat(prodwork, "__same.unit.ww")));
@@ -807,30 +808,20 @@ fn workescape(s: str) str = {
let externalproduction: str = readfile(strings.concat(sharedwork,
"__ww-test-001-external-production.unit.ww"));
assert(!os.exists(strings.concat(externalbin, ".sepwork")));
assert(has(sameunit, "//ww:module api\n"));
assert(has(sameunit, "//ww:module __same\n"));
assert(has(sameunit, "//ww:module test\n"));
assert(!has(sameunit, "//ww:module implementation\n"));
assert(!has(sameunit, "//ww:module __external\n"));
assert(!has(sameunit, "//ww:module "));
assert(os.exists(strings.concat(sharedwork,
"__external.unit.ww")));
assert(has(sameunit, "PACKAGE_PRODUCTION_A"));
assert(has(sameunit, "PACKAGE_PRODUCTION_Z"));
assert(has(sameunit, "SAME_TEST_SOURCE"));
assert(!has(sameunit, "EXTERNAL_TEST_SOURCE"));
assert(has(externalunit, "//ww:module pkg\n"));
assert(has(externalunit, "//ww:module __external\n"));
assert(has(externalunit, "//ww:module test\n"));
assert(!has(externalunit, "//ww:module api\n"));
assert(!has(externalunit, "//ww:module implementation\n"));
assert(!has(externalunit, "//ww:module __same\n"));
assert(!has(externalunit, "//ww:module "));
assert(has(externalunit, "EXTERNAL_TEST_SOURCE"));
assert(!has(externalunit, "PACKAGE_PRODUCTION_A"));
assert(!has(externalunit, "PACKAGE_PRODUCTION_Z"));
assert(has(externalproduction, "PACKAGE_PRODUCTION_A"));
assert(has(externalproduction, "PACKAGE_PRODUCTION_Z"));
assert(has(externalproduction, "//ww:module api\n"));
assert(!has(externalproduction, "//ww:module implementation\n"));
assert(!has(externalproduction, "//ww:module "));
assert(!has(externalproduction, "SAME_TEST_SOURCE"));
assert(!has(externalproduction, "EXTERNAL_TEST_SOURCE"));
assert(!has(readfile(strings.concat(sharedwork, "api.unit.ww")),
@@ -872,6 +863,30 @@ fn workescape(s: str) str = {
"__ww-test-001-external.unit.ww") == 1);
assert(occurrences(ctrace,
"-T --test-support-module") == 2);
let samecompile: str = linecontaining(ctrace,
"__ww-test-000-same.unit.ww");
let externalcompile: str = linecontaining(ctrace,
"__ww-test-001-external.unit.ww");
let productioncompile: str = linecontaining(ctrace,
"__ww-test-001-external-production.unit.ww");
assert(same(samecompile, strings.concat(
"-T --test-support-module test -c --import __same ",
sharedwork, "__same.wwi --import api ", sharedwork,
"api.wwi --import test ", sharedwork, "test.wwi -o ",
sharedwork, "__ww-test-000-same.s ", sharedwork,
"__ww-test-000-same.unit.ww")));
assert(same(externalcompile, strings.concat(
"-T --test-support-module test -c --import __external ",
sharedwork, "__external.wwi --import pkg ", sharedwork,
"__ww-test-001-external-production.wwi --import test ",
sharedwork, "test.wwi -o ", sharedwork,
"__ww-test-001-external.s ", sharedwork,
"__ww-test-001-external.unit.ww")));
assert(same(productioncompile, strings.concat(
"-c --import api ", sharedwork, "api.wwi -I ", sharedwork,
"__ww-test-001-external-production.wwi -o ", sharedwork,
"__ww-test-001-external-production.s ", sharedwork,
"__ww-test-001-external-production.unit.ww")));
let ltrace: str = readfile(linkertrace);
assert(occurrences(ltrace, "\n") == 2);
let samelink: str = linecontaining(ltrace,
@@ -1204,43 +1219,33 @@ fn workescape(s: str) str = {
alphaartifact, ".unit.ww"));
let betaunit: str = readfile(strings.concat(sharedwork,
betaartifact, ".unit.ww"));
assert(has(commonunit, "//ww:module leaf\n"));
assert(!has(commonunit, "//ww:module test\n"));
assert(has(alphaunit, "//ww:module common\n"));
assert(!has(alphaunit, "//ww:module leaf\n"));
assert(has(commonunit, "//ww:module-reset common\n"));
assert(!has(commonunit, "//ww:module "));
assert(!has(alphaunit, "//ww:module "));
assert(has(alphaunit, "MULTIDIR_ALPHA_A"));
assert(has(alphaunit, "MULTIDIR_ALPHA_Z"));
assert(has(betaunit, "//ww:module common\n"));
assert(has(betaunit, "//ww:module alpha\n"));
assert(!has(betaunit, "//ww:module leaf\n"));
assert(!has(betaunit, "//ww:module "));
assert(has(betaunit, "MULTIDIR_BETA"));
assert(!has(commonunit, "DEPENDENCY_TEST_FILE_MUST_NOT_COMPILE"));
let roots: []str = [readfile(strings.concat(sharedwork,
rootkeys[0], ".unit.ww")), readfile(strings.concat(sharedwork,
rootkeys[1], ".unit.ww")), readfile(strings.concat(sharedwork,
rootkeys[2], ".unit.ww")), readfile(strings.concat(sharedwork,
rootkeys[3], ".unit.ww"))];
assert(has(roots[0], "//ww:module _alpha_same\n"));
assert(has(roots[0], "//ww:module common\n"));
assert(has(roots[0], "//ww:module test\n"));
assert(!has(roots[0], "//ww:module leaf\n"));
assert(!has(roots[0], "//ww:module alpha\n"));
assert(!has(roots[0], "//ww:module "));
assert(has(roots[0], "MULTIDIR_ALPHA_A"));
assert(has(roots[0], "MULTIDIR_ALPHA_Z"));
assert(has(roots[1], "//ww:module alpha\n"));
assert(has(roots[1], "//ww:module _alpha_external\n"));
assert(has(roots[1], "//ww:module test\n"));
assert(!has(roots[1], "//ww:module common\n"));
assert(!has(roots[1], "//ww:module _alpha_same\n"));
assert(has(roots[2], "//ww:module _beta_same\n"));
assert(has(roots[2], "//ww:module common\n"));
assert(has(roots[2], "//ww:module alpha\n"));
assert(has(roots[2], "//ww:module test\n"));
assert(!has(roots[2], "//ww:module leaf\n"));
assert(!has(roots[2], "//ww:module beta\n"));
assert(has(roots[3], "//ww:module beta\n"));
assert(has(roots[3], "//ww:module _beta_external\n"));
assert(has(roots[3], "//ww:module test\n"));
assert(!has(roots[3], "//ww:module common\n"));
assert(has(roots[0], "MULTIDIR_ALPHA_SAME"));
assert(!has(roots[0], "MULTIDIR_ALPHA_EXTERNAL"));
assert(!has(roots[1], "//ww:module "));
assert(has(roots[1], "MULTIDIR_ALPHA_EXTERNAL"));
assert(!has(roots[1], "MULTIDIR_ALPHA_A"));
assert(!has(roots[2], "//ww:module "));
assert(has(roots[2], "MULTIDIR_BETA"));
assert(has(roots[2], "MULTIDIR_BETA_SAME"));
assert(!has(roots[3], "//ww:module "));
assert(has(roots[3], "MULTIDIR_BETA_EXTERNAL"));
assert(!has(roots[3], "MULTIDIR_BETA_SAME"));
let products: []str = ["leaf", "common", alphaartifact, betaartifact,
"_alpha_same", "_alpha_external", "_beta_same",
"_beta_external", "test"];
@@ -1625,13 +1630,7 @@ fn workescape(s: str) str = {
let ri: i32 = 0;
for (ri < keys.len) {
let unit: str = readfile(strings.concat(work, keys[ri], ".unit.ww"));
assert(has(unit, "//ww:module __wwtest\n"));
if (ri == 1 || ri == 2) {
assert(has(unit, "//ww:module test\n"));
};
if (ri == 3) {
assert(has(unit, "//ww:module consumer\n"));
};
assert(!has(unit, "//ww:module "));
let runav: []str = [bins[ri]];
runcommand(root, strings.concat("mixed-run-", stages[si], "-",
keys[ri]), runav,
@@ -1748,8 +1747,8 @@ fn workescape(s: str) str = {
let cbin: str = readfile(bin);
let rootunit: str = readfile(strings.concat(work,
"__ww-test-000-same.unit.ww"));
assert(has(rootunit, "//ww:module p00\n"));
assert(!has(rootunit, "//ww:module p01\n"));
assert(has(rootunit, "//ww:module-reset\npackage target;"));
assert(!has(rootunit, "//ww:module "));
let linkargs: str = readfile(trace);
assert(linkargs.len > 8192);
assert(!has(linkargs, ".wwi\n"));
@@ -2075,8 +2074,7 @@ fn workescape(s: str) str = {
"__ww-test-000-external-production.unit.ww"));
let supportunit: str = readfile(strings.concat(work,
"__wwtest.unit.ww"));
assert(has(rootunit, "//ww:module test\n"));
assert(has(rootunit, "//ww:module __wwtest\n"));
assert(!has(rootunit, "//ww:module "));
assert(has(rootunit, "USER_TEST_EXTERNAL"));
assert(!has(rootunit, "USER_TEST_PACKAGE_A"));
assert(!has(rootunit, "USER_TEST_PACKAGE_Z"));
@@ -2115,121 +2113,52 @@ fn workescape(s: str) str = {
clean(root);
};
@test fn diamond_test_dependency_compiles_once() void = {
let root: str = fresh();
let shared: str = strings.concat(root, "/shared");
let left: str = strings.concat(root, "/left");
let right: str = strings.concat(root, "/right");
let target: str = strings.concat(root, "/diamond");
assert(os.mkdir(shared, 448i32) == 0);
assert(os.mkdir(left, 448i32) == 0);
assert(os.mkdir(right, 448i32) == 0);
assert(os.mkdir(target, 448i32) == 0);
writefile(strings.concat(shared, "/shared.ww"),
"package shared;\nexport fn value() i32 = { return 20; };\n");
writefile(strings.concat(left, "/left.ww"), strings.concat(
"package left;\nimport shared;\n",
"export fn value() i32 = { return shared.value(); };\n"));
writefile(strings.concat(right, "/right.ww"), strings.concat(
"package right;\nimport shared;\n",
"export fn value() i32 = { return shared.value() + 1; };\n"));
writefile(strings.concat(target, "/diamond.ww"),
"package diamond;\nfn local() i32 = { return 1; };\n");
writefile(strings.concat(target, "/diamond_test.ww"), strings.concat(
"package diamond;\nimport left;\nimport right;\n",
"@test fn one_shared_compile() void = {\n",
" assert(left.value() + right.value() + local() == 42);\n};\n"));
let trace: str = strings.concat(root, "/compiler.trace");
let wrapper: str = strings.concat(root, "/trace-w6c.sh");
writefile(trace, "");
writeexecutable(wrapper, strings.concat(
"#!/bin/sh\n",
"printf '%s\\n' \"$*\" >> \"$WW_PACKAGE_TRACE\"\n",
"exec \"$WW_PACKAGE_W6C\" \"$@\"\n"));
let baseenv: []str = os.getenvs();
let env: []str = alloc([], (baseenv.len + 3): u64)!;
let ei: i32 = 0;
for (ei < baseenv.len) {
if (!strings.hasprefix(baseenv[ei], "WW_W6C=")
&& !strings.hasprefix(baseenv[ei], "WW_PACKAGE_TRACE=")
&& !strings.hasprefix(baseenv[ei], "WW_PACKAGE_W6C=")) {
append(env, baseenv[ei]);
};
ei += 1;
};
append(env, strings.concat("WW_W6C=", wrapper));
append(env, strings.concat("WW_PACKAGE_TRACE=", trace));
append(env, strings.concat("WW_PACKAGE_W6C=", driver("w6c")));
let bin: str = strings.concat(root, "/diamond.test");
let av: []str = [driver("ww"), "test", "-c", "-o", bin,
"-I", root, target];
let out: commandout;
runcommandenv(root, "diamond-build", av, env,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(occurrences(readfile(trace), "shared.unit.ww") == 1);
let work: str = strings.concat(bin, ".sepwork/");
let unit: str = readfile(strings.concat(work,
"__ww-test-000-same.unit.ww"));
assert(has(unit, "//ww:module left\n"));
assert(has(unit, "//ww:module right\n"));
assert(!has(unit, "//ww:module shared\n"));
assert(has(readfile(strings.concat(work, "left.unit.ww")),
"//ww:module shared\n"));
assert(has(readfile(strings.concat(work, "right.unit.ww")),
"//ww:module shared\n"));
assert(os.exists(strings.concat(work, "shared.a")));
let runav: []str = [bin];
runcommand(root, "diamond-run", runav,
(60i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(has(out.stdout, "one_shared_compile ... ok\n"));
clean(root);
};
@test fn exact_package_tool_argv_stage_parity() void = {
let root: str = fresh();
let source: str = strings.concat(root, "/source tree");
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 base: str = strings.concat(source, "/ww_root_parity_base_7f3");
let left: str = strings.concat(source, "/ww_root_parity_left_7f3");
let right: str = strings.concat(source, "/ww_root_parity_right_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(base, 448i32) == 0);
assert(os.mkdir(left, 448i32) == 0);
assert(os.mkdir(right, 448i32) == 0);
assert(os.mkdir(target, 448i32) == 0);
assert(os.mkdir(tools, 448i32) == 0);
writefile(strings.concat(leaf, "/leaf.ww"), strings.concat(
"package ww_root_parity_leaf_7f3;\n",
"export fn value() i32 = { return 40; };\n"));
writefile(strings.concat(dep, "/dep.ww"), strings.concat(
"package ww_root_parity_dep_7f3;\n",
"import ww_root_parity_leaf_7f3;\n",
let basea: str = strings.concat(
"package ww_root_parity_base_7f3;\n",
"export fn value() i32 = { return 20; };\n");
let basez: str = strings.concat(
"package ww_root_parity_base_7f3;\n",
"fn private_value() i32 = { return 99; };\n");
let leftbody: str = strings.concat(
"package ww_root_parity_left_7f3;\n",
"import ww_root_parity_base_7f3;\n",
"import ww_root_parity_base_7f3;\n",
"export fn value() i32 = { return ",
"ww_root_parity_leaf_7f3.value() + 2; };\n"));
writefile(strings.concat(target, "/target.ww"), strings.concat(
"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 ww_root_parity_target_7f3;\n",
"@test fn exact_argv() void = { assert(value() == 42); };\n"));
"ww_root_parity_base_7f3.value(); };\n");
let rightbody: str = strings.concat(
"package ww_root_parity_right_7f3;\n",
"import ww_root_parity_base_7f3;\n",
"export fn value() i32 = { return ",
"ww_root_parity_base_7f3.value() + 1; };\n");
let rootbody: str = strings.concat(
"package main;\n",
"import ww_root_parity_right_7f3;\n",
"import ww_root_parity_left_7f3;\n",
"fn main() i32 = { return ww_root_parity_left_7f3.value() + ",
"ww_root_parity_right_7f3.value() + 1; };\n");
writefile(strings.concat(base, "/a.ww"), basea);
writefile(strings.concat(base, "/z.ww"), basez);
writefile(strings.concat(left, "/left.ww"), leftbody);
writefile(strings.concat(right, "/right.ww"), rightbody);
writefile(strings.concat(target, "/main.ww"), rootbody);
let compilerwrapper: str = strings.concat(tools, "/w6c wrapper.sh");
let assemblerwrapper: str = strings.concat(tools, "/w6a wrapper.sh");
@@ -2262,19 +2191,43 @@ fn workescape(s: str) str = {
"for arg in \"$@\"; do printf '<%s>' \"$arg\" >> ",
"\"$WW_ARGV_FAILURE_TRACE\"; done\n",
"printf '\\n' >> \"$WW_ARGV_FAILURE_TRACE\"\n",
"exit 23\n"));
"owner=\n",
"for arg in \"$@\"; do if [ \"$arg\" = ",
"\"$WW_ARGV_MISSING_OWNER\" ]; then owner=1; fi; done\n",
"if [ -n \"$owner\" ]; then\n",
" mv -- \"$WW_ARGV_MISSING_EXPORT\" ",
"\"$WW_ARGV_MISSING_EXPORT.saved\" || exit 24\n",
" \"$WW_ARGV_REAL_COMPILER\" \"$@\"\n",
" rc=$?\n",
" mv -- \"$WW_ARGV_MISSING_EXPORT.saved\" ",
"\"$WW_ARGV_MISSING_EXPORT\" || exit 25\n",
" exit $rc\n",
"fi\n",
"exec \"$WW_ARGV_REAL_COMPILER\" \"$@\"\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 bin: str = strings.concat(root, "/published test binary");
let stages: []str = ["ww", "ww", "ww_ww", "ww_ww"];
let compilers: []str = ["w6c", "w6c", "w6c_ww", "w6c_ww"];
let assemblers: []str = ["w6a", "w6a", "w6a_ww", "w6a_ww"];
let linkers: []str = ["w6l", "w6l", "w6l_ww", "w6l_ww"];
let tags: []str = ["c1", "c2", "ww1", "ww2"];
let bin: str = strings.concat(root, "/published binary");
let workroot: str = strings.concat(bin, ".sepwork");
let work: str = strings.concat(workroot, "/");
let referenceunit: str = "";
let referencewwi: str = "";
let referencearchive: str = "";
let artifacts: []str = ["ww_root_parity_base_7f3",
"ww_root_parity_left_7f3", "ww_root_parity_right_7f3"];
let unitartifacts: []str = ["ww_root_parity_base_7f3",
"ww_root_parity_left_7f3", "ww_root_parity_right_7f3", "__root"];
let wantunits: []str = [strings.concat(
"//ww:module-reset ww_root_parity_base_7f3\n", basea,
"\n//ww:module-reset ww_root_parity_base_7f3\n", basez, "\n"),
strings.concat("//ww:module-reset ww_root_parity_left_7f3\n",
leftbody, "\n"),
strings.concat("//ww:module-reset ww_root_parity_right_7f3\n",
rightbody, "\n"),
strings.concat("//ww:module-reset\n", rootbody, "\n")];
let referenceunits: []str = ["", "", "", ""];
let referenceexports: []str = ["", "", ""];
let referencearchives: []str = ["", "", ""];
let referencebin: str = "";
let referencecompiler: str = "";
let referenceassembler: str = "";
@@ -2316,7 +2269,13 @@ fn workescape(s: str) str = {
&& !strings.hasprefix(baseenv[ei],
"WW_ARGV_REAL_ASSEMBLER=")
&& !strings.hasprefix(baseenv[ei],
"WW_ARGV_REAL_LINKER=")) {
"WW_ARGV_REAL_LINKER=")
&& !strings.hasprefix(baseenv[ei],
"WW_ARGV_FAILURE_TRACE=")
&& !strings.hasprefix(baseenv[ei],
"WW_ARGV_MISSING_EXPORT=")
&& !strings.hasprefix(baseenv[ei],
"WW_ARGV_MISSING_OWNER=")) {
append(env, baseenv[ei]);
};
ei += 1;
@@ -2336,72 +2295,89 @@ fn workescape(s: str) str = {
append(env, strings.concat("WW_ARGV_REAL_LINKER=",
driver(linkers[si])));
let av: []str = [driver(stages[si]), "test", "-c", "-o", bin,
let av: []str = [driver(stages[si]), "build", "-o", bin,
target];
let out: commandout;
runcommandenv(root, strings.concat("exact-argv-", tags[si]), av, env,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
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,
"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,
"__ww-test-000-same.a")));
let ui: i32 = 0;
for (ui < unitartifacts.len) {
let unit: str = readfile(strings.concat(work, unitartifacts[ui],
".unit.ww"));
assert(same(unit, wantunits[ui]));
assert(!has(unit, "//ww:module "));
if (si == 0) { referenceunits[ui] = strings.dup(unit); }
else { assert(same(referenceunits[ui], unit)); };
ui += 1;
};
let ai: i32 = 0;
for (ai < artifacts.len) {
let exportf: str = readfile(strings.concat(work, artifacts[ai],
".wwi"));
let archive: str = readfile(strings.concat(work, artifacts[ai],
".a"));
if (si == 0) {
referenceexports[ai] = strings.dup(exportf);
referencearchives[ai] = strings.dup(archive);
} else {
assert(same(referenceexports[ai], exportf));
assert(same(referencearchives[ai], archive));
};
ai += 1;
};
assert(!os.exists(strings.concat(work, "__root.wwi")));
assert(!os.exists(strings.concat(work, "__root.a")));
assert(os.exists(bin));
let ctrace: str = readfile(compilertrace);
let atrace: str = readfile(assemblertrace);
let ltrace: str = readfile(linkertrace);
assert(occurrences(ctrace, strings.concat("<", work,
"ww_root_parity_leaf_7f3.unit.ww>")) == 1);
assert(occurrences(ctrace, strings.concat("<", work,
"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,
"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,
"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(occurrences(ctrace, "\n") == 4);
let baseline: str = strings.concat("BEGIN<-c><-I><", work,
"ww_root_parity_base_7f3.wwi><-o><", work,
"ww_root_parity_base_7f3.s><", work,
"ww_root_parity_base_7f3.unit.ww>");
let leftline: str = strings.concat("BEGIN<-c><--import>",
"<ww_root_parity_base_7f3><", work,
"ww_root_parity_base_7f3.wwi><-I><", work,
"ww_root_parity_left_7f3.wwi><-o><", work,
"ww_root_parity_left_7f3.s><", work,
"ww_root_parity_left_7f3.unit.ww>");
let rightline: str = strings.concat("BEGIN<-c><--import>",
"<ww_root_parity_base_7f3><", work,
"ww_root_parity_base_7f3.wwi><-I><", work,
"ww_root_parity_right_7f3.wwi><-o><", work,
"ww_root_parity_right_7f3.s><", work,
"ww_root_parity_right_7f3.unit.ww>");
let rootline: str = strings.concat("BEGIN<-c><--import>",
"<ww_root_parity_left_7f3><", work,
"ww_root_parity_left_7f3.wwi><--import>",
"<ww_root_parity_right_7f3><", work,
"ww_root_parity_right_7f3.wwi><-o><", work,
"__root.s><", work, "__root.unit.ww>");
assert(same(linecontaining(ctrace,
"ww_root_parity_base_7f3.unit.ww"), baseline));
assert(same(linecontaining(ctrace,
"ww_root_parity_left_7f3.unit.ww"), leftline));
assert(same(linecontaining(ctrace,
"ww_root_parity_right_7f3.unit.ww"), rightline));
assert(same(linecontaining(ctrace, "__root.unit.ww"), rootline));
assert(!has(rootline, "ww_root_parity_base_7f3.wwi"));
assert(occurrences(atrace, "\n") == 4);
assert(has(atrace, strings.concat("BEGIN<-o><", work,
"ww_root_parity_dep_7f3.o><", work,
"ww_root_parity_dep_7f3.s>")));
"ww_root_parity_left_7f3.o><", work,
"ww_root_parity_left_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,
"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>")));
"__root.o>")));
ai = 0;
for (ai < artifacts.len) {
assert(occurrences(ltrace, strings.concat("<", work, artifacts[ai],
".a>")) == 1);
ai += 1;
};
assert(has(ltrace, strings.concat("<", runtime, "/libwwrt.a>")));
assert(!has(ltrace, strings.concat("<", repo(),
"/out/lib/libwwrt.a>")));
@@ -2410,14 +2386,9 @@ fn workescape(s: str) str = {
let runav: []str = [bin];
runcommand(root, strings.concat("exact-argv-run-", tags[si]), runav,
(60i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(has(out.stdout, "exact_argv ... ok\n"));
expectexit(&out, 42);
assert(out.stdout.len == 0 && out.stderr.len == 0);
if (si == 0) {
referenceunit = strings.dup(rootunit);
referencewwi = strings.dup(readfile(strings.concat(work,
"ww_root_parity_dep_7f3.wwi")));
referencearchive = strings.dup(readfile(strings.concat(work,
"ww_root_parity_dep_7f3.a")));
referencebin = strings.dup(readfile(bin));
referencecompiler = strings.dup(ctrace);
referenceassembler = strings.dup(atrace);
@@ -2425,13 +2396,6 @@ fn workescape(s: str) str = {
referenceout = strings.dup(out.stdout);
referenceerr = strings.dup(out.stderr);
} else {
assert(same(referenceunit, rootunit));
assert(same(referencewwi,
readfile(strings.concat(work,
"ww_root_parity_dep_7f3.wwi"))));
assert(same(referencearchive,
readfile(strings.concat(work,
"ww_root_parity_dep_7f3.a"))));
assert(same(referencebin, readfile(bin)));
assert(same(referencecompiler, ctrace));
assert(same(referenceassembler, atrace));
@@ -2442,7 +2406,7 @@ fn workescape(s: str) str = {
clean(workroot);
clean(bin);
let failenv: []str = alloc([], (env.len + 2): u64)!;
let failenv: []str = alloc([], (env.len + 4): u64)!;
ei = 0;
for (ei < env.len) {
if (!strings.hasprefix(env[ei], "WW_W6C=")
@@ -2454,13 +2418,21 @@ fn workescape(s: str) str = {
};
append(failenv, strings.concat("WW_W6C=", failurewrapper));
append(failenv, strings.concat("WW_ARGV_FAILURE_TRACE=", failuretrace));
append(failenv, strings.concat("WW_ARGV_MISSING_EXPORT=", work,
"ww_root_parity_base_7f3.wwi"));
append(failenv, strings.concat("WW_ARGV_MISSING_OWNER=", work,
"ww_root_parity_left_7f3.unit.ww"));
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 ww_root_parity_leaf_7f3\n"));
assert(has(readfile(failuretrace), strings.concat("<-I><", work,
"ww_root_parity_leaf_7f3.wwi>")));
let wantfailure: str = strings.concat(
"w6c: import ww_root_parity_base_7f3: cannot read ", work,
"ww_root_parity_base_7f3.wwi\n",
"ww: w6c failed for ww_root_parity_left_7f3\n");
assert(same(out.stderr, wantfailure));
assert(has(readfile(failuretrace), strings.concat(
"<--import><ww_root_parity_base_7f3><", work,
"ww_root_parity_base_7f3.wwi>")));
if (si == 0) { referencefailure = strings.dup(out.stderr); }
else { assert(same(referencefailure, out.stderr)); };
clean(workroot);