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

ww test: retain directory test binaries like Go

Browse Source
This commit is contained in:
Hojun-Cho
2026-08-20 20:13:08 +09:00
parent f28843f2f5
commit db5782eff9
10 changed files with 1014 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

582
test/package/package_test.ww
View File

@@ -1159,12 +1159,12 @@ fn cwdwritedata(dir: str, label: str) void = {
caller, stdinpath,
(90i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
let defaultbin: str = strings.concat(p2, "/p2.test");
let defaultbin: str = strings.concat(caller, "/p2.test");
assert(os.exists(defaultbin));
assert(!os.exists(strings.concat(p2, "/p2.test")));
assert(!os.exists(strings.concat(p2, "/created.txt")));
assert(!has(out.stdout, "dep-init") && !has(out.stdout, "p2-external"));
assert(os.remove(defaultbin) == 0);
clean(strings.concat(defaultbin, ".sepwork"));
assert(os.remove(strings.concat(p1, "/created.txt")) == 0);
let p1cbin: str = strings.concat(root, "/p1-c.test");
@@ -1814,6 +1814,12 @@ fn cwdwritedata(dir: str, label: str) void = {
"toexternal_test", "tomixed"];
let shapetargetsecond: []str = ["", "shapeexternal_test", "", "",
"tomixed_test"];
let shapeproductionselector: []str = ["shapeinternal", "shapeexternal",
"-", "-", "-"];
let shapeinternalselector: []str = ["shapeinternal", "-", "tosame",
"-", "tomixed"];
let shapeexternalselector: []str = ["-", "shapeexternal_test", "-",
"toexternal_test", "tomixed_test"];
let shapecompilerrefs: []str = ["", "", "", "", ""];
let shapelinkerrefs: []str = ["", "", "", "", ""];
let shapemainrefs: []str = ["", "", "", "", ""];
@@ -1827,6 +1833,7 @@ fn cwdwritedata(dir: str, label: str) void = {
let shapebin: str = strings.concat(root, "/shape-product-",
boundarypkgname(sj), ".test");
let shapework: str = strings.concat(shapebin, ".sepwork");
let shapestatus: str = strings.concat(shapebin, ".status");
let ctracepath: str = strings.concat(root, "/shape-compiler-",
boundarypkgname(sj), ".trace");
let ltracepath: str = strings.concat(root, "/shape-linker-",
@@ -1835,6 +1842,7 @@ fn cwdwritedata(dir: str, label: str) void = {
writefile(ltracepath, "");
let stagei: i32 = 0;
for (stagei < stages.len) {
assert(os.mkdir(shapework, 448i32) == 0);
if (stagei != 0) {
rewritefile(ctracepath, "");
rewritefile(ltracepath, "");
@@ -1864,8 +1872,12 @@ fn cwdwritedata(dir: str, label: str) void = {
driver(shapecompilers[stagei])));
append(env, strings.concat("WW_SHAPE_REAL_LINKER=",
driver(shapelinkers[stagei])));
let shapeav: []str = [driver(stages[stagei]), "test", "-c", "-o",
shapebin, "-I", root, shapes[index]];
let shapeav: []str = [driver(stages[stagei]), "test", "-c", "-w",
shapework, "-I", root,
"--ww-package-test", "test", shapefamilies[index],
shapeproductionselector[sj], shapeinternalselector[sj],
shapeexternalselector[sj], shapes[index], shapebin, "-",
shapestatus, shapes[index]];
runcommandenv(root, strings.concat("shape-structure-",
stages[stagei], "-", boundarypkgname(sj)), shapeav, env,
(120i64 * (time.second: i64)): time.duration, &out);
@@ -1876,9 +1888,9 @@ fn cwdwritedata(dir: str, label: str) void = {
shapefamilies[index], ".test")));
let ctrace: str = readfile(ctracepath);
let ltrace: str = readfile(ltracepath);
assert(occurrences(ctrace, "-test-main.unit.ww") == 1);
assert(occurrences(ctrace, "-test-main.unit.new") == 1);
let mainline: str = linecontaining(ctrace,
strings.concat("/", shapemains[sj], ".unit.ww"));
strings.concat("/", shapemains[sj], ".unit.new"));
let targetcount: i32 = 1;
if (shapetargetsecond[sj].len != 0) { targetcount = 2; };
assert(occurrences(mainline, "--test-target-package")
@@ -1932,6 +1944,7 @@ fn cwdwritedata(dir: str, label: str) void = {
};
clean(shapework);
clean(shapebin);
clean(shapestatus);
stagei += 1;
};
sj += 1;
@@ -2191,37 +2204,39 @@ fn cwdwritedata(dir: str, label: str) void = {
assert(same(outc.stderr, outw.stderr));
assert(has(outc.stderr, "usage: wwtest package"));
let cc: []str = [driver("ww"), "test", "-c", "-I", root, route];
let cwork: str = strings.concat(root, "/compile-c-work");
let wwork: str = strings.concat(root, "/compile-ww-work");
let cbinarypath: str = strings.concat(root, "/route-c.test");
let wbinarypath: str = strings.concat(root, "/route-ww.test");
let cc: []str = [driver("ww"), "test", "-w", cwork, "-o",
cbinarypath, "-I", root, route];
runcommand(root, "compile-c", cc,
(30i64 * (time.second: i64)): time.duration, &outc);
expectexit(&outc, 0);
assert(has(outc.stdout, strings.concat(" -> ", route, "/route.test\n")));
assert(occurrences(outc.stdout, "built ") == 1);
let cwhite: str = readfile(strings.concat(route,
"/route.test.sepwork/route-internal-test.s"));
let cexternal: str = readfile(strings.concat(route,
"/route.test.sepwork/route_test-external-test.s"));
let cmain: str = readfile(strings.concat(route,
"/route.test.sepwork/route-test-main.s"));
let cbinary: str = readfile(strings.concat(route, "/route.test"));
// The explicit package `-c` outputs are caller-owned artifacts. Release
// the shared C-stage tree before asking the WW driver to acquire the same
// stem; the driver never deletes a pre-existing `.sepwork` path.
clean(strings.concat(route, "/route.test.sepwork"));
assert(has(outc.stdout, "route.white ... ok\n"));
assert(has(outc.stdout, "route.external ... ok\n"));
let cwhite: str = readfile(strings.concat(cwork,
"/route-internal-test.s"));
let cexternal: str = readfile(strings.concat(cwork,
"/route_test-external-test.s"));
let cmain: str = readfile(strings.concat(cwork,
"/route-test-main.s"));
let cbinary: str = readfile(cbinarypath);
let wc: []str = [driver("ww_ww"), "test", "-c", "-I", root, route];
let wc: []str = [driver("ww_ww"), "test", "-w", wwork, "-o",
wbinarypath, "-I", root, route];
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(route,
"/route.test.sepwork/route-internal-test.s"))));
assert(same(cexternal, readfile(strings.concat(route,
"/route.test.sepwork/route_test-external-test.s"))));
assert(same(cmain, readfile(strings.concat(route,
"/route.test.sepwork/route-test-main.s"))));
assert(same(cbinary, readfile(strings.concat(route, "/route.test"))));
assert(same(cwhite, readfile(strings.concat(wwork,
"/route-internal-test.s"))));
assert(same(cexternal, readfile(strings.concat(wwork,
"/route_test-external-test.s"))));
assert(same(cmain, readfile(strings.concat(wwork,
"/route-test-main.s"))));
assert(same(cbinary, readfile(wbinarypath)));
clean(root);
};
@@ -2464,7 +2479,7 @@ fn cwdwritedata(dir: str, label: str) void = {
let av: []str = [driver(stages[si]), "test", "-c", "-w", works[si],
"-I", root, "--ww-package-test", "test", "pkg", "pkg", "pkg",
"pkg_test", pkg, bins[si], statuses[si], pkg];
"pkg_test", pkg, bins[si], "-", statuses[si], pkg];
runcommandenv(root, strings.concat("graph-cold-", stages[si]), av,
env, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -2728,7 +2743,7 @@ fn cwdwritedata(dir: str, label: str) void = {
driver(linkers[si])));
let av: []str = [driver(stages[si]), "test", "-c", "-w", works[si],
"-I", root, "--ww-package-test", "test", "pkg", "pkg", "pkg",
"pkg_test", pkg, bins[si], statuses[si], pkg];
"pkg_test", pkg, bins[si], "-", statuses[si], pkg];
runcommandenv(root, strings.concat("graph-body-", stages[si]), av,
tracedenv, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -2807,7 +2822,7 @@ fn cwdwritedata(dir: str, label: str) void = {
driver(linkers[si])));
let av: []str = [driver(stages[si]), "test", "-c", "-w", works[si],
"-I", root, "--ww-package-test", "test", "pkg", "pkg", "pkg",
"pkg_test", pkg, bins[si], statuses[si], pkg];
"pkg_test", pkg, bins[si], "-", statuses[si], pkg];
runcommandenv(root, strings.concat("graph-external-", stages[si]), av,
tracedenv, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -2878,7 +2893,7 @@ fn cwdwritedata(dir: str, label: str) void = {
driver(linkers[si])));
let av: []str = [driver(stages[si]), "test", "-c", "-w", works[si],
"-I", root, "--ww-package-test", "test", "pkg", "pkg", "pkg",
"pkg_test", pkg, bins[si], statuses[si], pkg];
"pkg_test", pkg, bins[si], "-", statuses[si], pkg];
runcommandenv(root, strings.concat("graph-export-", stages[si]), av,
tracedenv, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -2981,7 +2996,7 @@ fn cwdwritedata(dir: str, label: str) void = {
driver(linkers[si])));
let av: []str = [driver(stages[si]), "test", "-c", "-w", works[si],
"-I", root, "--ww-package-test", "test", "pkg", "pkg", "pkg",
"-", pkg, bins[si], statuses[si], pkg];
"-", pkg, bins[si], "-", statuses[si], pkg];
runcommandenv(root, strings.concat("graph-remove-external-", stages[si]),
av, env, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -3106,7 +3121,7 @@ fn cwdwritedata(dir: str, label: str) void = {
driver(linkers[si])));
let av: []str = [driver(stages[si]), "test", "-c", "-w", works[si],
"-I", root, "--ww-package-test", "test", "pkg", "pkg", "pkg",
"pkg_test", pkg, bins[si], statuses[si], pkg];
"pkg_test", pkg, bins[si], "-", statuses[si], pkg];
runcommandenv(root, strings.concat("graph-readd-external-", stages[si]),
av, env, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -3191,7 +3206,7 @@ fn cwdwritedata(dir: str, label: str) void = {
runcommand(root, strings.concat("graph-direct-product-", stages[si]),
directav, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(occurrences(out.stdout, "built ") == 1);
assert(out.stdout.len == 0);
assert(os.exists(directbin));
if (si == 0) {
directbytes = readfile(directbin);
@@ -3376,19 +3391,19 @@ fn cwdwritedata(dir: str, label: str) void = {
let forward: []str = [driver(stages[si]), "test", "-c", "-w",
works[si], "-I", suite, "-I", root,
"--ww-package-test", "test", "alpha", "alpha", "alpha",
"alpha_test", alpha, bins[0], statuses[0],
"alpha_test", alpha, bins[0], "-", statuses[0],
"--ww-package-test", "test", "beta", "beta", "beta",
"beta_test", beta, bins[1], statuses[1],
"beta_test", beta, bins[1], "-", statuses[1],
"--ww-package-test", "test", "gamma", "gamma", "-", "-",
gamma, gammabin, statuses[2], alpha];
gamma, gammabin, "-", statuses[2], alpha];
let reverse: []str = [driver(stages[si]), "test", "-c", "-w",
works[si], "-I", suite, "-I", root,
"--ww-package-test", "test", "gamma", "gamma", "-", "-",
gamma, gammabin, statuses[2],
gamma, gammabin, "-", statuses[2],
"--ww-package-test", "test", "beta", "beta", "beta",
"beta_test", beta, bins[1], statuses[1],
"beta_test", beta, bins[1], "-", statuses[1],
"--ww-package-test", "test", "alpha", "alpha", "alpha",
"alpha_test", alpha, bins[0], statuses[0], alpha];
"alpha_test", alpha, bins[0], "-", statuses[0], alpha];
if (si == 0) {
runcommandenv(root, "multi-forward-c", forward, env,
(180i64 * (time.second: i64)): time.duration, &out);
@@ -3531,14 +3546,11 @@ fn cwdwritedata(dir: str, label: str) void = {
si += 1;
};
// Public root order is presentation-only: two directories publish one
// binary each, while the selected no-test directory publishes no binary.
let publicalpha: str = strings.concat(alpha, "/alpha.test");
let publicbeta: str = strings.concat(beta, "/beta.test");
let publicgamma: str = strings.concat(gamma, "/gamma.test");
let publicworks: []str = [strings.concat(publicalpha, ".sepwork"),
strings.concat(publicbeta, ".sepwork"),
strings.concat(publicgamma, ".sepwork")];
// Public root order is presentation-only. Default -c destinations are in
// the invocation cwd, and the selected no-test package publishes nothing.
let publicalpha: str = strings.concat(root, "/alpha.test");
let publicbeta: str = strings.concat(root, "/beta.test");
let publicgamma: str = strings.concat(root, "/gamma.test");
let publicout: str = "";
let publicerr: str = "";
let publicalphabytes: str = "";
@@ -3562,11 +3574,11 @@ fn cwdwritedata(dir: str, label: str) void = {
append(publicav, gamma); append(publicav, beta);
append(publicav, alpha);
};
runcommand(root, strings.concat("multi-public-order-",
publiclabels[pi]), publicav,
runcommanddir(root, strings.concat("multi-public-order-",
publiclabels[pi]), root, publicav,
(180i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(occurrences(out.stdout, "built ") == 2);
assert(occurrences(out.stdout, "built ") == 0);
assert(has(out.stdout, strings.concat(
"? ", gamma, " [no tests]\n")));
assert(os.exists(publicalpha) && os.exists(publicbeta));
@@ -3584,8 +3596,6 @@ fn cwdwritedata(dir: str, label: str) void = {
assert(same(publicalphabytes, readfile(publicalpha)));
assert(same(publicbetabytes, readfile(publicbeta)));
};
let wi: i32 = 0;
for (wi < publicworks.len) { clean(publicworks[wi]); wi += 1; };
clean(publicalpha); clean(publicbeta); clean(publicgamma);
pi += 1;
};
@@ -3756,6 +3766,8 @@ fn cwdwritedata(dir: str, label: str) void = {
append(linkenv, strings.concat("WW_MIXED_W6L=", driver("w6l")));
let bins: []str = [strings.concat(named, "/test.test"),
strings.concat(consumer, "/zconsumer.test")];
let statuses: []str = [strings.concat(root, "/mixed-test.status"),
strings.concat(root, "/mixed-zconsumer.status")];
let keys: []str = ["test-internal-test", "test_test-external-test",
"test-test-main", "zconsumer-internal-test",
"zconsumer_test-external-test", "zconsumer-test-main"];
@@ -3766,8 +3778,14 @@ fn cwdwritedata(dir: str, label: str) void = {
let out: commandout;
let si: i32 = 0;
for (si < stages.len) {
let av: []str = [driver(stages[si]), "test", "-c", "-j", "1",
"-I", suite, strings.concat(suite, "/...")];
assert(os.mkdir(workroot, 448i32) == 0);
let av: []str = [driver(stages[si]), "test", "-c", "-w", workroot,
"-I", suite,
"--ww-package-test", "test", "test", "test", "test",
"test_test", named, bins[0], "-", statuses[0],
"--ww-package-test", "test", "zconsumer", "zconsumer",
"zconsumer", "zconsumer_test", consumer, bins[1], "-",
statuses[1], named];
if (si == 0) {
runcommandenv(root, "mixed-actions-c", av, linkenv,
(120i64 * (time.second: i64)): time.duration, &out);
@@ -3776,7 +3794,7 @@ fn cwdwritedata(dir: str, label: str) void = {
(120i64 * (time.second: i64)): time.duration, &out);
};
expectexit(&out, 0);
assert(occurrences(out.stdout, "built ") == 2);
assert(out.stdout.len == 0 && out.stderr.len == 0);
let namedprod: str = readfile(strings.concat(work,
"test-internal-test.unit.ww"));
let support: str = readfile(strings.concat(work, "__wwtest.unit.ww"));
@@ -4441,7 +4459,7 @@ fn cwdwritedata(dir: str, label: str) void = {
append(env, strings.concat("WW_UNIVERSE_BUILDER_TRACE=",
buildertraces[si]));
let av: []str = alloc([], (8 + productcount * 9): u64)!;
let av: []str = alloc([], (8 + productcount * 10): u64)!;
append(av, driver(stages[si]));
append(av, "test"); append(av, "-c");
append(av, "-w"); append(av, works[si]);
@@ -4461,6 +4479,7 @@ fn cwdwritedata(dir: str, label: str) void = {
};
append(av, dir);
append(av, strings.concat(root, "/product-", name, ".test"));
append(av, "-");
append(av, strings.concat(root, "/product-", name, ".status"));
i += 1;
};
@@ -4479,12 +4498,13 @@ fn cwdwritedata(dir: str, label: str) void = {
};
append(av, dir);
append(av, strings.concat(root, "/product-", name, ".test"));
append(av, "-");
append(av, strings.concat(root, "/product-", name, ".status"));
i -= 1;
};
};
append(av, strings.concat(suite, "/p000"));
assert(av.len == 8 + productcount * 9);
assert(av.len == 8 + productcount * 10);
runcommandenv(root, strings.concat("dynamic-universe-", stages[si]), av,
env, (1200i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -5038,7 +5058,7 @@ fn cwdwritedata(dir: str, label: str) void = {
let seedav: []str = [driver(stages[i]), "test", "-c",
"-w", lateworks[i], "-I", root, "--ww-package-test", "test",
"late", "late", "late", "late_test", late, latebins[i],
latestatuses[i], late];
"-", latestatuses[i], late];
runcommandenv(root, strings.concat("late-seed-", tags[i]), seedav,
seedenv, (180i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -5164,7 +5184,7 @@ fn cwdwritedata(dir: str, label: str) void = {
let failav: []str = [driver(stages[i]), "test", "-c",
"-w", lateworks[i], "-I", root, "--ww-package-test", "test",
"late", "late", "late", "late_test", late, attemptbin,
attemptstatus, late];
"-", attemptstatus, late];
runcommandenv(root, strings.concat("late-failure-",
phaselabels[phasei], "-", tags[i], "-", retrylabel), failav,
env, (180i64 * (time.second: i64)): time.duration, &out);
@@ -5276,8 +5296,8 @@ fn cwdwritedata(dir: str, label: str) void = {
let out: commandout;
let i: i32 = 0;
for (i < stages.len) {
let av: []str = [driver(stages[i]), "test", "-c", "-I", root,
"-o", bin, pkg];
let av: []str = [driver(stages[i]), "test", "-w", workroot,
"-I", root, "-o", bin, pkg];
runcommand(root, strings.concat("named-test-build-", stages[i]), av,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -5914,18 +5934,22 @@ fn cwdwritedata(dir: str, label: str) void = {
orderwork, "-I", source,
"--ww-package-test", "test", "main", "main", "-", "-", client,
strings.concat(root, "/order-client-", stages[si]),
"-",
strings.concat(root, "/order-client-", stages[si], ".status"),
"--ww-package-test", "test", "main", "main", "-", "-", outsider,
strings.concat(root, "/order-outsider-", stages[si]),
"-",
strings.concat(root, "/order-outsider-", stages[si], ".status"),
client];
let orderreverse: []str = [driver(stages[si]), "test", "-c", "-w",
orderwork, "-I", source,
"--ww-package-test", "test", "main", "main", "-", "-", outsider,
strings.concat(root, "/order-outsider-", stages[si]),
"-",
strings.concat(root, "/order-outsider-", stages[si], ".status"),
"--ww-package-test", "test", "main", "main", "-", "-", client,
strings.concat(root, "/order-client-", stages[si]),
"-",
strings.concat(root, "/order-client-", stages[si], ".status"),
client];
let orderrequests: [][]str = [orderforward, orderreverse];
@@ -6352,10 +6376,10 @@ fn cwdwritedata(dir: str, label: str) void = {
source, "--ww-package-build",
"--ww-package-test", "build", "paritybase", "paritybase",
"-", "-", base,
combinedbase, combinedbasestatus,
combinedbase, "-", combinedbasestatus,
"--ww-package-test", "build", "parityleft", "parityleft",
"-", "-", left,
combinedleft, combinedleftstatus, left];
combinedleft, "-", combinedleftstatus, left];
runcommandenv(root, strings.concat("long-combined-", tags[si]),
combinedav, env, (120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
@@ -9113,13 +9137,17 @@ fn cwdwritedata(dir: str, label: str) void = {
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);
runcommand(root, "tree-o-c", oc,
(30i64 * (time.second: i64)): time.duration, &outc);
runcommand(root, "tree-o-ww", ow,
(30i64 * (time.second: i64)): time.duration, &outw);
expectexit(&outc, 1);
expectexit(&outw, 1);
assert(outc.stdout.len == 0 && outw.stdout.len == 0);
assert(same(outc.stderr, outw.stderr));
assert(has(outc.stderr,
"ww test: -o needs -c for a package target\n"));
"with multiple packages, -o must refer to a directory or /dev/null"));
assert(!os.exists(strings.concat(root, "/stem")));
// -w on a package target forwards to the coordinator: one shared
// persistent driver workdir for the complete selected request,
@@ -9691,9 +9719,11 @@ fn cwdwritedata(dir: str, label: str) void = {
"--ww-package-build",
"--ww-package-test", "build", "foo", "foo", "-", "-",
localleft, leftout,
"-",
strings.concat(root, "/local-", stages[si], "-left.status"),
"--ww-package-test", "build", "foo", "foo", "-", "-",
localright, rightout,
"-",
strings.concat(root, "/local-", stages[si], "-right.status"),
localleft];
runcommand(root, strings.concat("local-command-union-", stages[si]),
@@ -10440,15 +10470,15 @@ fn runtimepath(relative: str) str = {
let foldforward: []str = [driver(stages[si]), "test", "-c", "-w",
foldmultiwork, "-I", source, "--ww-package-build",
"--ww-package-test", "build", "main", "main", "-", "-", client,
foldallowedout, foldallowedstatus,
foldallowedout, "-", foldallowedstatus,
"--ww-package-test", "build", "main", "main", "-", "-",
foldvendorclient, foldcollisionout, foldcollisionstatus, client];
foldvendorclient, foldcollisionout, "-", foldcollisionstatus, client];
let foldreverse: []str = [driver(stages[si]), "test", "-c", "-w",
foldmultiwork, "-I", source, "--ww-package-build",
"--ww-package-test", "build", "main", "main", "-", "-",
foldvendorclient, foldcollisionout, foldcollisionstatus,
foldvendorclient, foldcollisionout, "-", foldcollisionstatus,
"--ww-package-test", "build", "main", "main", "-", "-", client,
foldallowedout, foldallowedstatus, client];
foldallowedout, "-", foldallowedstatus, client];
let foldrequests: [][]str = [foldforward, foldreverse];
let foldmultidiags: []str = ["", ""];
let foldorderlabels: []str = ["forward", "reverse"];
@@ -10793,7 +10823,7 @@ fn runtimepath(relative: str) str = {
strings.concat(combinedoutputs[5], ".status"),
strings.concat(combinedoutputs[6], ".status")];
let combinedav: []str = alloc([],
(9 + combinedtargets.len * 9): u64)!;
(9 + combinedtargets.len * 10): u64)!;
append(combinedav, driver(stages[si]));
append(combinedav, "test"); append(combinedav, "-c");
append(combinedav, "-w"); append(combinedav, combinedwork);
@@ -10809,6 +10839,7 @@ fn runtimepath(relative: str) str = {
append(combinedav, "-");
append(combinedav, combinedtargets[ui]);
append(combinedav, combinedoutputs[ui]);
append(combinedav, "-");
append(combinedav, combinedstatuses[ui]);
ui += 1;
};
@@ -10882,15 +10913,15 @@ fn runtimepath(relative: str) str = {
let orderforward: []str = [driver(stages[si]), "test", "-c", "-w",
orderwork, "-I", source, "--ww-package-build",
"--ww-package-test", "build", "main", "main", "-", "-", client,
orderallowed, orderallowedstatus,
orderallowed, "-", orderallowedstatus,
"--ww-package-test", "build", "main", "main", "-", "-", outsider,
orderforbidden, orderforbiddenstatus, client];
orderforbidden, "-", orderforbiddenstatus, client];
let orderreverse: []str = [driver(stages[si]), "test", "-c", "-w",
orderwork, "-I", source, "--ww-package-build",
"--ww-package-test", "build", "main", "main", "-", "-", outsider,
orderforbidden, orderforbiddenstatus,
orderforbidden, "-", orderforbiddenstatus,
"--ww-package-test", "build", "main", "main", "-", "-", client,
orderallowed, orderallowedstatus, client];
orderallowed, "-", orderallowedstatus, client];
let orderrequests: [][]str = [orderforward, orderreverse];
let orderdiags: []str = ["", ""];
let oi: i32 = 0;
@@ -12162,23 +12193,32 @@ fn runtimepath(relative: str) str = {
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"));
"package family;\nexport fn v() i32 = { return 7; };\n");
writefile(strings.concat(pdir, "/same_test.ww"), strings.concat(
"package family;\nimport os;\n",
"@test fn seven() void = { let av: []str = os.args();",
" if (av.len != 0) { os.write(os.STDOUT_FILENO, av[0].ptr,",
" av[0].len: u64); os.write(os.STDOUT_FILENO, \"\\n\".ptr, 1u64); };",
" assert(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.
writefile(strings.concat(adir, "/a.ww"),
"package other;\nexport fn v() i32 = { return 1; };\n");
writefile(strings.concat(adir, "/a_test.ww"),
"package other;\n@test fn one() void = { assert(v() == 1); };\n");
let none: str = strings.concat(root, "/znone");
assert(os.mkdir(none, 493i32) == 0);
writefile(strings.concat(none, "/none.ww"),
"package renamed;\nexport fn v() i32 = { return 9; };\n");
// '_' roots are excluded from recursive 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 namedbytes: str = "";
let defaultbytes: str = "";
let fanabytes: str = "";
let fanpkgbytes: str = "";
let i: i32 = 0;
for (i < 2) {
let named: str = strings.concat(outdir, "/out_", drvs[i],
@@ -12193,31 +12233,379 @@ fn runtimepath(relative: str) str = {
case void => void;
case let e: os.oserror => abort("-c -o artifact missing");
};
assert(((fi.mode: u32) & 73u32) != 0u32);
assert(!has(out.stdout, "seven ... "));
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;
};
if (i == 0) { namedbytes = readfile(named); }
else { assert(same(namedbytes, readfile(named))); };
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"));
assert(has(out.stdout, "seven ... "));
let runnamed: str = strings.concat(outdir, "/run_", drvs[i], ".bin");
let nocav: []str = [driver(drvs[i]), "test", "-I", root,
"-o", named, pdir];
"-o", runnamed, 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"));
expectexit(&out, 0);
assert(out.stderr.len == 0 && os.exists(runnamed));
assert(has(out.stdout, "seven ... "));
assert(has(out.stdout, "/package.test\n"));
assert(!has(out.stdout, runnamed));
let defaultbin: str = strings.concat(root, "/pkg.test");
let defaultav: []str = [driver(drvs[i]), "test", "-c", "-I", root,
pdir];
runcommanddir(root, strings.concat("default_", drvs[i]), root,
defaultav,
(30i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(os.exists(defaultbin));
assert(!os.exists(strings.concat(root, "/family.test")));
assert(!os.exists(strings.concat(pdir, "/family.test")));
if (i == 0) { defaultbytes = readfile(defaultbin); }
else { assert(same(defaultbytes, readfile(defaultbin))); };
clean(defaultbin);
let fanroot: str = strings.concat(root, "/_fan_", drvs[i]);
let fanarg: str = strings.concat(fanroot, "/nested/");
let fanav: []str = [driver(drvs[i]), "test", "-c", "-j", "2",
"-I", root, "-o", fanarg, strings.concat(root, "/...")];
runcommand(root, strings.concat("fan_", drvs[i]), fanav,
(60i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
let fanabin: str = strings.concat(fanarg, "a.test");
let fanpkg: str = strings.concat(fanarg, "pkg.test");
assert(os.exists(fanabin) && os.exists(fanpkg));
assert(!os.exists(strings.concat(fanarg, "znone.test")));
assert(has(out.stdout, strings.concat("? ", none, " [no tests]\n")));
if (i == 0) {
fanabytes = readfile(fanabin);
fanpkgbytes = readfile(fanpkg);
} else {
assert(same(fanabytes, readfile(fanabin)));
assert(same(fanpkgbytes, readfile(fanpkg)));
};
let badout: str = strings.concat(outdir, "/multi-file-", drvs[i]);
let mulav: []str = [driver(drvs[i]), "test", "-c", "-o",
named, strings.concat(root, "/...")];
badout, strings.concat(root, "/...")];
runcommand(root, strings.concat("multi_", drvs[i]), mulav,
(30i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 2);
expectexit(&out, 1);
assert(has(out.stderr,
"cannot use -o with multiple packages"));
"with multiple packages, -o must refer to a directory or /dev/null"));
assert(!os.exists(badout));
let nullcompile: []str = [driver(drvs[i]), "test", "-c", "-I",
root, "-o", "/dev/null", pdir];
runcommand(root, strings.concat("null-compile_", drvs[i]), nullcompile,
(30i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(!has(out.stdout, "seven ... "));
assert(!os.exists("/dev/null.new"));
let nullrun: []str = [driver(drvs[i]), "test", "-I", root,
"-o", "/dev/null", pdir];
runcommand(root, strings.concat("null-run_", drvs[i]), nullrun,
(30i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(has(out.stdout, "seven ... "));
i += 1;
};
clean(root);
};
@test fn test_binary_publication_transaction() void = {
let root: str = fresh();
let suite: str = strings.concat(root, "/suite");
let leftsame: str = strings.concat(suite, "/left/same");
let rightsame: str = strings.concat(suite, "/right/same");
let alpha: str = strings.concat(suite, "/alpha");
let beta: str = strings.concat(suite, "/beta");
let failed: str = strings.concat(suite, "/failed");
let none: str = strings.concat(suite, "/none");
let persist: str = strings.concat(suite, "/persist");
mkdirall(leftsame); mkdirall(rightsame); mkdirall(alpha);
mkdirall(beta); mkdirall(failed); mkdirall(none); mkdirall(persist);
writefile(strings.concat(leftsame, "/same.ww"),
"package declared_left;\nfn value() i32 = { return 1; };\n");
writefile(strings.concat(leftsame, "/same_test.ww"), strings.concat(
"package declared_left;\n",
"@test fn left() void = { assert(value() == 1); };\n"));
writefile(strings.concat(rightsame, "/same.ww"),
"package declared_right;\nfn value() i32 = { return 2; };\n");
writefile(strings.concat(rightsame, "/same_test.ww"), strings.concat(
"package declared_right;\n",
"@test fn right() void = { assert(value() == 2); };\n"));
writefile(strings.concat(alpha, "/alpha.ww"),
"package alpha_decl;\nfn value() i32 = { return 3; };\n");
writefile(strings.concat(alpha, "/alpha_test.ww"), strings.concat(
"package alpha_decl;\n",
"@test fn alpha_ok() void = { assert(value() == 3); };\n"));
writefile(strings.concat(beta, "/beta.ww"),
"package beta_decl;\nfn value() i32 = { return 4; };\n");
writefile(strings.concat(beta, "/beta_test.ww"), strings.concat(
"package beta_decl;\n",
"@test fn beta_ok() void = { assert(value() == 4); };\n"));
writefile(strings.concat(failed, "/failed.ww"),
"package failed_decl;\nfn value() i32 = { return 5; };\n");
writefile(strings.concat(failed, "/failed_test.ww"), strings.concat(
"package failed_decl;\n",
"@test fn runtime_failure() void = { assert(false); };\n"));
writefile(strings.concat(none, "/none.ww"),
"package none_decl;\nfn value() i32 = { return 6; };\n");
let persisttest: str = strings.concat(persist, "/persist_test.ww");
let persistbase: str = strings.concat(
"package persist_decl;\n",
"@test fn persistent_base() void = { assert(true); };\n");
let persistchanged: str = strings.concat(
"package persist_decl;\n",
"@test fn persistent_changed() void = { assert(1 + 1 == 2); };\n");
writefile(strings.concat(persist, "/persist.ww"),
"package persist_decl;\nfn value() i32 = { return 7; };\n");
writefile(persisttest, persistbase);
let compilerwrapper: str = strings.concat(root, "/publish-w6c.sh");
let linkerwrapper: str = strings.concat(root, "/publish-w6l.sh");
writeexecutable(compilerwrapper, strings.concat(
"#!/bin/sh\nprintf '%s\\n' \"$*\" >> \"$WW_PUBLISH_CTRACE\"\n",
"exec \"$WW_PUBLISH_REAL_C\" \"$@\"\n"));
writeexecutable(linkerwrapper, strings.concat(
"#!/bin/sh\nprintf '%s\\n' \"$*\" >> \"$WW_PUBLISH_LTRACE\"\n",
"if test -n \"$WW_PUBLISH_FAIL\"; then\n",
" for arg do case \"$arg\" in *\"$WW_PUBLISH_FAIL\"*)\n",
" printf 'injected publication linker failure\\n' >&2\n",
" exit 97;; esac; done\nfi\n",
"exec \"$WW_PUBLISH_REAL_L\" \"$@\"\n"));
let stages: []str = ["ww", "ww_ww"];
let compilers: []str = ["w6c", "w6c_ww"];
let linkers: []str = ["w6l", "w6l_ww"];
let tags: []str = ["c", "ww"];
let duplicatediag: str = "";
let rollbackdiag: str = "";
let missingdiag: str = "";
let occupieddiag: str = "";
let failurebytes: str = "";
let persistbasebytes: str = "";
let persistchangedbytes: str = "";
let baseenv: []str = os.getenvs();
let out: commandout;
let si: i32 = 0;
for (si < stages.len) {
let ctrace: str = strings.concat(root, "/publish-", tags[si],
"-w6c.trace");
let ltrace: str = strings.concat(root, "/publish-", tags[si],
"-w6l.trace");
writefile(ctrace, ""); writefile(ltrace, "");
let env: []str = alloc([], (baseenv.len + 7): u64)!;
let ei: i32 = 0;
for (ei < baseenv.len) {
if (!strings.hasprefix(baseenv[ei], "WW_W6C=")
&& !strings.hasprefix(baseenv[ei], "WW_W6L=")
&& !strings.hasprefix(baseenv[ei], "WW_PUBLISH_CTRACE=")
&& !strings.hasprefix(baseenv[ei], "WW_PUBLISH_LTRACE=")
&& !strings.hasprefix(baseenv[ei], "WW_PUBLISH_REAL_C=")
&& !strings.hasprefix(baseenv[ei], "WW_PUBLISH_REAL_L=")
&& !strings.hasprefix(baseenv[ei], "WW_PUBLISH_FAIL=")) {
append(env, baseenv[ei]);
};
ei += 1;
};
append(env, strings.concat("WW_W6C=", compilerwrapper));
append(env, strings.concat("WW_W6L=", linkerwrapper));
append(env, strings.concat("WW_PUBLISH_CTRACE=", ctrace));
append(env, strings.concat("WW_PUBLISH_LTRACE=", ltrace));
append(env, strings.concat("WW_PUBLISH_REAL_C=",
driver(compilers[si])));
append(env, strings.concat("WW_PUBLISH_REAL_L=",
driver(linkers[si])));
append(env, "WW_PUBLISH_FAIL=");
// Equal import leaves are rejected before tools or output creation,
// independent of their unequal declared package names.
let duplicateout: str = strings.concat(root, "/duplicate-output/");
let duplicateav: []str = [driver(stages[si]), "test", "-c",
"-j", "2", "-I", suite, "-o", duplicateout,
leftsame, rightsame];
runcommandenvdir(root, strings.concat("publish-duplicate-", tags[si]),
duplicateav, env, root,
(60i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 1);
assert(out.stdout.len == 0);
assert(has(out.stderr,
"ww test: cannot write test binary same.test for multiple packages:\n"));
assert(has(out.stderr, strings.concat(leftsame, "\n")));
assert(has(out.stderr, strings.concat(rightsame, "\n")));
assert(readfile(ctrace).len == 0 && readfile(ltrace).len == 0);
assert(!os.exists(duplicateout));
if (si == 0) { duplicatediag = strings.dup(out.stderr); }
else { assert(same(duplicatediag, out.stderr)); };
// /dev/null is Go's exact multi-package discard exception: both
// products build, neither publishes, and duplicate names are harmless.
let nullav: []str = [driver(stages[si]), "test", "-c", "-j", "2",
"-I", suite, "-o", "/dev/null", leftsame, rightsame];
runcommandenvdir(root, strings.concat("publish-null-", tags[si]),
nullav, env, root,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(out.stdout.len == 0 && out.stderr.len == 0);
assert(readfile(ctrace).len != 0);
assert(occurrences(readfile(ltrace), "\n") == 2);
assert(!os.exists("/dev/null.new"));
// An occupied retained-binary stage is a pre-tool rejection. The
// caller's old destination and occupied stage both remain untouched.
let occupied: str = strings.concat(root, "/occupied");
if (si == 0) {
assert(os.mkdir(occupied, 448i32) == 0);
writefile(strings.concat(occupied, "/alpha.test"), "old-alpha\n");
writefile(strings.concat(occupied, "/alpha.test.new"),
"occupied-stage\n");
};
rewritefile(ctrace, ""); rewritefile(ltrace, "");
let occupiedav: []str = [driver(stages[si]), "test", "-c", "-I",
suite, "-o", strings.concat(occupied, "/"), alpha];
runcommandenvdir(root, strings.concat("publish-occupied-", tags[si]),
occupiedav, env, root,
(60i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 1);
assert(has(out.stderr, strings.concat(
"ww: product staging path already exists: ", occupied,
"/alpha.test.new\n")));
assert(same(readfile(strings.concat(occupied, "/alpha.test")),
"old-alpha\n"));
assert(same(readfile(strings.concat(occupied, "/alpha.test.new")),
"occupied-stage\n"));
assert(readfile(ctrace).len == 0 && readfile(ltrace).len == 0);
if (si == 0) { occupieddiag = strings.dup(out.stderr); }
else { assert(same(occupieddiag, out.stderr)); };
// Link failure after an earlier sibling has staged a retained copy
// rejects the whole request and preserves every old destination.
let rollback: str = strings.concat(root, "/rollback-", tags[si]);
assert(os.mkdir(rollback, 448i32) == 0);
writefile(strings.concat(rollback, "/alpha.test"), "alpha-sentinel\n");
writefile(strings.concat(rollback, "/beta.test"), "beta-sentinel\n");
rewritefile(ctrace, ""); rewritefile(ltrace, "");
env[env.len - 1] = "WW_PUBLISH_FAIL=beta-test-main";
let rollbackav: []str = [driver(stages[si]), "test", "-c", "-j",
"1", "-I", suite, "-o", strings.concat(rollback, "/"),
alpha, beta];
runcommandenvdir(root, strings.concat("publish-rollback-", tags[si]),
rollbackav, env, root,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 1);
assert(has(out.stderr, "injected publication linker failure\n"));
assert(has(out.stderr, "ww: w6l failed\n"));
assert(same(readfile(strings.concat(rollback, "/alpha.test")),
"alpha-sentinel\n"));
assert(same(readfile(strings.concat(rollback, "/beta.test")),
"beta-sentinel\n"));
assert(!directoryhasnew(rollback));
assert(occurrences(readfile(ltrace), "\n") == 2);
if (si == 0) { rollbackdiag = strings.dup(out.stderr); }
else { assert(same(rollbackdiag, out.stderr)); };
// Output directories minted for a rejected request are rolled back.
let missingroot: str = strings.concat(root, "/missing-", tags[si]);
let missingout: str = strings.concat(missingroot, "/nested/");
rewritefile(ctrace, ""); rewritefile(ltrace, "");
env[env.len - 1] = "WW_PUBLISH_FAIL=alpha-test-main";
let missingav: []str = [driver(stages[si]), "test", "-c", "-j",
"1", "-I", suite, "-o", missingout, alpha];
runcommandenvdir(root, strings.concat("publish-missing-", tags[si]),
missingav, env, root,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 1);
assert(!os.exists(missingroot));
assert(occurrences(readfile(ltrace), "\n") == 1);
if (si == 0) { missingdiag = strings.dup(out.stderr); }
else { assert(same(missingdiag, out.stderr)); };
// A package with no tests never claims a binary or creates a requested
// output hierarchy, although its production package is still checked.
let noneroot: str = strings.concat(root, "/none-output-", tags[si]);
let noneav: []str = [driver(stages[si]), "test", "-c", "-I", suite,
"-o", strings.concat(noneroot, "/nested/"), none];
env[env.len - 1] = "WW_PUBLISH_FAIL=";
runcommandenvdir(root, strings.concat("publish-none-", tags[si]),
noneav, env, root,
(60i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(has(out.stdout, strings.concat("? ", none,
" [no tests]\n")));
assert(out.stderr.len == 0 && !os.exists(noneroot));
// Publication commits before execution. A failing test therefore leaves
// a runnable retained binary while its product failure stays on stdout.
let failurebin: str = strings.concat(root, "/failure-", tags[si],
".test");
let failureav: []str = [driver(stages[si]), "test", "-I", suite,
"-o", failurebin, failed];
runcommandenvdir(root, strings.concat("publish-runtime-", tags[si]),
failureav, env, root,
(60i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 1);
assert(os.exists(failurebin) && !os.exists(strings.concat(failurebin,
".new")));
assert(has(out.stdout,
"failed_decl.runtime_failure ... FAIL (exit 1)\n"));
assert(out.stderr.len == 0);
let fi: os.filestat;
match (os.stat(&fi, failurebin)) {
case void => void;
case let e: os.oserror => abort("retained failure binary missing");
};
assert(((fi.mode: u32) & 73u32) != 0u32);
if (si == 0) { failurebytes = readfile(failurebin); }
else { assert(same(failurebytes, readfile(failurebin))); };
// -w keeps semantic actions persistent while -o remains a presentation
// copy. Unchanged input reuses actions; changed input replaces the copy.
rewritefile(persisttest, persistbase);
let persistwork: str = strings.concat(root, "/persist-work-", tags[si]);
let persistbin: str = strings.concat(root, "/persist.test");
if (os.exists(persistbin)) { clean(persistbin); };
rewritefile(ctrace, ""); rewritefile(ltrace, "");
let persistav: []str = [driver(stages[si]), "test", "-w",
persistwork, "-I", suite, "-o", persistbin, persist];
runcommandenvdir(root, strings.concat("publish-persist-cold-", tags[si]),
persistav, env, root,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(has(out.stdout, "persistent_base ... ok\n"));
let basebytes: str = readfile(persistbin);
if (si == 0) { persistbasebytes = strings.dup(basebytes); }
else { assert(same(persistbasebytes, basebytes)); };
rewritefile(ctrace, ""); rewritefile(ltrace, "");
runcommandenvdir(root, strings.concat("publish-persist-warm-", tags[si]),
persistav, env, root,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(readfile(ctrace).len == 0);
assert(same(basebytes, readfile(persistbin)));
rewritefile(persisttest, persistchanged);
rewritefile(ctrace, ""); rewritefile(ltrace, "");
runcommandenvdir(root, strings.concat("publish-persist-change-", tags[si]),
persistav, env, root,
(120i64 * (time.second: i64)): time.duration, &out);
expectexit(&out, 0);
assert(has(out.stdout, "persistent_changed ... ok\n"));
assert(readfile(ctrace).len != 0);
let changedbytes: str = readfile(persistbin);
assert(!same(basebytes, changedbytes));
if (si == 0) { persistchangedbytes = strings.dup(changedbytes); }
else { assert(same(persistchangedbytes, changedbytes)); };
assert(!directoryhasnew(persistwork));
si += 1;
};
assert(os.remove(strings.concat(root,
"/occupied/alpha.test.new")) == 0);
clean(root);
};

11
test/sep/importdir_test.ww
View File

@@ -197,18 +197,21 @@ fn samefile(a: str, b: str, why: str) void = {
"@test fn directory_import() void = { assert(foo.value() == 42); };\n"));
let testbins: []str = [strings.concat(td, "/test-c"),
strings.concat(td, "/test-w")];
let testworks: []str = [strings.concat(td, "/test-work-c"),
strings.concat(td, "/test-work-w")];
i = 0;
for (i < 2) {
let tav: []str = [testenv.driver(drivers[i * 2]), "test", "-c",
"-I", early, "-I", late, "-o", testbins[i], checks];
let tav: []str = [testenv.driver(drivers[i * 2]), "test", "-w",
testworks[i], "-I", early, "-I", late, "-o", testbins[i],
checks];
expectcode(td, strings.concat("test_build_", tags[i * 2]), tav, 0);
let trav: []str = [testbins[i]];
expectcode(td, strings.concat("test_run_", tags[i * 2]), trav, 0);
i += 1;
};
samefile(testbins[0], testbins[1], "directory-test binaries differ");
samefile(strings.concat(testbins[0], ".sepwork/example.foo.a"),
strings.concat(testbins[1], ".sepwork/example.foo.a"),
samefile(strings.concat(testworks[0], "/example.foo.a"),
strings.concat(testworks[1], "/example.foo.a"),
"directory-test dependency archives differ");
testenv.clean(td);
};

2
test/sep/sepinit_test.ww
View File

@@ -814,7 +814,7 @@ fn rejectrow(td: str, label: str, src: str, expected: str) void = {
let av: []str = [launcher, limitstr, testenv.driver(stages[stagei]),
"test", "-c", "-w", work, "-I", tree,
"--ww-package-test", "test", "target", "target", "target",
"target_test", target, output, status, target];
"target_test", target, output, "-", status, target];
let out: testenv.commandout;
runenv(td, strings.concat("allocation-", stages[stagei], "-", tag),
av, env, &out);

8
test/tool/driver_test.ww
View File

@@ -167,13 +167,12 @@ fn runrootargv(dir: str, root: str, name: str, drv: str,
// a3 == "" means a two-token argv tail; no row passes a literal "".
@test fn flagargs() void = {
let a1: []str = ["build", "build", "build", "build", "build",
"run", "run", "run", "test", "test", "test", "test", "test",
"test"];
"run", "run", "run", "test", "test", "test", "test", "test"];
let a2: []str = ["-o", "-I", "-L", "-l", "-zz",
"-o", "-l", "-zz", "-l", "-zz", "-I", "-o", "-o",
"-o", "-l", "-zz", "-l", "-zz", "-I", "-o",
"-run"];
let a3: []str = ["", "", "", "", "",
"", "", "", "", "", "", "", "x",
"", "", "", "", "", "", "",
""];
let subs: []str = [
"ww build: -o needs an argument",
@@ -188,7 +187,6 @@ fn runrootargv(dir: str, root: str, name: str, drv: str,
"ww test: unknown flag",
"ww test: -I needs an argument",
"ww test: -o needs an argument",
"ww test: -o needs -c for a package target",
"ww test: -run needs an argument"];
let i: i32 = 0;
for (i < subs.len) {