if (testPath.includes("test-dns")) return 60_000;

if (testPath.includes("-docker-")) return 60_000;

if (!isCI) return 60_000; // everything slower in debug mode

if (options["step"]?.includes("-asan-")) return 60_000;

return 20_000;

const expectationsPath = join(cwd, "test", "expectations.txt");

if (!existsSync(expectationsPath)) {

return [];

}

const lines = readFileSync(expectationsPath, "utf-8").split(/\r?\n/);

/** @type {TestExpectation[]} */

const expectations = [];

for (const line of lines) {

const content = line.trim();

if (!content || content.startsWith("#")) {

continue;

}

let comment;

const commentIndex = content.indexOf("#");

let cleanLine = content;

if (commentIndex !== -1) {

comment = content.substring(commentIndex + 1).trim();

cleanLine = content.substring(0, commentIndex).trim();

}

let modifiers = [];

let remaining = cleanLine;

let modifierMatch = remaining.match(/^\[(.*?)\]/);

if (modifierMatch) {

modifiers = modifierMatch[1].trim().split(/\s+/);

remaining = remaining.substring(modifierMatch[0].length).trim();

}

let expectationValues = ["Skip"];

const expectationMatch = remaining.match(/\[(.*?)\]$/);

if (expectationMatch) {

expectationValues = expectationMatch[1].trim().split(/\s+/);

remaining = remaining.substring(0, remaining.length - expectationMatch[0].length).trim();

}

const filename = remaining.trim();

if (filename) {

expectations.push({

filename,

expectations: expectationValues,

bugs: undefined,

modifiers: modifiers.length ? modifiers : undefined,

comment,

});

}

}

return expectations;

const ext = extname(testPath);

const filename = basename(testPath, ext);

const modifiers = filename.split("-").filter(value => value !== "bun");

const os = getOs();

const arch = getArch();

modifiers.push(os, arch, `${os}-${arch}`);

const distro = getDistro();

if (distro) {

modifiers.push(distro, `${os}-${distro}`, `${os}-${arch}-${distro}`);

const distroVersion = getDistroVersion();

if (distroVersion) {

modifiers.push(

distroVersion,

`${distro}-${distroVersion}`,

`${os}-${distro}-${distroVersion}`,

`${os}-${arch}-${distro}-${distroVersion}`,

);

}

}

const abi = getAbi();

if (abi) {

modifiers.push(abi, `${os}-${abi}`, `${os}-${arch}-${abi}`);

const abiVersion = getAbiVersion();

if (abiVersion) {

modifiers.push(

abiVersion,

`${abi}-${abiVersion}`,

`${os}-${abi}-${abiVersion}`,

`${os}-${arch}-${abi}-${abiVersion}`,

);

}

}

return modifiers.map(value => value.toUpperCase());

let execPath;

if (options["step"]) {

execPath = await getExecPathFromBuildKite(options["step"], options["build-id"]);

} else {

execPath = getExecPath(options["exec-path"]);

}

!isQuiet && console.log("Bun:", execPath);

const expectations = getTestExpectations();

const modifiers = getTestModifiers(execPath);

!isQuiet && console.log("Modifiers:", modifiers);

const revision = getRevision(execPath);

!isQuiet && console.log("Revision:", revision);

const tests = getRelevantTests(testsPath, modifiers, expectations);

!isQuiet && console.log("Running tests:", tests.length);

/** @type {VendorTest[] | undefined} */

let vendorTests;

let vendorTotal = 0;

if (/true|1|yes|on/i.test(options["vendor"]) || (isCI && typeof options["vendor"] === "undefined")) {

vendorTests = await getVendorTests(cwd);

if (vendorTests.length) {

vendorTotal = vendorTests.reduce((total, { testPaths }) => total + testPaths.length + 1, 0);

!isQuiet && console.log("Running vendor tests:", vendorTotal);

}

}

let i = 0;

let total = vendorTotal + tests.length + 2;

const okResults = [];

const flakyResults = [];

const flakyResultsTitles = [];

const failedResults = [];

const failedResultsTitles = [];

const maxAttempts = 1 + (parseInt(options["retries"]) || 0);

const parallelism = options["parallel"] ? availableParallelism() : 1;

console.log("parallelism", parallelism);

const limit = pLimit(parallelism);

/**

const runTest = async (title, fn) => {

const index = ++i;

let result, failure, flaky;

let attempt = 1;

for (; attempt <= maxAttempts; attempt++) {

if (attempt > 1) {

await new Promise(resolve => setTimeout(resolve, 5000 + Math.random() * 10_000));

}

let grouptitle = `${getAnsi("gray")}[${index}/${total}]${getAnsi("reset")} ${title}`;

if (attempt > 1) grouptitle += ` ${getAnsi("gray")}[attempt #${attempt}]${getAnsi("reset")}`;

if (parallelism > 1) {

console.log(grouptitle);

result = await fn(index);

} else {

result = await startGroup(grouptitle, fn);

}

const { ok, stdoutPreview, error } = result;

if (ok) {

if (failure) {

flakyResults.push(failure);

flakyResultsTitles.push(title);

} else {

okResults.push(result);

}

break;

}

const color = attempt >= maxAttempts ? "red" : "yellow";

const label = `${getAnsi(color)}[${index}/${total}] ${title} - ${error}${getAnsi("reset")}`;

startGroup(label, () => {

if (parallelism > 1) return;

if (!isCI) return;

process.stderr.write(stdoutPreview);

});

failure ||= result;

flaky ||= true;

if (attempt >= maxAttempts || isAlwaysFailure(error)) {

flaky = false;

failedResults.push(failure);

failedResultsTitles.push(title);

break;

}

}

if (!failure) {

return result;

}

if (isBuildkite) {

// Group flaky tests together, regardless of the title

const context = flaky ? "flaky" : title;

const style = flaky ? "warning" : "error";

if (!flaky) attempt = 1; // no need to show the retries count on failures, we know it maxed out

if (title.startsWith("vendor")) {

const content = formatTestToMarkdown({ ...failure, testPath: title }, false, attempt - 1);

if (content) {

reportAnnotationToBuildKite({ context, label: title, content, style });

}

} else {

const content = formatTestToMarkdown(failure, false, attempt - 1);

if (content) {

reportAnnotationToBuildKite({ context, label: title, content, style });

}

}

}

if (isGithubAction) {

const summaryPath = process.env["GITHUB_STEP_SUMMARY"];

if (summaryPath) {

const longMarkdown = formatTestToMarkdown(failure, false, attempt - 1);

appendFileSync(summaryPath, longMarkdown);

}

const shortMarkdown = formatTestToMarkdown(failure, true, attempt - 1);

appendFileSync("comment.md", shortMarkdown);

}

if (options["bail"]) {

process.exit(getExitCode("fail"));

}

return result;

};

if (!isQuiet) {

for (const path of [cwd, testsPath]) {

const title = relative(cwd, join(path, "package.json")).replace(/\\/g, "/");

await runTest(title, async () => spawnBunInstall(execPath, { cwd: path }));

}

}

if (!failedResults.length) {

// TODO: remove windows exclusion here

if (isCI && !isWindows) {

// bun install has succeeded

const { promise: portPromise, resolve: portResolve } = Promise.withResolvers();

const { promise: errorPromise, resolve: errorResolve } = Promise.withResolvers();

console.log("run in", cwd);

let exiting = false;

const server = spawn(execPath, ["run", "--silent", "ci-remap-server", execPath, cwd, getCommit()], {

stdio: ["ignore", "pipe", "inherit"],

cwd, // run in main repo

env: { ...process.env, BUN_DEBUG_QUIET_LOGS: "1", NO_COLOR: "1" },

});

server.unref();

server.on("error", errorResolve);

server.on("exit", (code, signal) => {

if (!exiting && (code !== 0 || signal !== null)) errorResolve(signal ? signal : "code " + code);

});

function onBeforeExit() {

exiting = true;

server.off("error");

server.off("exit");

server.kill?.();

}

process.once("beforeExit", onBeforeExit);

const lines = createInterface(server.stdout);

lines.on("line", line => {

portResolve({ port: parseInt(line) });

});

const result = await Promise.race([portPromise, errorPromise.catch(e => e), setTimeoutPromise(5000, "timeout")]);

if (typeof result?.port != "number") {

process.off("beforeExit", onBeforeExit);

server.kill?.();

console.warn("ci-remap server did not start:", result);

} else {

console.log("crash reports parsed on port", result.port);

remapPort = result.port;

}

}

await Promise.all(

tests.map(testPath =>

limit(() => {

const absoluteTestPath = join(testsPath, testPath);

const title = relative(cwd, absoluteTestPath).replaceAll(sep, "/");

if (isNodeTest(testPath)) {

const testContent = readFileSync(absoluteTestPath, "utf-8");

let runWithBunTest = title.includes("needs-test") || testContent.includes("node:test");

// don't wanna have a filter for includes("bun:test") but these need our mocks

runWithBunTest ||= title === "test/js/node/test/parallel/test-fs-append-file-flush.js";

runWithBunTest ||= title === "test/js/node/test/parallel/test-fs-write-file-flush.js";

runWithBunTest ||= title === "test/js/node/test/parallel/test-fs-write-stream-flush.js";

const subcommand = runWithBunTest ? "test" : "run";

const env = {

FORCE_COLOR: "0",

NO_COLOR: "1",

BUN_DEBUG_QUIET_LOGS: "1",

};

if ((basename(execPath).includes("asan") || !isCI) && shouldValidateExceptions(testPath)) {

env.BUN_JSC_validateExceptionChecks = "1";

env.BUN_JSC_dumpSimulatedThrows = "1";

}

if ((basename(execPath).includes("asan") || !isCI) && shouldValidateLeakSan(testPath)) {

env.BUN_DESTRUCT_VM_ON_EXIT = "1";

env.ASAN_OPTIONS = "allow_user_segv_handler=1:disable_coredump=0:detect_leaks=1:abort_on_error=1";

// prettier-ignore

env.LSAN_OPTIONS = `malloc_context_size=100:print_suppressions=0:suppressions=${process.cwd()}/test/leaksan.supp`;

}

return runTest(title, async () => {

const { ok, error, stdout, crashes } = await spawnBun(execPath, {

cwd: cwd,

args: [

subcommand,

"--config=" + join(import.meta.dirname, "../bunfig.node-test.toml"),

absoluteTestPath,

],

timeout: getNodeParallelTestTimeout(title),

env,

stdout: parallelism > 1 ? () => {} : chunk => pipeTestStdout(process.stdout, chunk),

stderr: parallelism > 1 ? () => {} : chunk => pipeTestStdout(process.stderr, chunk),

});

const mb = 1024 ** 3;

let stdoutPreview = stdout.slice(0, mb).split("\n").slice(0, 50).join("\n");

if (crashes) stdoutPreview += crashes;

return {

testPath: title,

ok: ok,

status: ok ? "pass" : "fail",

error: error,

errors: [],

tests: [],

stdout: stdout,

stdoutPreview: stdoutPreview,

};

});

} else {

return runTest(title, async () =>

spawnBunTest(execPath, join("test", testPath), {

cwd,

stdout: parallelism > 1 ? () => {} : chunk => pipeTestStdout(process.stdout, chunk),

stderr: parallelism > 1 ? () => {} : chunk => pipeTestStdout(process.stderr, chunk),

}),

);

}

}),

),

);

}

if (vendorTests?.length) {

for (const { cwd: vendorPath, packageManager, testRunner, testPaths } of vendorTests) {

if (!testPaths.length) {

continue;

}

const packageJson = join(relative(cwd, vendorPath), "package.json").replace(/\\/g, "/");

if (packageManager === "bun") {

const { ok } = await runTest(packageJson, () => spawnBunInstall(execPath, { cwd: vendorPath }));

if (!ok) {

continue;

}

} else {

throw new Error(`Unsupported package manager: ${packageManager}`);

}

// build

const buildResult = await spawnBun(execPath, {

cwd: vendorPath,

args: ["run", "build"],

timeout: 60_000,

});

if (!buildResult.ok) {

throw new Error(`Failed to build vendor: ${buildResult.error}`);

}

for (const testPath of testPaths) {

const title = join(relative(cwd, vendorPath), testPath).replace(/\\/g, "/");

if (testRunner === "bun") {

await runTest(title, index =>

spawnBunTest(execPath, testPath, { cwd: vendorPath, env: { TEST_SERIAL_ID: index } }),

);

} else {

const testRunnerPath = join(cwd, "test", "runners", `${testRunner}.ts`);

if (!existsSync(testRunnerPath)) {

throw new Error(`Unsupported test runner: ${testRunner}`);

}

await runTest(title, () =>

spawnBunTest(execPath, testPath, {

cwd: vendorPath,

args: ["--preload", testRunnerPath],

}),

);

}

}

}

}

// tests are all over, close the group from the final test. any further output should print ungrouped.

startGroup("End");

if (isGithubAction) {

reportOutputToGitHubAction("failing_tests_count", failedResults.length);

const markdown = formatTestToMarkdown(failedResults, false, 0);

reportOutputToGitHubAction("failing_tests", markdown);

}

// Generate and upload JUnit reports if requested

if (options["junit"]) {

const junitTempDir = options["junit-temp-dir"];

mkdirSync(junitTempDir, { recursive: true });

// Generate JUnit reports for tests that don't use bun test

const nonBunTestResults = [...okResults, ...flakyResults, ...failedResults].filter(result => {

// Check if this is a test that wasn't run with bun test

const isNodeTest =

isJavaScript(result.testPath) && !isTestStrict(result.testPath) && !result.testPath.includes("vendor");

return isNodeTest;

});

// If we have tests not covered by bun test JUnit reports, generate a report for them

if (nonBunTestResults.length > 0) {

const nonBunTestJunitPath = join(junitTempDir, "non-bun-test-results.xml");

generateJUnitReport(nonBunTestJunitPath, nonBunTestResults);

!isQuiet &&

console.log(

`Generated JUnit report for ${nonBunTestResults.length} non-bun test results at ${nonBunTestJunitPath}`,

);

// Upload this report immediately if we're on BuildKite

if (isBuildkite && options["junit-upload"]) {

const uploadSuccess = await uploadJUnitToBuildKite(nonBunTestJunitPath);

if (uploadSuccess) {

// Delete the file after successful upload to prevent redundant uploads

try {

unlinkSync(nonBunTestJunitPath);

!isQuiet && console.log(`Uploaded and deleted non-bun test JUnit report`);

} catch (unlinkError) {

!isQuiet && console.log(`Uploaded but failed to delete non-bun test JUnit report: ${unlinkError.message}`);

}

} else {

!isQuiet && console.log(`Failed to upload non-bun test JUnit report to BuildKite`);

}

}

}

// Check for any JUnit reports that may not have been uploaded yet

// Since we're deleting files after upload, any remaining files need to be uploaded

if (isBuildkite && options["junit-upload"]) {

try {

// Only process XML files and skip the non-bun test results which we've already uploaded

const allJunitFiles = readdirSync(junitTempDir).filter(

file => file.endsWith(".xml") && file !== "non-bun-test-results.xml",

);

if (allJunitFiles.length > 0) {

!isQuiet && console.log(`Found ${allJunitFiles.length} remaining JUnit reports to upload...`);

// Process each remaining JUnit file - these are files we haven't processed yet

let uploadedCount = 0;

for (const file of allJunitFiles) {

const filePath = join(junitTempDir, file);

if (existsSync(filePath)) {

try {

const uploadSuccess = await uploadJUnitToBuildKite(filePath);

if (uploadSuccess) {

// Delete the file after successful upload

try {

unlinkSync(filePath);

uploadedCount++;

} catch (unlinkError) {

!isQuiet && console.log(`Uploaded but failed to delete ${file}: ${unlinkError.message}`);

}

}

} catch (err) {

console.error(`Error uploading JUnit file ${file}:`, err);

}

}

}