frida-test 0.1.1

package/README.md

@@ -0,0 +1,138 @@
+# frida-test Documentation
+
+This is a small test framework which runs on the target. It is used to unit test Frida code running on actual devices. It was originaly developed to test the Frida agent code used in [frooky](https://github.com/cpholguera/frooky).
+
+The following chapters explain how to write and run tests.
+
+## Installation
+
+```sh
+npm install --save-dev frida-test
+```
+
+## Writing Tests
+
+Tests follow the Behavior-Driven Development (BDD) pattern. They use the describe-it-expect structure to describe the expected behavior.
+
+The basic syntax is:
+
+- `describe()`: Defines a test suite or a specific component's behavior.
+- `test()` or `it()`: Describes a specific requirement or expected outcome.
+- `expect()`: Validates that the actual output matches the expected behavior.
+
+```typescript
+describe('Classloader', () => {
+  it('should throw an exception if the class is not available.', () => {
+    expect(() => {
+      ClassLoader.loadSync('badClass')
+    }).toThrow(new Error("Class 'badClass' is not available."));
+  })
+});
+```
+
+Tests can be nested to any depth and can be synchronous or asynchronous.
+
+### Test discovery
+
+The framework collects every file matching `*.test.ts` in the directories passed on the command line, recursively.
+
+A good practice is to create test files next to the source code file as shown here:
+
+```text
+myProject/
+├── android/
+│   ├── classLoader.ts
+│   └── classLoader.test.ts
+├── ios/
+│   ├── objcRuntime.ts
+│   └── objcRuntime.test.ts
+└── shared/
+    ├── helper.ts
+    └── helper.test.ts
+```
+
+## Matchers
+
+`expect(actualValue)` returns a `Matcher` which we can use to test for the expected value. Use the following functions to do that:
+
+| Matcher | Description |
+| --- | --- |
+| `.toBe(value)` | Strict equality (`===`) |
+| `.toEqual(value)` | Deep equality |
+| `.toBeTruthy()` | Value is truthy |
+| `.toBeFalsy()` | Value is falsy |
+| `.toBeNull()` | Value is strictly `null` |
+| `.toBeDefined()` | Value is not `undefined` |
+| `.toBeUndefined()` | Value is `undefined` |
+| `.toBeGreaterThan(value)` | Numeric value is greater than `value` |
+| `.toBeLessThan(value)` | Numeric value is less than `value` |
+| `.toContain(value)` | Value (array, string, etc.) contains `value` |
+| `.toThrow(errorMatch)` | Exception thrown; optionally matches a string message or `Error` instance |
+| `.toReject(errorMatch)` | Returned promise rejects; optionally matches a string message or `Error` instance (must be `await`ed) |
+| `.toHaveBeenCalled()` | Spy target function was called at least once |
+| `.toHaveBeenCalledWith(...expected)` | Spy target function was called with expected arguments |
+| `.not.<matcher>` | Inverts the assertion result |
+
+> [!NOTE]
+> `frida-test` test itself. So for examples for all Matches and more, have a look a the `*.test.ts` located in the [test folder](./tests/)
+
+## Running Tests
+
+`frida-test` takes one or more directories, collects every `*.test.ts` file below them, compiles them together with the framework agent, and runs the resulting agent on the target.
+
+```sh
+frida-test [options] <dir...>
+```
+
+### Options
+
+| Option | Description |
+| --- | --- |
+| `-i, --id <id>` | Bundle/package id or app name (spawns the app) |
+| `-p, --pid <id>` | Attach to a running process instead |
+| `-U, --usb` | Use the USB device |
+| `-D, --device <id>` | Use a specific device by id |
+| `-o, --out <path>` | Path of the output file for JSON reporter (default: disabled) |
+| `-t, --timeout <s>` | Abort the run after this many seconds (default: `600`, `0` disables) |
+| `-d, --delay <s>` | Start running the test suites after this many seconds (default: `0`) |
+| `-k, --keep` | Keep the generated agent in `.frida-test/agent.js` |
+| `-v, --verbose` | Enable verbose logging |
+| `-h, --help` | Shows the help message |
+
+### `frida-test` Examples
+
+```sh
+# Android app on a USB device, tests in ./tests/android and ./tests/shared
+frida-test -i org.owasp.mastestapp -U ./tests/android ./tests/shared
+
+# Attach to a running process by pid
+frida-test --pid 4926 -u ./tests/android
+
+# iOS app in the local simulator
+frida-test -i org.owasp.mastestapp.MASTestApp-iOS ./tests/ios ./tests/shared
+```
+
+## Compile Agent
+
+`frida-test` automatically bundles the test suites, and compiles them together with the testing framework into a Frida agent.
+
+If you only want to compile this agent, use `frida-test-compiler`:
+
+```sh
+frida-test-compiler [options] <dir...>
+```
+
+| Option | Description |
+| --- | --- |
+| `-o, --out <path>` | Path of the output file for JSON reporter (default: disabled) |
+| `-h, --help` | Shows the help message |
+
+### `frida-test-compiler` Examples
+
+```sh
+# Collects all tests in ./tests, compiles the frida-test agent, and print it to stdout
+frida-test-compiler ./tests
+
+# Collects all tests in ./tests, compile the frida-test agent, and stores it in the path ./frida-test-agent.js
+frida-test-compiler ./tests -o ./frida-test-agent.js
+```

package/bin/frida-test-compiler.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+import("../dist/cli-frida-test-compiler.js").catch((err) => {
+  console.error("Failed to load the CLI module. Make sure the project is built.");
+  console.error(err);
+  process.exit(1);
+});

package/bin/frida-test.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+import("../dist/cli-frida-test.js").catch((err) => {
+  console.error("Failed to load the CLI module. Make sure the project is built.");
+  console.error(err);
+  process.exit(1);
+});

package/dist/bundler.js

@@ -0,0 +1,132 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { logger } from "./logger.js";
+const IMPORT_MARKER = "/// IMPORT TESTS SUITES ///";
+const execFileAsync = promisify(execFile);
+const AGENT_ENTRYPOINT_FILENAME = "agentRuntime.ts";
+const AGENT_ENTRYPOINT_BASENAME = path.basename(AGENT_ENTRYPOINT_FILENAME, path.extname(AGENT_ENTRYPOINT_FILENAME));
+const AGENT_BUNDLE_FILENAME = `${AGENT_ENTRYPOINT_BASENAME}.bundle.js`;
+function resolveProjectRoot(startDir = process.cwd()) {
+    let dir = startDir;
+    while (true) {
+        if (existsSync(path.join(dir, "package.json")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return startDir;
+        dir = parent;
+    }
+}
+function resolveAgentRuntimePath(projectRoot) {
+    return path.join(projectRoot, "src", "agent-runtime");
+}
+function resolveFridaCompileBin(projectRoot) {
+    const binName = process.platform === "win32" ? "frida-compile.cmd" : "frida-compile";
+    return path.join(projectRoot, "node_modules", ".bin", binName);
+}
+let cachedProjectRoot;
+let cachedAgentRuntimeSrcDir;
+let cachedFridaCompileBin;
+function getProjectRoot() {
+    cachedProjectRoot ??= resolveProjectRoot();
+    return cachedProjectRoot;
+}
+function getAgentRuntimeSrcDir(projectRoot) {
+    if (!cachedAgentRuntimeSrcDir) {
+        const dir = resolveAgentRuntimePath(projectRoot);
+        if (!existsSync(dir)) {
+            throw new Error(`Agent runtime source directory not found at "${dir}".`);
+        }
+        cachedAgentRuntimeSrcDir = dir;
+    }
+    return cachedAgentRuntimeSrcDir;
+}
+function getFridaCompileBin(projectRoot) {
+    if (!cachedFridaCompileBin) {
+        const localBin = resolveFridaCompileBin(projectRoot);
+        cachedFridaCompileBin = existsSync(localBin) ? { path: localBin, useLocal: true } : { path: "npx", useLocal: false };
+    }
+    return cachedFridaCompileBin;
+}
+async function createWorkDir(projectRoot) {
+    const cacheRoot = path.join(projectRoot, ".frida-test-cache");
+    await mkdir(cacheRoot, { recursive: true });
+    const gitignorePath = path.join(cacheRoot, ".gitignore");
+    if (!existsSync(gitignorePath)) {
+        await writeFile(gitignorePath, "*\n", "utf8");
+    }
+    return mkdtemp(cacheRoot + path.sep);
+}
+async function deleteWorkDir(workDir) {
+    try {
+        return await rm(workDir, { recursive: true, force: true });
+    }
+    catch (err) {
+        logger.warn(`Failed to remove temporary work dir "${workDir}": ${err.message}`);
+    }
+}
+async function copyDirRecursive(srcDir, destDir) {
+    await mkdir(destDir, { recursive: true });
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    await Promise.all(entries.map(async (entry) => {
+        const srcPath = path.join(srcDir, entry.name);
+        const destPath = path.join(destDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(srcPath, destPath);
+            return;
+        }
+        await copyFile(srcPath, destPath);
+    }));
+}
+export async function bundleAgent(testSuitePaths, keep = false) {
+    if (testSuitePaths.length === 0) {
+        throw new Error("bundleAgent requires at least one test suite path.");
+    }
+    const projectRoot = getProjectRoot();
+    const workDir = await createWorkDir(projectRoot);
+    try {
+        const agentRuntimeSrcDir = getAgentRuntimeSrcDir(projectRoot);
+        await copyDirRecursive(agentRuntimeSrcDir, workDir);
+        const entrypointPath = path.join(workDir, AGENT_ENTRYPOINT_FILENAME);
+        const agentSource = await readFile(entrypointPath, "utf8");
+        if (!agentSource.includes(IMPORT_MARKER)) {
+            throw new Error(`Marker "${IMPORT_MARKER}" not found in ${entrypointPath}`);
+        }
+        const importStatements = testSuitePaths
+            .map((suitePath) => {
+            const absolute = path.resolve(suitePath).replace(/\\/g, "/");
+            const specifier = absolute.replace(/\.tsx?$/, "");
+            return `import ${JSON.stringify(specifier)};`;
+        })
+            .join("\n");
+        await rm(entrypointPath, { force: true });
+        await writeFile(entrypointPath, agentSource.replace(IMPORT_MARKER, importStatements), "utf8");
+        const outfilePath = path.join(workDir, AGENT_BUNDLE_FILENAME);
+        const fridaCompile = getFridaCompileBin(projectRoot);
+        let stdout;
+        let stderr;
+        try {
+            const args = fridaCompile.useLocal ? [entrypointPath, "-o", outfilePath] : ["frida-compile", entrypointPath, "-o", outfilePath];
+            ({ stdout, stderr } = await execFileAsync(fridaCompile.path, args, {
+                cwd: projectRoot,
+                shell: process.platform === "win32",
+            }));
+        }
+        catch (err) {
+            throw new Error(`frida-compile failed for entrypoint "${entrypointPath}" with suites [${testSuitePaths.join(", ")}]: ${err.message}`, { cause: err });
+        }
+        if (stdout.trim())
+            logger.log(`[frida-compile] ${stdout.trim()}`);
+        if (stderr.trim())
+            logger.warn(`[frida-compile] ${stderr.trim()}`);
+        return await readFile(outfilePath, "utf8");
+    }
+    finally {
+        if (!keep) {
+            await deleteWorkDir(workDir);
+        }
+    }
+}

package/dist/cli-frida-test-compiler.js

@@ -0,0 +1,38 @@
+const usage = `
+  Usage: frida-test-compiler [options] <src_path>...
+
+  Options:
+    -o, --out <path>                Path of the output file for JSON reporter (default: disabled)
+    -h, --help                      Show this help message
+`;
+import { writeFile } from "node:fs/promises";
+import { bundleAgent } from "./bundler.js";
+import { collectTestSuitePaths } from "./collector.js";
+const args = process.argv.slice(2);
+let outPath;
+const srcPaths = [];
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-o" || arg === "--out") {
+        outPath = args[++i];
+    }
+    else if (arg === "-h" || arg === "--help") {
+        console.log(usage);
+        process.exit(0);
+    }
+    else {
+        srcPaths.push(arg);
+    }
+}
+if (srcPaths.length === 0) {
+    console.error(usage);
+    process.exit(1);
+}
+const testSuitePaths = await collectTestSuitePaths(srcPaths);
+const bundle = await bundleAgent(testSuitePaths);
+if (outPath) {
+    await writeFile(outPath, bundle, "utf8");
+}
+else {
+    console.log(bundle);
+}

package/dist/cli-frida-test.js

@@ -0,0 +1,133 @@
+import chalk from "chalk";
+import { setTimeout as sleep } from "node:timers/promises";
+import { parseArgs } from "node:util";
+import { bundleAgent } from "./bundler.js";
+import { collectTestSuitePaths } from "./collector.js";
+import { resolveDevice, resolveTarget } from "./device.js";
+import { logger } from "./logger.js";
+import { writeRunSummaryJson } from "./reporter/json.js";
+import { printSummary } from "./reporter/summary.js";
+import { TestRunner } from "./runner.js";
+const usage = `
+  Usage: frida-test [options] <src_path>...
+
+  Options:
+    -i, --id <id>                   Bundle/package id or app name (spawns the app)
+    -p, --pid <id>                  Attach to a running process instead
+    -U, --usb                       Use the USB device
+    -D, --device <id>               Use a specific device by id
+    -o, --out <path>                Path of the output file for JSON reporter (default: disabled)
+    -t, --timeout <s>               Abort the run after this many seconds (default: 600, 0 disables)
+    -d, --delay <s>                 Start running the test suites after this many seconds (default: 0)
+    -k, --keep                      Keep the generated agent in .frida-test/agent.js
+    -v, --verbose                   Enable verbose logging
+    -h, --help                      Show this help message
+
+  Examples:
+    frida-test -U -i org.owasp.mastestapp ./test -r json -o ./testing/reports/out.json
+    frida-test -U --pid 4926 ./src/hooks.test.ts ./lib/utils
+`;
+class CliError extends Error {
+}
+function fail(message) {
+    throw new CliError(message);
+}
+function parseNonNegativeInt(value, name) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`${name} must be a non-negative integer`);
+    }
+    return n;
+}
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            id: { type: "string", short: "i" },
+            pid: { type: "string", short: "p" },
+            usb: { type: "boolean", short: "U", default: false },
+            device: { type: "string", short: "D" },
+            out: { type: "string", short: "o" },
+            delay: { type: "string", short: "d", default: "0" },
+            timeout: { type: "string", short: "t", default: "600" },
+            keep: { type: "boolean", short: "k", default: false },
+            verbose: { type: "boolean", short: "v", default: false },
+            help: { type: "boolean", short: "h", default: false },
+        },
+    });
+    if (values.help) {
+        console.log(usage);
+        return;
+    }
+    logger.setVerbose(values.verbose);
+    if (positionals.length === 0) {
+        fail("Missing required argument <src_path>...");
+    }
+    if (Boolean(values.id) === Boolean(values.pid)) {
+        fail("Must provide either --id (-i) or --pid (-p), but not both");
+    }
+    let targetDef;
+    if (values.id) {
+        targetDef = { id: values.id };
+    }
+    else {
+        const parsedPid = parseNonNegativeInt(values.pid, "pid");
+        if (parsedPid === 0)
+            fail("Invalid pid: must be greater than 0");
+        targetDef = { pid: parsedPid };
+    }
+    const delay = parseNonNegativeInt(values.delay, "delay");
+    const timeout = parseNonNegativeInt(values.timeout, "timeout");
+    const deviceSelector = values.device !== undefined ? { id: values.device } : values.usb ? "usb" : "local";
+    logger.info(`Collecting tests from ${positionals.join(", ")}...`);
+    const testSuitePaths = await collectTestSuitePaths(positionals);
+    logger.info(`Bundling testSuites with frida-test agent...`);
+    const agentBundle = await bundleAgent(testSuitePaths, values.keep);
+    logger.info(`Resolving devices...`);
+    const device = await resolveDevice(deviceSelector);
+    logger.info(`Resolving target...`);
+    const target = await resolveTarget(device, targetDef);
+    const runner = new TestRunner(device, target, agentBundle, values.verbose);
+    try {
+        logger.info(`Starting frida-test agent on the remote device...`);
+        await runner.initialize();
+        if (delay > 0) {
+            logger.info(`Waiting ${delay} second(s) before starting tests...`);
+            await sleep(delay * 1000);
+        }
+        let timerId;
+        const timeoutPromise = new Promise((_, reject) => {
+            if (timeout > 0) {
+                timerId = globalThis.setTimeout(() => {
+                    reject(new Error(`Test execution timed out after ${timeout} second(s)`));
+                }, timeout * 1000);
+            }
+        });
+        let runSummary;
+        try {
+            runSummary = await Promise.race([runner.runTests(), timeoutPromise]);
+        }
+        finally {
+            if (timerId)
+                globalThis.clearTimeout(timerId);
+        }
+        if (values.out) {
+            await writeRunSummaryJson(runSummary, values.out);
+        }
+        printSummary(runSummary);
+    }
+    finally {
+        await runner.dispose();
+    }
+}
+main().catch((error) => {
+    if (error instanceof CliError) {
+        logger.error(error.message);
+        console.log(chalk.dim(usage));
+    }
+    else {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.error(`Fatal error: ${msg}`);
+    }
+    process.exitCode = 1;
+});

package/dist/collector.js

@@ -0,0 +1,27 @@
+import { readdir, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const TEST_FILE_SUFFIX = ".test.ts";
+async function findTestFiles(absolutePath) {
+    let fileInfo;
+    try {
+        fileInfo = await stat(absolutePath);
+    }
+    catch (err) {
+        throw new Error(`Path does not exist: ${absolutePath}`, { cause: err });
+    }
+    if (fileInfo.isDirectory()) {
+        const entries = await readdir(absolutePath, {
+            recursive: true,
+            withFileTypes: true,
+        });
+        return entries.filter((entry) => entry.isFile() && entry.name.endsWith(TEST_FILE_SUFFIX)).map((entry) => join(entry.parentPath, entry.name));
+    }
+    if (absolutePath.endsWith(TEST_FILE_SUFFIX)) {
+        return [absolutePath];
+    }
+    throw new Error(`Not a *${TEST_FILE_SUFFIX} file: ${absolutePath}`);
+}
+export async function collectTestSuitePaths(srcPaths) {
+    const results = await Promise.all(srcPaths.map((p) => findTestFiles(resolve(p))));
+    return [...new Set(results.flat())].sort();
+}

package/dist/device.js

@@ -0,0 +1,38 @@
+import frida from "frida";
+export async function resolveDevice(selector = "local") {
+    if (selector === "usb")
+        return frida.getUsbDevice();
+    if (selector === "local")
+        return frida.getLocalDevice();
+    return frida.getDevice(selector.id);
+}
+export async function resolveTarget(device, targetDef) {
+    if ("pid" in targetDef)
+        return { pid: targetDef.pid, wasSpawned: false };
+    const { id } = targetDef;
+    if (!id.trim())
+        throw new Error("Target id must not be empty");
+    try {
+        const pid = await device.spawn(id);
+        return { pid, wasSpawned: true };
+    }
+    catch (spawnError) {
+        const needle = id.toLowerCase();
+        const processes = await device.enumerateProcesses();
+        const tiers = [
+            processes.filter((p) => p.name === id),
+            processes.filter((p) => p.name.toLowerCase() === needle),
+            processes.filter((p) => p.name.toLowerCase().includes(needle)),
+        ];
+        const matches = tiers.find((tier) => tier.length > 0) ?? [];
+        if (matches.length === 0) {
+            const reason = spawnError instanceof Error ? spawnError.message : String(spawnError);
+            throw new Error(`Unable to spawn '${id}' and no matching running process was found (spawn failed: ${reason}).`);
+        }
+        if (matches.length > 1) {
+            const names = matches.map((p) => `${p.name} (pid ${p.pid})`).join(", ");
+            throw new Error(`Ambiguous target '${id}', matches: ${names}`);
+        }
+        return { pid: matches[0].pid, wasSpawned: false };
+    }
+}

package/dist/logger.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+let verbose = false;
+export const logger = {
+    setVerbose: (value) => {
+        verbose = value;
+    },
+    info: (msg) => {
+        if (verbose)
+            console.log(`${chalk.blue("[i]")} ${msg}`);
+    },
+    log: (msg) => console.log(`${chalk.blue("[i]")} ${msg}`),
+    warn: (msg) => console.log(`${chalk.yellow("[!]")} ${msg}`),
+    error: (msg) => console.error(`${chalk.red("[!]")} ${msg}`),
+    success: (msg) => console.log(`${chalk.green("[✓]")} ${msg}`),
+};

package/dist/protocol.js

@@ -0,0 +1,6 @@
+export function isAgentMessage(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const { type } = value;
+    return type === "agent-ready" || type === "test-suite-started" || type === "test-suite-finished" || type === "run-finished";
+}

package/dist/reporter/console.js

@@ -0,0 +1,38 @@
+import { logger } from "../logger.js";
+import {} from "../protocol.js";
+const STATUS_SYMBOLS = {
+    passed: "✅",
+    failed: "❌",
+    skipped: "➖",
+};
+function printTestResult(node, depth = 0) {
+    const indent = "  ".repeat(depth);
+    const symbol = STATUS_SYMBOLS[node.status] || "?";
+    console.log(`${indent}${symbol} ${node.name} (${node.durationMs}ms)`);
+    if (node.error) {
+        const errorIndent = "  ".repeat(depth + 1);
+        console.error(`${errorIndent}Error: ${node.error.message}`);
+        if (node.error.stack) {
+            console.error(`${errorIndent}${node.error.stack.replace(/\n/g, `\n${errorIndent}`)}`);
+        }
+    }
+    if (node.children && node.children.length > 0) {
+        for (const child of node.children) {
+            printTestResult(child, depth + 1);
+        }
+    }
+}
+export function printTestSuiteResult(suite) {
+    if (suite.status == "failed") {
+        logger.warn(`Test suite "${suite.name}" failed:`);
+    }
+    else if (suite.status == "passed") {
+        logger.success(`Test suite "${suite.name}" passed:`);
+    }
+    if (suite.testResult) {
+        printTestResult(suite.testResult, 1);
+    }
+    else {
+        logger.warn(`No results for test suite  "${suite.name}".`);
+    }
+}

package/dist/reporter/json.js

@@ -0,0 +1,6 @@
+import { writeFile } from "node:fs/promises";
+import { logger } from "../logger.js";
+export async function writeRunSummaryJson(result, outPath) {
+    await writeFile(outPath, JSON.stringify(result, null, 2), "utf-8");
+    logger.info(`JSON report saved to ${outPath}`);
+}

package/dist/reporter/summary.js

@@ -0,0 +1,41 @@
+import chalk from "chalk";
+function formatDuration(ms) {
+    return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(2)}s`;
+}
+function formatCount(passed, failed, total) {
+    const parts = [];
+    if (passed > 0)
+        parts.push(chalk.green(`${passed} passed`));
+    if (failed > 0)
+        parts.push(chalk.red(`${failed} failed`));
+    parts.push(`${total} total`);
+    return parts.join(", ");
+}
+export function printSummary(runSummary) {
+    const { total, passed, failed, durationMs, testSuitesResults } = runSummary;
+    const suitePassed = testSuitesResults.filter((s) => s.status === "passed").length;
+    const suiteFailed = testSuitesResults.length - suitePassed;
+    console.log();
+    console.log("------------------------------------------------------------------------------");
+    console.log();
+    console.log(chalk.bold("Test Suites"));
+    for (const suite of testSuitesResults) {
+        const isPassed = suite.status === "passed";
+        console.log(`  ${isPassed ? chalk.green("✓") : chalk.red("✗")} ${suite.name}`);
+        if (!isPassed && suite.testResult?.name) {
+            for (const line of suite.testResult.name.split("\n")) {
+                console.log(chalk.red(`      ${line}`));
+            }
+        }
+    }
+    console.log();
+    console.log(chalk.bold("Summary"));
+    console.log(`  Suites:   ${formatCount(suitePassed, suiteFailed, testSuitesResults.length)}`);
+    console.log(`  Tests:    ${formatCount(passed, failed, total)}`);
+    console.log(`  Duration: ${formatDuration(durationMs)}`);
+    console.log();
+    const badge = failed > 0 ? chalk.bgRed.black.bold(" FAIL ") : chalk.bgGreen.black.bold(" PASS ");
+    const tail = failed > 0 ? chalk.red(`${failed} test(s) failed`) : chalk.green("All tests passed");
+    console.log(`${badge} ${tail}`);
+    console.log();
+}