702 lines
22 KiB
TypeScript
702 lines
22 KiB
TypeScript
import {
|
|
defaultJobs,
|
|
discoverRustCommands,
|
|
execute,
|
|
installCancellationHandlers,
|
|
mapConcurrent,
|
|
parseJobs,
|
|
parseRustListing,
|
|
resultSummary,
|
|
rustTestCommands,
|
|
shardRustCommand,
|
|
} from "./test.ts";
|
|
import { spawn } from "node:child_process";
|
|
import process from "node:process";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
function assert(
|
|
condition: unknown,
|
|
message = "assertion failed",
|
|
): asserts condition {
|
|
if (!condition) throw new Error(message);
|
|
}
|
|
|
|
Deno.test("Cargo artifact selection retains every test target and deduplicates executable reports", () => {
|
|
const test = (path: string, target: string) => ({
|
|
reason: "compiler-artifact",
|
|
package_id: "pkg",
|
|
executable: path,
|
|
target: { name: target },
|
|
profile: { test: true },
|
|
});
|
|
const commands = rustTestCommands([
|
|
test("/repo/target/lib-test", "lib"),
|
|
test("/repo/target/integration", "integration"),
|
|
test("/repo/target/integration", "integration"),
|
|
{ ...test("/repo/target/app", "app"), profile: { test: false } },
|
|
{ reason: "build-finished" },
|
|
], [{
|
|
id: "pkg",
|
|
name: "example",
|
|
manifest_path: "/repo/crates/example/Cargo.toml",
|
|
}]);
|
|
assert(commands.length === 2);
|
|
assert(commands[0].cwd === "/repo/crates/example");
|
|
assert(commands[0].env?.CARGO_MANIFEST_DIR === commands[0].cwd);
|
|
assert(commands[1].name === "example/integration");
|
|
assert(
|
|
commands.every((command) => command.args.length === 0),
|
|
"no filtering or ignore flags",
|
|
);
|
|
});
|
|
|
|
Deno.test("missing Cargo package or executables fails instead of claiming an empty suite passed", () => {
|
|
for (
|
|
const artifacts of [[], [{
|
|
reason: "compiler-artifact",
|
|
package_id: "missing",
|
|
executable: "/test",
|
|
profile: { test: true },
|
|
target: { name: "test" },
|
|
}]]
|
|
) {
|
|
let failed = false;
|
|
try {
|
|
rustTestCommands(artifacts, []);
|
|
} catch {
|
|
failed = true;
|
|
}
|
|
assert(failed);
|
|
}
|
|
});
|
|
|
|
Deno.test("bounded scheduling runs every command once and retains failing results", async () => {
|
|
let active = 0, maximum = 0;
|
|
const seen: number[] = [];
|
|
const results = await mapConcurrent([0, 1, 2, 3, 4], 2, async (item) => {
|
|
active++;
|
|
maximum = Math.max(active, maximum);
|
|
await Promise.resolve();
|
|
seen.push(item);
|
|
active--;
|
|
return item === 2 ? 1 : 0;
|
|
});
|
|
assert(maximum === 2);
|
|
assert(seen.sort().join() === "0,1,2,3,4");
|
|
assert(results.join() === "0,0,1,0,0");
|
|
for (const jobs of [0, -1, 1.5]) {
|
|
let failed = false;
|
|
try {
|
|
await mapConcurrent([], jobs, () => Promise.resolve(0));
|
|
} catch {
|
|
failed = true;
|
|
}
|
|
assert(failed);
|
|
}
|
|
});
|
|
|
|
function assertThrows(fn: () => unknown) {
|
|
let failed = false;
|
|
try {
|
|
fn();
|
|
} catch {
|
|
failed = true;
|
|
}
|
|
assert(failed, "expected failure");
|
|
}
|
|
|
|
Deno.test("CPU-derived jobs accommodates concurrent suites within the CLI bound", () => {
|
|
assert(defaultJobs(24) === 32);
|
|
assert(defaultJobs(128) === 32);
|
|
assert(defaultJobs(6) === 8);
|
|
assert(defaultJobs(1) === 2);
|
|
assert(parseJobs([]) === defaultJobs());
|
|
assert(parseJobs(["--jobs", "64"]) === 64);
|
|
assert(parseJobs(["--jobs", "1"]) === 1);
|
|
for (
|
|
const args of [
|
|
["--jobs", "65"],
|
|
["--jobs", "0"],
|
|
["--jobs", "1.5"],
|
|
["--jobs", "NaN"],
|
|
["--jobs"],
|
|
["--other", "4"],
|
|
]
|
|
) {
|
|
assertThrows(() => parseJobs(args));
|
|
}
|
|
});
|
|
|
|
Deno.test("Rust terse listing accepts every name and fails closed on unknown or duplicate lines", () => {
|
|
assert(parseRustListing("").length === 0);
|
|
assert(
|
|
parseRustListing("unit::a: test\r\nunit::bench: benchmark\r\n").join() ===
|
|
"unit::a,unit::bench",
|
|
);
|
|
for (
|
|
const text of [
|
|
"unit::a\n",
|
|
"unit::a: ignored\n",
|
|
"unit::a: test\n1 test, 0 benchmarks\n",
|
|
"unit::a: test\nunit::a: test\n",
|
|
"\n",
|
|
"unit::a: test\n\n",
|
|
"\x1b[31munit::a: test\n",
|
|
]
|
|
) {
|
|
assertThrows(() => parseRustListing(text));
|
|
}
|
|
});
|
|
|
|
function listedNames(count: number) {
|
|
return Array.from({ length: count }, (_, i) => `unit::case_${i}`);
|
|
}
|
|
|
|
Deno.test("round-robin shards retain every listed name exactly once at thresholds and the 32-shard cap", () => {
|
|
const task = {
|
|
name: "pkg/binary",
|
|
command: "/test-binary",
|
|
args: [],
|
|
cwd: "/pkg",
|
|
env: { CARGO_MANIFEST_DIR: "/pkg" },
|
|
};
|
|
for (const count of [0, 1, 72, 73, 108, 1135, 1152, 1153, 2000]) {
|
|
const names = parseRustListing(
|
|
listedNames(count).map((name) => `${name}: test\n`).join(""),
|
|
);
|
|
const shards = shardRustCommand(task, names);
|
|
const assigned = shards.flatMap((shard) => shard.selectedNames);
|
|
assert(assigned.length === count && new Set(assigned).size === count);
|
|
assert(
|
|
[...assigned].sort().join("\n") === [...names].sort().join("\n"),
|
|
"no names may be excluded",
|
|
);
|
|
if (count <= 72) {
|
|
assert(
|
|
shards.length === 1 && shards[0].task === task,
|
|
"small binaries must be unchanged",
|
|
);
|
|
} else {
|
|
const expected = Math.min(32, Math.ceil(count / 36));
|
|
assert(shards.length === expected);
|
|
const lengths = shards.map((shard) => shard.selectedNames.length);
|
|
assert(Math.max(...lengths) - Math.min(...lengths) <= 1);
|
|
shards.forEach((shard, index) => {
|
|
assert(
|
|
shard.selectedNames.join() ===
|
|
names.filter((_, i) => i % expected === index).join(),
|
|
"must distribute round-robin",
|
|
);
|
|
assert(
|
|
shard.task.args.slice(0, 3).join() === "--exact,--test-threads,2",
|
|
);
|
|
assert(shard.task.args.slice(3).join() === shard.selectedNames.join());
|
|
assert(
|
|
!shard.task.args.includes("--ignored") &&
|
|
!shard.task.args.includes("--include-ignored"),
|
|
);
|
|
assert(shard.task.cwd === task.cwd && shard.task.env === task.env);
|
|
});
|
|
}
|
|
}
|
|
assertThrows(() => shardRustCommand(task, ["same", "same"]));
|
|
});
|
|
|
|
Deno.test("scheduler drains active workers before propagating a callback error", async () => {
|
|
let drained = false;
|
|
let failed = false;
|
|
try {
|
|
await mapConcurrent([0, 1], 2, async (item) => {
|
|
if (!item) throw new Error("callback failed");
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
drained = true;
|
|
});
|
|
} catch {
|
|
failed = true;
|
|
}
|
|
assert(failed && drained);
|
|
});
|
|
|
|
const fixturePath = fileURLToPath(import.meta.url);
|
|
function fixtureArgs(mode: string, output: string) {
|
|
return [
|
|
"run",
|
|
"--allow-read",
|
|
"--allow-write",
|
|
"--allow-run",
|
|
"--allow-env",
|
|
fixturePath,
|
|
mode,
|
|
output,
|
|
];
|
|
}
|
|
function fixtureTask(mode: string, output: string) {
|
|
return {
|
|
name: `fixture/${mode}`,
|
|
command: Deno.execPath(),
|
|
args: fixtureArgs(mode, output),
|
|
cwd: output,
|
|
};
|
|
}
|
|
async function waitUntil(
|
|
check: () => boolean | Promise<boolean>,
|
|
message: string,
|
|
) {
|
|
const end = performance.now() + 10_000;
|
|
while (performance.now() < end) {
|
|
if (await check()) return;
|
|
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
}
|
|
throw new Error(message);
|
|
}
|
|
function absent(pid: number) {
|
|
try {
|
|
process.kill(pid, 0);
|
|
return false;
|
|
} catch (error) {
|
|
if ((error as NodeJS.ErrnoException).code === "ESRCH") return true;
|
|
throw error;
|
|
}
|
|
}
|
|
function emergencyKill(pid: number) {
|
|
try {
|
|
process.kill(-pid, "SIGKILL");
|
|
} catch (error) {
|
|
if ((error as NodeJS.ErrnoException).code !== "ESRCH") throw error;
|
|
}
|
|
}
|
|
|
|
for (const [mode, code] of [["success", 0], ["nonzero", 7]] as const) {
|
|
Deno.test({
|
|
name: `execute streams real ${mode} child output and records its exit`,
|
|
ignore: Deno.build.os !== "linux",
|
|
async fn() {
|
|
const output = await Deno.makeTempDir();
|
|
try {
|
|
const result = await execute({
|
|
...fixtureTask(mode, output),
|
|
inventoryRef: { binaryIndex: 3, shardIndex: 1 },
|
|
}, {
|
|
output,
|
|
label: mode,
|
|
timeoutMs: 10_000,
|
|
});
|
|
assert(result.code === code, JSON.stringify(result));
|
|
assert(!result.timedOut);
|
|
assert(!result.error, result.error);
|
|
assert(result.stdout.includes("fixture stdout 日本語"));
|
|
assert(result.stderr.includes("fixture stderr"));
|
|
assert(
|
|
await Deno.readTextFile(`${output}/${mode}.stdout`) === result.stdout,
|
|
);
|
|
assert(
|
|
await Deno.readTextFile(`${output}/${mode}.stderr`) === result.stderr,
|
|
);
|
|
const summary = JSON.parse(
|
|
await Deno.readTextFile(`${output}/${mode}.result.json`),
|
|
);
|
|
assert(summary.code === code && summary.timedOut === false);
|
|
assert(summary.log === mode && summary.timeoutMs === 10_000);
|
|
assert(
|
|
summary.inventoryRef.binaryIndex === 3 &&
|
|
summary.inventoryRef.shardIndex === 1,
|
|
"results must link unambiguously to inventory entries",
|
|
);
|
|
assert(
|
|
!("stdout" in summary),
|
|
"summary references logs, not full output",
|
|
);
|
|
assert(
|
|
absent(Number(await Deno.readTextFile(`${output}/parent.pid`))),
|
|
"direct child must be reaped",
|
|
);
|
|
} finally {
|
|
await Deno.remove(output, { recursive: true });
|
|
}
|
|
},
|
|
});
|
|
}
|
|
|
|
Deno.test({
|
|
name:
|
|
"execute preserves live stdout/stderr and times out a group containing a grandchild",
|
|
ignore: Deno.build.os !== "linux",
|
|
async fn() {
|
|
const output = await Deno.makeTempDir();
|
|
let parent: number | undefined;
|
|
let finished = false;
|
|
const running = execute(fixtureTask("tree", output), {
|
|
output,
|
|
label: "tree",
|
|
timeoutMs: 4_000,
|
|
killGraceMs: 500,
|
|
}).finally(() => finished = true);
|
|
try {
|
|
await waitUntil(async () => {
|
|
const text = await Deno.readTextFile(`${output}/tree.stdout`);
|
|
return text.includes("grandchild ready");
|
|
}, "grandchild did not become ready");
|
|
parent = Number(await Deno.readTextFile(`${output}/parent.pid`));
|
|
const grandchild = Number(
|
|
await Deno.readTextFile(`${output}/grandchild.pid`),
|
|
);
|
|
assert(!finished, "logs must be visible before execute resolves");
|
|
assert(
|
|
(await Deno.readTextFile(`${output}/tree.stderr`)).includes(
|
|
"fixture stderr",
|
|
),
|
|
);
|
|
assert(
|
|
!absent(parent) && !absent(grandchild),
|
|
"both processes must actually be running",
|
|
);
|
|
const result = await running;
|
|
assert(result.timedOut && result.code === 124, JSON.stringify(result));
|
|
assert(!result.error, result.error);
|
|
assert(result.seconds < 10, "timeout cleanup must be bounded");
|
|
assert(result.stderr.includes("timeout after 4000ms"));
|
|
assert(
|
|
result.stderr.includes("grandchild reaped"),
|
|
"fixture parent must reap its child",
|
|
);
|
|
assert(absent(parent), "direct child must be reaped by runner");
|
|
assert(absent(grandchild), "grandchild must be stopped and reaped");
|
|
const summary = JSON.parse(
|
|
await Deno.readTextFile(`${output}/tree.result.json`),
|
|
);
|
|
assert(summary.timedOut && summary.code === 124);
|
|
assert(summary.name === "fixture/tree" && summary.log === "tree");
|
|
} finally {
|
|
if (parent !== undefined) emergencyKill(parent);
|
|
await running;
|
|
await Deno.remove(output, { recursive: true });
|
|
}
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name:
|
|
"execute escalates SIGTERM to SIGKILL and reaps a stubborn direct child",
|
|
ignore: Deno.build.os !== "linux",
|
|
async fn() {
|
|
const output = await Deno.makeTempDir();
|
|
try {
|
|
const result = await execute(fixtureTask("stubborn", output), {
|
|
output,
|
|
label: "stubborn",
|
|
timeoutMs: 2_000,
|
|
killGraceMs: 100,
|
|
});
|
|
assert(result.stdout.includes("stubborn ready"));
|
|
assert(result.stderr.includes("ignored SIGTERM"));
|
|
assert(
|
|
result.timedOut && result.code === 124 && result.signal === "SIGKILL",
|
|
JSON.stringify(result),
|
|
);
|
|
assert(!result.error, result.error);
|
|
assert(result.seconds < 8);
|
|
assert(absent(Number(await Deno.readTextFile(`${output}/parent.pid`))));
|
|
} finally {
|
|
await Deno.remove(output, { recursive: true });
|
|
}
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "execute records spawn failure instead of an empty passing suite",
|
|
ignore: Deno.build.os !== "linux",
|
|
async fn() {
|
|
const output = await Deno.makeTempDir();
|
|
try {
|
|
const result = await execute({
|
|
name: "missing",
|
|
command: `${output}/does-not-exist`,
|
|
args: [],
|
|
cwd: output,
|
|
}, { output, label: "missing", timeoutMs: 2_000, killGraceMs: 10 });
|
|
assert(result.code !== 0 && !result.timedOut);
|
|
assert(result.error?.includes("ENOENT"), JSON.stringify(result));
|
|
assert(
|
|
(await Deno.readTextFile(`${output}/missing.stderr`)).includes(
|
|
"ENOENT",
|
|
),
|
|
);
|
|
const summary = JSON.parse(
|
|
await Deno.readTextFile(`${output}/missing.result.json`),
|
|
);
|
|
assert(summary.code !== 0 && summary.error.includes("ENOENT"));
|
|
} finally {
|
|
await Deno.remove(output, { recursive: true });
|
|
}
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name:
|
|
"runtime listing persists complete name inventory for large and small binaries",
|
|
ignore: Deno.build.os !== "linux",
|
|
async fn() {
|
|
const output = await Deno.makeTempDir();
|
|
try {
|
|
const discovery = await discoverRustCommands(
|
|
[
|
|
fixtureTask("list-large", output),
|
|
fixtureTask("list-small", output),
|
|
],
|
|
2,
|
|
{ output },
|
|
);
|
|
assert(discovery.inventory.complete);
|
|
assert(
|
|
discovery.inventory.rustBinaries === 2 &&
|
|
discovery.inventory.selectedCases === 1137,
|
|
);
|
|
assert(discovery.tasks.length === 33);
|
|
const persisted = JSON.parse(
|
|
await Deno.readTextFile(`${output}/inventory.json`),
|
|
) as typeof discovery.inventory;
|
|
assert(persisted.complete && persisted.selectedCases === 1137);
|
|
const large = persisted.binaries[0];
|
|
assert(large.shards.length === 32 && large.selectedCases === 1135);
|
|
persisted.binaries.forEach((binary, binaryIndex) =>
|
|
binary.shards.forEach((shard, shardIndex) => {
|
|
assert(shard.task.inventoryRef?.binaryIndex === binaryIndex);
|
|
assert(shard.task.inventoryRef?.shardIndex === shardIndex);
|
|
})
|
|
);
|
|
const assigned = large.shards.flatMap((shard) => shard.selectedNames);
|
|
assert(new Set(assigned).size === 1135 && assigned.length === 1135);
|
|
assert([...assigned].sort().join() === listedNames(1135).sort().join());
|
|
assert(
|
|
persisted.binaries[1].shards[0].task.args.join() ===
|
|
fixtureTask("list-small", output).args.join(),
|
|
);
|
|
assert(
|
|
persisted.binaries.every((binary) =>
|
|
binary.listing.code === 0 && binary.listing.seconds > 0
|
|
),
|
|
);
|
|
} finally {
|
|
await Deno.remove(output, { recursive: true });
|
|
}
|
|
},
|
|
});
|
|
|
|
for (const mode of ["list-nonzero", "list-unknown"]) {
|
|
Deno.test({
|
|
name:
|
|
`discovery ${mode} fails with saved evidence rather than running a partial selection`,
|
|
ignore: Deno.build.os !== "linux",
|
|
async fn() {
|
|
const output = await Deno.makeTempDir();
|
|
try {
|
|
const discovery = await discoverRustCommands(
|
|
[
|
|
fixtureTask("list-small", output),
|
|
fixtureTask(mode, output),
|
|
],
|
|
2,
|
|
{ output },
|
|
);
|
|
assert(!discovery.inventory.complete);
|
|
assert(discovery.inventory.selectedCases === null);
|
|
assert(discovery.tasks.length === 0);
|
|
const persisted = JSON.parse(
|
|
await Deno.readTextFile(`${output}/inventory.json`),
|
|
) as typeof discovery.inventory;
|
|
assert(
|
|
!persisted.complete && persisted.binaries[1].shards.length === 0,
|
|
);
|
|
assert(
|
|
persisted.binaries[1].error?.includes(
|
|
mode === "list-nonzero" ? "code 7" : "unknown Rust listing format",
|
|
),
|
|
);
|
|
const listing = JSON.parse(
|
|
await Deno.readTextFile(`${output}/list-001.result.json`),
|
|
);
|
|
assert(listing.code === (mode === "list-nonzero" ? 7 : 0));
|
|
assert(
|
|
persisted.discoveredCases === 2,
|
|
"partial discovery must not be presented as complete selection",
|
|
);
|
|
} finally {
|
|
await Deno.remove(output, { recursive: true });
|
|
}
|
|
},
|
|
});
|
|
}
|
|
|
|
async function textIfPresent(path: string): Promise<string> {
|
|
try {
|
|
return await Deno.readTextFile(path);
|
|
} catch (error) {
|
|
if (error instanceof Deno.errors.NotFound) return "";
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
for (const signal of ["SIGINT", "SIGTERM"] as const) {
|
|
Deno.test({
|
|
name:
|
|
`parent ${signal} cleans up active groups, reaps children and does not spawn queued commands`,
|
|
ignore: Deno.build.os !== "linux",
|
|
async fn() {
|
|
const output = await Deno.makeTempDir();
|
|
const parent = new Deno.Command(Deno.execPath(), {
|
|
args: fixtureArgs("runner-parent", output),
|
|
stdout: "piped",
|
|
stderr: "piped",
|
|
}).spawn();
|
|
const done = parent.output();
|
|
const pids: number[] = [];
|
|
try {
|
|
await waitUntil(
|
|
async () =>
|
|
(await textIfPresent(`${output}/tree/tree.stdout`)).includes(
|
|
"grandchild ready",
|
|
) &&
|
|
(await textIfPresent(`${output}/stubborn/stubborn.stdout`))
|
|
.includes("stubborn ready"),
|
|
"parent runner fixtures did not become ready",
|
|
);
|
|
for (
|
|
const file of [
|
|
"tree/parent.pid",
|
|
"tree/grandchild.pid",
|
|
"stubborn/parent.pid",
|
|
]
|
|
) {
|
|
pids.push(Number(await Deno.readTextFile(`${output}/${file}`)));
|
|
}
|
|
process.kill(parent.pid, signal);
|
|
const status = await done;
|
|
assert(
|
|
status.code === (signal === "SIGINT" ? 130 : 143),
|
|
new TextDecoder().decode(status.stderr),
|
|
);
|
|
assert(absent(parent.pid));
|
|
assert(
|
|
pids.every(absent),
|
|
"active children and grandchild must be reaped",
|
|
);
|
|
const results = JSON.parse(
|
|
await Deno.readTextFile(`${output}/cancel-summary.json`),
|
|
) as ReturnType<typeof resultSummary>[];
|
|
assert(results.length === 3);
|
|
assert(
|
|
results.every((result) =>
|
|
result.cancelled && result.cancellationReason === signal &&
|
|
!result.timedOut && !result.error
|
|
),
|
|
);
|
|
assert(
|
|
results[1].signal === "SIGKILL",
|
|
"stubborn child requires escalation on parent cancellation too",
|
|
);
|
|
assert(
|
|
await textIfPresent(`${output}/queued/parent.pid`) === "",
|
|
"cancelled queue must not spawn",
|
|
);
|
|
assert(
|
|
(await Deno.readTextFile(`${output}/tree/tree.stderr`)).includes(
|
|
"grandchild reaped",
|
|
),
|
|
);
|
|
} finally {
|
|
if (!absent(parent.pid)) process.kill(parent.pid, "SIGTERM");
|
|
await done;
|
|
for (const pid of pids) emergencyKill(pid);
|
|
await Deno.remove(output, { recursive: true });
|
|
}
|
|
},
|
|
});
|
|
}
|
|
|
|
// Real subprocess fixtures live here rather than introducing another executable.
|
|
// A watchdog is independent of execute, so a broken runner cannot leak fixtures
|
|
// forever. The tree's parent cooperatively reaps its child on TERM; KILL behavior
|
|
// is exercised separately by the stubborn fixture.
|
|
if (import.meta.main) {
|
|
const [mode, output] = Deno.args;
|
|
setTimeout(() => Deno.exit(99), 20_000);
|
|
if (mode.startsWith("list-")) {
|
|
assert(
|
|
Deno.args.slice(2).join() === "--list,--format,terse",
|
|
"discovery must use libtest terse listing",
|
|
);
|
|
if (mode === "list-unknown") {
|
|
console.log("unexpected harness output");
|
|
} else {
|
|
console.log(
|
|
listedNames(mode === "list-large" ? 1135 : 2).map((name) =>
|
|
`${name}: test`
|
|
).join("\n"),
|
|
);
|
|
}
|
|
Deno.exit(mode === "list-nonzero" ? 7 : 0);
|
|
} else if (mode === "runner-parent") {
|
|
const cancellation = installCancellationHandlers();
|
|
try {
|
|
for (const dir of ["tree", "stubborn", "queued"]) {
|
|
await Deno.mkdir(`${output}/${dir}`);
|
|
}
|
|
const results = await mapConcurrent(
|
|
["tree", "stubborn", "queued"],
|
|
2,
|
|
async (name) => {
|
|
const dir = `${output}/${name}`;
|
|
return resultSummary(
|
|
await execute(
|
|
fixtureTask(name === "queued" ? "success" : name, dir),
|
|
{
|
|
output: dir,
|
|
label: name,
|
|
timeoutMs: 15_000,
|
|
killGraceMs: 200,
|
|
signal: cancellation.signal,
|
|
},
|
|
),
|
|
);
|
|
},
|
|
);
|
|
await Deno.writeTextFile(
|
|
`${output}/cancel-summary.json`,
|
|
JSON.stringify(results),
|
|
);
|
|
Deno.exitCode = results[0].code;
|
|
} finally {
|
|
cancellation.dispose();
|
|
}
|
|
Deno.exit(Deno.exitCode);
|
|
} else if (mode === "grandchild") {
|
|
Deno.addSignalListener("SIGTERM", () => Deno.exit(0));
|
|
Deno.writeTextFileSync(`${output}/grandchild.pid`, String(Deno.pid));
|
|
console.log("grandchild ready");
|
|
} else {
|
|
Deno.writeTextFileSync(`${output}/parent.pid`, String(Deno.pid));
|
|
console.log("fixture stdout 日本語");
|
|
console.error("fixture stderr");
|
|
if (mode === "success" || mode === "nonzero") {
|
|
Deno.exit(mode === "success" ? 0 : 7);
|
|
} else if (mode === "stubborn") {
|
|
Deno.addSignalListener("SIGTERM", () => console.error("ignored SIGTERM"));
|
|
console.log("stubborn ready");
|
|
} else if (mode === "tree") {
|
|
// The grandchild inherits the new group from execute's direct child.
|
|
// The parent intentionally does NOT forward TERM: only group signaling
|
|
// can stop the grandchild before its independent watchdog.
|
|
Deno.addSignalListener("SIGTERM", () => {});
|
|
const child = spawn(Deno.execPath(), fixtureArgs("grandchild", output), {
|
|
stdio: "inherit",
|
|
});
|
|
child.on("close", () => {
|
|
console.error("grandchild reaped");
|
|
Deno.exit(0);
|
|
});
|
|
} else {
|
|
throw new Error(`unknown fixture mode: ${mode}`);
|
|
}
|
|
}
|
|
}
|